From 4b20ccafaa3bacfd11c5fcc61e1647dbbefe7bad Mon Sep 17 00:00:00 2001 From: Mattias Jonsson Date: Mon, 16 Aug 2010 14:53:30 +0200 Subject: Bug#49907: ALTER TABLE ... TRUNCATE PARTITION does not wait for locks on the table Fixing the partitioning specifics after TRUNCATE TABLE in bug-42643 was fixed. Reorganize of code to decrease the size of the giant switch in mysql_execute_command, and to prepare for future parser reengineering. Moved code into Sql_statement objects. Updated patch according to davi's review comments. libmysqld/CMakeLists.txt: Added new files. libmysqld/Makefile.am: Added new files. mysql-test/r/not_partition.result: now returning error on partitioning commands if partitioning is not enabled. mysql-test/r/partition_disabled.result: There is no partition handlerton, so it cannot find the specified engine in the .frm file. mysql-test/r/partition_truncate.result: Updated test results. mysql-test/suite/parts/inc/partition_mgm.inc: Added check that TRUNCATE PARTITION does not delete on failure. mysql-test/suite/parts/r/partition_debug_sync_innodb.result: updated results. mysql-test/suite/parts/r/partition_mgm_lc0_archive.result: updated results. mysql-test/suite/parts/r/partition_mgm_lc1_archive.result: updated results. mysql-test/suite/parts/r/partition_mgm_lc2_archive.result: updated results. mysql-test/suite/parts/t/partition_debug_sync_innodb.test: Test case for this bug. mysql-test/t/not_partition.test: Added check for TRUNCATE PARTITION without partitioning. mysql-test/t/partition_truncate.test: Added test of TRUNCATE PARTITION on non partitioned table. sql/CMakeLists.txt: Added new files. sql/Makefile.am: Added new files. sql/datadict.cc: Moved out the storage engine check into an own function, including assert for lock. sql/datadict.h: added dd_frm_storage_engine. sql/sql_alter_table.cc: moved the code for SQLCOM_ALTER_TABLE in mysql_execute_command into its own file, and using the Sql_statement object to prepare for future parser reengineering. sql/sql_alter_table.h: Created Sql_statement object for ALTER TABLE. sql/sql_lex.cc: resetting m_stmt. sql/sql_lex.h: Temporary hack for forward declaration of enum_alter_table_change_level. sql/sql_parse.cc: Moved out ALTER/ANALYZE/CHECK/OPTIMIZE/REPAIR TABLE from the giant switch into their own Sql_statement objects. sql/sql_parse.h: Exporting check_merge_table_access. sql/sql_partition_admin.cc: created Sql_statement for ALTER TABLE t ANALYZE/CHECK/OPTIMIZE/REPAIR/TRUNCATE PARTITION. To be able to reuse the TABLE equivalents. sql/sql_partition_admin.h: Added Sql_statement of partition admin statements. sql/sql_table.cc: Moved table maintenance code into sql_table_maintenance.cc sql/sql_table.h: Moved table maintenance code into sql_table_maintenance.h exporting functions used by sql_table_maintenance. sql/sql_table_maintenance.cc: Moved table maintenance code from sql_table.cc sql/sql_table_maintenance.h: Sql_statement objects for ANALYZE/CHECK/OPTIMIZE/REPAIR TABLE. Also declaring the keycache functions. sql/sql_truncate.cc: Moved code from SQLCOM_TRUNCATE in mysql_execute_command into Truncate_statement::execute. Added check for partitioned table on TRUNCATE PARTITION. Moved locking fix for partitioned table into Alter_table_truncate_partition::execute. sql/sql_truncate.h: Truncate_statement declaration (sub class of Sql_statement). sql/sql_yacc.yy: Using the new Sql_statment objects. --- sql/sql_partition_admin.h | 236 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 236 insertions(+) create mode 100644 sql/sql_partition_admin.h (limited to 'sql/sql_partition_admin.h') diff --git a/sql/sql_partition_admin.h b/sql/sql_partition_admin.h new file mode 100644 index 00000000000..36bafec4202 --- /dev/null +++ b/sql/sql_partition_admin.h @@ -0,0 +1,236 @@ +/* Copyright (c) 2010 Oracle and/or its affiliates. All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ + +#ifndef SQL_PARTITION_ADMIN_H +#define SQL_PARTITION_ADMIN_H + +#ifndef WITH_PARTITION_STORAGE_ENGINE + +/** + Stub class that returns a error if the partition storage engine is + not supported. +*/ +class Partition_statement_unsupported : public Sql_statement +{ +public: + Partition_statement_unsupported(LEX *lex) + : Sql_statement(lex) + {} + + ~Partition_statement_unsupported() + {} + + bool execute(THD *thd); +}; + + +class Alter_table_analyze_partition_statement : + public Partition_statement_unsupported +{ +public: + Alter_table_analyze_partition_statement(LEX *lex) + : Partition_statement_unsupported(lex) + {} + + ~Alter_table_analyze_partition_statement() + {} +}; + + +class Alter_table_check_partition_statement : + public Partition_statement_unsupported +{ +public: + Alter_table_check_partition_statement(LEX *lex) + : Partition_statement_unsupported(lex) + {} + + ~Alter_table_check_partition_statement() + {} +}; + + +class Alter_table_optimize_partition_statement : + public Partition_statement_unsupported +{ +public: + Alter_table_optimize_partition_statement(LEX *lex) + : Partition_statement_unsupported(lex) + {} + + ~Alter_table_optimize_partition_statement() + {} +}; + + +class Alter_table_repair_partition_statement : + public Partition_statement_unsupported +{ +public: + Alter_table_repair_partition_statement(LEX *lex) + : Partition_statement_unsupported(lex) + {} + + ~Alter_table_repair_partition_statement() + {} +}; + + +class Alter_table_truncate_partition_statement : + public Partition_statement_unsupported +{ +public: + Alter_table_truncate_partition_statement(LEX *lex) + : Partition_statement_unsupported(lex) + {} + + ~Alter_table_truncate_partition_statement() + {} +}; + + +#else + +/** + Class that represents the ALTER TABLE t1 ANALYZE PARTITION p statement. +*/ +class Alter_table_analyze_partition_statement : public Analyze_table_statement +{ +public: + /** + Constructor, used to represent a ALTER TABLE ANALYZE PARTITION statement. + @param lex the LEX structure for this statement. + */ + Alter_table_analyze_partition_statement(LEX *lex) + : Analyze_table_statement(lex) + {} + + ~Alter_table_analyze_partition_statement() + {} + + /** + Execute a ALTER TABLE ANALYZE PARTITION statement at runtime. + @param thd the current thread. + @return false on success. + */ + bool execute(THD *thd); +}; + + +/** + Class that represents the ALTER TABLE t1 CHECK PARTITION p statement. +*/ +class Alter_table_check_partition_statement : public Check_table_statement +{ +public: + /** + Constructor, used to represent a ALTER TABLE CHECK PARTITION statement. + @param lex the LEX structure for this statement. + */ + Alter_table_check_partition_statement(LEX *lex) + : Check_table_statement(lex) + {} + + ~Alter_table_check_partition_statement() + {} + + /** + Execute a ALTER TABLE CHECK PARTITION statement at runtime. + @param thd the current thread. + @return false on success. + */ + bool execute(THD *thd); +}; + + +/** + Class that represents the ALTER TABLE t1 OPTIMIZE PARTITION p statement. +*/ +class Alter_table_optimize_partition_statement : public Optimize_table_statement +{ +public: + /** + Constructor, used to represent a ALTER TABLE OPTIMIZE PARTITION statement. + @param lex the LEX structure for this statement. + */ + Alter_table_optimize_partition_statement(LEX *lex) + : Optimize_table_statement(lex) + {} + + ~Alter_table_optimize_partition_statement() + {} + + /** + Execute a ALTER TABLE OPTIMIZE PARTITION statement at runtime. + @param thd the current thread. + @return false on success. + */ + bool execute(THD *thd); +}; + + +/** + Class that represents the ALTER TABLE t1 REPAIR PARTITION p statement. +*/ +class Alter_table_repair_partition_statement : public Repair_table_statement +{ +public: + /** + Constructor, used to represent a ALTER TABLE REPAIR PARTITION statement. + @param lex the LEX structure for this statement. + */ + Alter_table_repair_partition_statement(LEX *lex) + : Repair_table_statement(lex) + {} + + ~Alter_table_repair_partition_statement() + {} + + /** + Execute a ALTER TABLE REPAIR PARTITION statement at runtime. + @param thd the current thread. + @return false on success. + */ + bool execute(THD *thd); +}; + + +/** + Class that represents the ALTER TABLE t1 TRUNCATE PARTITION p statement. +*/ +class Alter_table_truncate_partition_statement : public Truncate_statement +{ +public: + /** + Constructor, used to represent a ALTER TABLE TRUNCATE PARTITION statement. + @param lex the LEX structure for this statement. + */ + Alter_table_truncate_partition_statement(LEX *lex) + : Truncate_statement(lex) + {} + + ~Alter_table_truncate_partition_statement() + {} + + /** + Execute a ALTER TABLE TRUNCATE PARTITION statement at runtime. + @param thd the current thread. + @return false on success. + */ + bool execute(THD *thd); +}; + +#endif /* WITH_PARTITION_STORAGE_ENGINE */ +#endif /* SQL_PARTITION_ADMIN_H */ -- cgit v1.2.1