merge

libmysqld/CMakeLists.txt

@@ -64,7 +64,7 @@ SET(SQL_EMBEDDED_SOURCES emb_qcache.cc libmysqld.c lib_sql.cc
            ../sql/sql_db.cc ../sql/sql_delete.cc ../sql/sql_derived.cc 
            ../sql/sql_do.cc ../sql/sql_error.cc ../sql/sql_handler.cc 
            ../sql/sql_help.cc ../sql/sql_insert.cc ../sql/datadict.cc
-           ../sql/sql_truncate.cc
+           ../sql/sql_table_maintenance.cc ../sql/sql_truncate.cc
            ../sql/sql_lex.cc ../sql/keycaches.cc
            ../sql/sql_list.cc ../sql/sql_load.cc ../sql/sql_locale.cc 
            ../sql/sql_binlog.cc ../sql/sql_manager.cc
@@ -80,6 +80,7 @@ SET(SQL_EMBEDDED_SOURCES emb_qcache.cc libmysqld.c lib_sql.cc
            ../sql/sql_time.cc ../sql/tztime.cc ../sql/uniques.cc ../sql/unireg.cc
            ../sql/partition_info.cc ../sql/sql_connect.cc 
            ../sql/scheduler.cc ../sql/sql_audit.cc
+           ../sql/sql_alter_table.cc ../sql/sql_partition_admin.cc
            ../sql/event_parse_data.cc
            ../sql/sql_signal.cc ../sql/rpl_handler.cc
 	       ../sql/rpl_utility.cc

libmysqld/Makefile.am

@@ -63,7 +63,7 @@ sqlsources = derror.cc field.cc field_conv.cc strfunc.cc filesort.cc \
 	protocol.cc net_serv.cc opt_range.cc \
 	opt_sum.cc procedure.cc records.cc sql_acl.cc \
 	sql_load.cc discover.cc sql_locale.cc \
-	sql_profile.cc sql_truncate.cc datadict.cc \
+	sql_profile.cc sql_table_maintenance.cc sql_truncate.cc datadict.cc \
 	sql_analyse.cc sql_base.cc sql_cache.cc sql_class.cc \
 	sql_crypt.cc sql_db.cc sql_delete.cc sql_error.cc sql_insert.cc \
 	sql_lex.cc sql_list.cc sql_manager.cc \
@@ -78,9 +78,10 @@ sqlsources = derror.cc field.cc field_conv.cc strfunc.cc filesort.cc \
 	parse_file.cc sql_view.cc sql_trigger.cc my_decimal.cc \
 	rpl_filter.cc sql_partition.cc sql_builtin.cc sql_plugin.cc \
 	debug_sync.cc sql_tablespace.cc transaction.cc \
-	rpl_injector.cc my_user.c partition_info.cc \
+	rpl_injector.cc my_user.c partition_info.cc sql_alter_table.cc \
 	sql_servers.cc event_parse_data.cc sql_signal.cc \
-	rpl_handler.cc mdl.cc keycaches.cc sql_audit.cc
+	rpl_handler.cc mdl.cc keycaches.cc sql_audit.cc \
+	sql_partition_admin.cc
 
 libmysqld_int_a_SOURCES= $(libmysqld_sources)
 nodist_libmysqld_int_a_SOURCES= $(libmysqlsources) $(sqlsources)

mysql-test/r/not_partition.result

@@ -21,23 +21,17 @@ Table	Op	Msg_type	Msg_text
 test.t1	repair	Error	Unknown storage engine 'partition'
 test.t1	repair	error	Corrupt
 ALTER TABLE t1 REPAIR PARTITION ALL;
-Table	Op	Msg_type	Msg_text
-test.t1	repair	Error	Unknown storage engine 'partition'
-test.t1	repair	error	Corrupt
+ERROR HY000: The 'partitioning' feature is disabled; you need MySQL built with '--with-plugin-partition' to have it working
 ALTER TABLE t1 CHECK PARTITION ALL;
-Table	Op	Msg_type	Msg_text
-test.t1	check	Error	Unknown storage engine 'partition'
-test.t1	check	error	Corrupt
+ERROR HY000: The 'partitioning' feature is disabled; you need MySQL built with '--with-plugin-partition' to have it working
 ALTER TABLE t1 OPTIMIZE PARTITION ALL;
-Table	Op	Msg_type	Msg_text
-test.t1	optimize	Error	Unknown storage engine 'partition'
-test.t1	optimize	error	Corrupt
+ERROR HY000: The 'partitioning' feature is disabled; you need MySQL built with '--with-plugin-partition' to have it working
 ALTER TABLE t1 ANALYZE PARTITION ALL;
-Table	Op	Msg_type	Msg_text
-test.t1	analyze	Error	Unknown storage engine 'partition'
-test.t1	analyze	error	Corrupt
+ERROR HY000: The 'partitioning' feature is disabled; you need MySQL built with '--with-plugin-partition' to have it working
 ALTER TABLE t1 REBUILD PARTITION ALL;
 ERROR 42000: Unknown storage engine 'partition'
+ALTER TABLE t1 TRUNCATE PARTITION ALL;
+ERROR HY000: The 'partitioning' feature is disabled; you need MySQL built with '--with-plugin-partition' to have it working
 ALTER TABLE t1 ENGINE Memory;
 ERROR 42000: Unknown storage engine 'partition'
 ALTER TABLE t1 ADD (new INT);

mysql-test/r/partition_disabled.result

@@ -3,7 +3,7 @@ FLUSH TABLES;
 SELECT * FROM t1;
 ERROR HY000: The MySQL server is running with the --skip-partition option so it cannot execute this statement
 TRUNCATE TABLE t1;
-ERROR HY000: The MySQL server is running with the --skip-partition option so it cannot execute this statement
+ERROR 42S02: Table 'test.t1' doesn't exist
 ANALYZE TABLE t1;
 Table	Op	Msg_type	Msg_text
 test.t1	analyze	Error	The MySQL server is running with the --skip-partition option so it cannot execute this statement

mysql-test/r/partition_truncate.result

@@ -16,3 +16,11 @@ subpartitions 1
 alter table t1 truncate partition sp1;
 ERROR HY000: Incorrect partition name
 drop table t1;
+create table t1 (a int);
+insert into t1 values (1), (3), (8);
+alter table t1 truncate partition p0;
+ERROR HY000: Partition management on a not partitioned table is not possible
+select count(*) from t1;
+count(*)
+3
+drop table t1;

mysql-test/suite/parts/inc/partition_mgm.inc

@@ -533,6 +533,8 @@ PARTITION BY KEY (a)
 INSERT INTO t1 VALUES (NULL, "First"), (NULL, "Second"), (999, "Last in LT1000"), (NULL, "First in LT2000"), (NULL, "Second in LT2000"), (1999, "Last in LT2000"), (NULL, "First in MAX"), (NULL, "Second in MAX");
 --error ER_PARTITION_MGMT_ON_NONPARTITIONED, ER_ILLEGAL_HA
 ALTER TABLE t1 TRUNCATE PARTITION MAX;
+--sorted_result
+SELECT * FROM t1;
 }
 if (!$no_truncate)
 {

mysql-test/suite/parts/r/partition_debug_sync_innodb.result

 #
+# Bug#49907: ALTER TABLE ... TRUNCATE PARTITION
+#            does not wait for locks on the table
+#
+CREATE TABLE t1 (a INT)
+ENGINE = InnoDB
+PARTITION BY RANGE (a)
+(PARTITION p0 VALUES LESS THAN (15),
+PARTITION pMax VALUES LESS THAN MAXVALUE);
+INSERT INTO t1 VALUES (1), (11), (21), (33);
+BEGIN;
+DELETE FROM t1 WHERE a = 11;
+SELECT * FROM t1;
+a
+1
+21
+33
+# con1 (send)
+ALTER TABLE t1 TRUNCATE PARTITION pMax;
+# con default
+SELECT * FROM t1;
+a
+1
+21
+33
+# Commit will allow the TRUNCATE to finish
+COMMIT;
+# con1 (reap)
+# con1 (disconnect)
+# default connection
+SELECT * FROM t1;
+a
+1
+DROP TABLE t1;
+#
 # Bug#50561: ALTER PARTITIONS does not have adequate lock, breaks with
 #            concurrent I_S query
 create table t1 (a int)

mysql-test/suite/parts/r/partition_mgm_lc0_archive.result

@@ -927,6 +927,16 @@ PARTITION MAX);
 INSERT INTO t1 VALUES (NULL, "First"), (NULL, "Second"), (999, "Last in LT1000"), (NULL, "First in LT2000"), (NULL, "Second in LT2000"), (1999, "Last in LT2000"), (NULL, "First in MAX"), (NULL, "Second in MAX");
 ALTER TABLE t1 TRUNCATE PARTITION MAX;
 Got one of the listed errors
+SELECT * FROM t1;
+a	b
+1	First
+1000	First in LT2000
+1001	Second in LT2000
+1999	Last in LT2000
+2	Second
+2000	First in MAX
+2001	Second in MAX
+999	Last in LT1000
 # Cleaning up before exit
 USE test;
 DROP DATABASE MySQL_Test_DB;

mysql-test/suite/parts/r/partition_mgm_lc1_archive.result

@@ -894,6 +894,16 @@ PARTITION MAX);
 INSERT INTO t1 VALUES (NULL, "First"), (NULL, "Second"), (999, "Last in LT1000"), (NULL, "First in LT2000"), (NULL, "Second in LT2000"), (1999, "Last in LT2000"), (NULL, "First in MAX"), (NULL, "Second in MAX");
 ALTER TABLE t1 TRUNCATE PARTITION MAX;
 Got one of the listed errors
+SELECT * FROM t1;
+a	b
+1	First
+1000	First in LT2000
+1001	Second in LT2000
+1999	Last in LT2000
+2	Second
+2000	First in MAX
+2001	Second in MAX
+999	Last in LT1000
 # Cleaning up before exit
 USE test;
 DROP DATABASE MySQL_Test_DB;

mysql-test/suite/parts/r/partition_mgm_lc2_archive.result

@@ -894,6 +894,16 @@ PARTITION MAX);
 INSERT INTO t1 VALUES (NULL, "First"), (NULL, "Second"), (999, "Last in LT1000"), (NULL, "First in LT2000"), (NULL, "Second in LT2000"), (1999, "Last in LT2000"), (NULL, "First in MAX"), (NULL, "Second in MAX");
 ALTER TABLE t1 TRUNCATE PARTITION MAX;
 Got one of the listed errors
+SELECT * FROM t1;
+a	b
+1	First
+1000	First in LT2000
+1001	Second in LT2000
+1999	Last in LT2000
+2	Second
+2000	First in MAX
+2001	Second in MAX
+999	Last in LT1000
 # Cleaning up before exit
 USE test;
 DROP DATABASE MySQL_Test_DB;

mysql-test/suite/parts/t/partition_debug_sync_innodb.test

@@ -4,6 +4,47 @@
 
 let $MYSQLD_DATADIR=`SELECT @@datadir`;
 
+--echo #
+--echo # Bug#49907: ALTER TABLE ... TRUNCATE PARTITION
+--echo #            does not wait for locks on the table
+--echo #
+CREATE TABLE t1 (a INT)
+ENGINE = InnoDB
+PARTITION BY RANGE (a)
+(PARTITION p0 VALUES LESS THAN (15),
+ PARTITION pMax VALUES LESS THAN MAXVALUE);
+INSERT INTO t1 VALUES (1), (11), (21), (33);
+BEGIN;
+DELETE FROM t1 WHERE a = 11;
+--sorted_result
+SELECT * FROM t1;
+
+--connect (con1, localhost, root,,)
+--echo # con1 (send)
+--send
+ALTER TABLE t1 TRUNCATE PARTITION pMax;
+
+--connection default
+--echo # con default
+let $wait_condition=
+  SELECT COUNT(*) = 1 FROM INFORMATION_SCHEMA.PROCESSLIST
+    WHERE STATE = "Waiting for table" AND INFO = "ALTER TABLE t1 TRUNCATE PARTITION pMax";
+--source include/wait_condition.inc
+--sorted_result
+SELECT * FROM t1;
+--echo # Commit will allow the TRUNCATE to finish
+COMMIT;
+
+--echo # con1 (reap)
+--connection con1
+--reap
+--echo # con1 (disconnect)
+--disconnect con1
+--connection default
+--echo # default connection
+SELECT * FROM t1;
+DROP TABLE t1;
+
 --echo #
 --echo # Bug#50561: ALTER PARTITIONS does not have adequate lock, breaks with
 --echo #            concurrent I_S query

mysql-test/t/not_partition.test

@@ -27,6 +27,7 @@ ALTER TABLE t1 CHECK PARTITION ALL;
 ALTER TABLE t1 OPTIMIZE PARTITION ALL;
 ALTER TABLE t1 ANALYZE PARTITION ALL;
 ALTER TABLE t1 REBUILD PARTITION ALL;
+ALTER TABLE t1 TRUNCATE PARTITION ALL;
 ALTER TABLE t1 ENGINE Memory;
 ALTER TABLE t1 ADD (new INT);
 DROP TABLE t1;

mysql-test/t/partition_truncate.test

@@ -24,3 +24,10 @@ subpartitions 1
 --error ER_WRONG_PARTITION_NAME
 alter table t1 truncate partition sp1;
 drop table t1;
+
+create table t1 (a int);
+insert into t1 values (1), (3), (8);
+--error ER_PARTITION_MGMT_ON_NONPARTITIONED
+alter table t1 truncate partition p0;
+select count(*) from t1;
+drop table t1;

sql/CMakeLists.txt

@@ -70,9 +70,9 @@ SET (SQL_SOURCE
                sql_tablespace.cc events.cc ../sql-common/my_user.c 
                partition_info.cc rpl_utility.cc rpl_injector.cc sql_locale.cc
                rpl_rli.cc rpl_mi.cc sql_servers.cc sql_audit.cc
-               sql_connect.cc scheduler.cc 
-               sql_profile.cc event_parse_data.cc
-               sql_signal.cc rpl_handler.cc mdl.cc
+               sql_connect.cc scheduler.cc sql_partition_admin.cc
+               sql_profile.cc event_parse_data.cc sql_alter_table.cc
+               sql_signal.cc rpl_handler.cc mdl.cc sql_table_maintenance.cc
                transaction.cc sys_vars.cc sql_truncate.cc datadict.cc
                ${GEN_SOURCES}
                ${MYSYS_LIBWRAP_SOURCE})

sql/Makefile.am

@@ -122,11 +122,11 @@ noinst_HEADERS =	item.h item_func.h item_sum.h item_cmpfunc.h \
 			sql_plugin.h authors.h event_parse_data.h \
 			event_data_objects.h event_scheduler.h \
 			sql_partition.h partition_info.h partition_element.h \
-			sql_audit.h \
+			sql_audit.h sql_alter_table.h sql_partition_admin.h \
 			contributors.h sql_servers.h sql_signal.h records.h \
 			sql_prepare.h rpl_handler.h replication.h mdl.h \
 			sql_plist.h transaction.h sys_vars.h sql_truncate.h \
-			datadict.h
+			sql_table_maintenance.h datadict.h
 
 mysqld_SOURCES =	sql_lex.cc sql_handler.cc sql_partition.cc \
 			item.cc item_sum.cc item_buff.cc item_func.cc \
@@ -143,7 +143,8 @@ mysqld_SOURCES =	sql_lex.cc sql_handler.cc sql_partition.cc \
 			datadict.cc sql_profile.cc \
 			sql_prepare.cc sql_error.cc sql_locale.cc \
 			sql_update.cc sql_delete.cc uniques.cc sql_do.cc \
-			procedure.cc sql_test.cc sql_truncate.cc \
+			procedure.cc sql_test.cc sql_table_maintenance.cc \
+                        sql_truncate.cc \
 			log.cc init.cc derror.cc sql_acl.cc \
 			unireg.cc des_key_file.cc \
 			log_event.cc rpl_record.cc \
@@ -171,7 +172,7 @@ mysqld_SOURCES =	sql_lex.cc sql_handler.cc sql_partition.cc \
 			sql_builtin.cc sql_tablespace.cc partition_info.cc \
 			sql_servers.cc event_parse_data.cc sql_signal.cc \
 			rpl_handler.cc mdl.cc transaction.cc sql_audit.cc  \
-			sha2.cc
+			sql_alter_table.cc sql_partition_admin.cc sha2.cc
 
 nodist_mysqld_SOURCES =	mini_client_errors.c pack.c client.c my_time.c my_user.c 
 

sql/datadict.cc

@@ -22,7 +22,9 @@
 /**
   Check type of .frm if we are not going to parse it.
 
-  @param  path  path to FRM file
+  @param[in]  thd   The current session.
+  @param[in]  path  path to FRM file.
+  @param[out] dbt   db_type of the table if FRMTYPE_TABLE, otherwise undefined.
 
   @retval  FRMTYPE_ERROR        error
   @retval  FRMTYPE_TABLE        table
@@ -66,29 +68,28 @@ frm_type_enum dd_frm_type(THD *thd, char *path, enum legacy_db_type *dbt)
 
 
 /**
-  Given a table name, check if the storage engine for the
-  table referred by this name supports an option 'flag'.
-  Return an error if the table does not exist or is not a
-  base table.
-
-  @pre Any metadata lock on the table.
+  Given a table name, check type of .frm and legacy table type.
 
   @param[in]   thd          The current session.
   @param[in]   db           Table schema.
   @param[in]   table_name   Table database.
-  @param[in]    flag        The option to check.
-  @param[out]   yes_no      The result. Undefined if error.
+  @param[out]  table_type   handlerton of the table if FRMTYPE_TABLE,
+                            otherwise undefined.
+
+  @return FALSE if FRMTYPE_TABLE and storage engine found. TRUE otherwise.
 */
 
-bool dd_check_storage_engine_flag(THD *thd,
-                                  const char *db, const char *table_name,
-                                  uint32 flag, bool *yes_no)
+bool dd_frm_storage_engine(THD *thd, const char *db, const char *table_name,
+                           handlerton **table_type)
 {
   char path[FN_REFLEN + 1];
   enum legacy_db_type db_type;
-  handlerton *table_type;
   LEX_STRING db_name = {(char *) db, strlen(db)};
 
+  /* There should be at least some lock on the table.  */
+  DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, db,
+                                             table_name, MDL_SHARED));
+
   if (check_db_name(&db_name))
   {
     my_error(ER_WRONG_DB_NAME, MYF(0), db_name.str);
@@ -101,23 +102,47 @@ bool dd_check_storage_engine_flag(THD *thd,
     return TRUE;
   }
 
-  /* There should be at least some lock on the table.  */
-  DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, db,
-                                             table_name, MDL_SHARED));
-
   (void) build_table_filename(path, sizeof(path) - 1, db,
                               table_name, reg_ext, 0);
 
   dd_frm_type(thd, path, &db_type);
 
   /* Type is unknown if the object is not found or is not a table. */
-  if (db_type == DB_TYPE_UNKNOWN)
+  if (db_type == DB_TYPE_UNKNOWN ||
+      !(*table_type= ha_resolve_by_legacy_type(thd, db_type)))
   {
     my_error(ER_NO_SUCH_TABLE, MYF(0), db, table_name);
     return TRUE;
   }
 
-  table_type= ha_resolve_by_legacy_type(thd, db_type);
+  return FALSE;
+}
+
+
+/**
+  Given a table name, check if the storage engine for the
+  table referred by this name supports an option 'flag'.
+  Return an error if the table does not exist or is not a
+  base table.
+
+  @pre Any metadata lock on the table.
+
+  @param[in]    thd         The current session.
+  @param[in]    db          Table schema.
+  @param[in]    table_name  Table database.
+  @param[in]    flag        The option to check.
+  @param[out]   yes_no      The result. Undefined if error.
+*/
+
+bool dd_check_storage_engine_flag(THD *thd,
+                                  const char *db, const char *table_name,
+                                  uint32 flag, bool *yes_no)
+{
+  handlerton *table_type;
+
+  if (dd_frm_storage_engine(thd, db, table_name, &table_type))
+    return TRUE;
+
   *yes_no= ha_check_storage_engine_flag(table_type, flag);
 
   return FALSE;

sql/datadict.h

@@ -31,6 +31,8 @@ enum frm_type_enum
 
 frm_type_enum dd_frm_type(THD *thd, char *path, enum legacy_db_type *dbt);
 
+bool dd_frm_storage_engine(THD *thd, const char *db, const char *table_name,
+                           handlerton **table_type);
 bool dd_check_storage_engine_flag(THD *thd,
                                   const char *db, const char *table_name,
                                   uint32 flag,

sql/sql_alter_table.cc

+/* 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 */
+
+#include "sql_parse.h"                       // check_access,
+                                             // check_merge_table_access
+#include "sql_table.h"                       // mysql_alter_table,
+                                             // mysql_exchange_partition
+#include "sql_alter_table.h"
+
+bool Alter_table_statement::execute(THD *thd)
+{
+  LEX *lex= thd->lex;
+  /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
+  SELECT_LEX *select_lex= &lex->select_lex;
+  /* first table of first SELECT_LEX */
+  TABLE_LIST *first_table= (TABLE_LIST*) select_lex->table_list.first;
+  /*
+    Code in mysql_alter_table() may modify its HA_CREATE_INFO argument,
+    so we have to use a copy of this structure to make execution
+    prepared statement- safe. A shallow copy is enough as no memory
+    referenced from this structure will be modified.
+    @todo move these into constructor...
+  */
+  HA_CREATE_INFO create_info(lex->create_info);
+  Alter_info alter_info(lex->alter_info, thd->mem_root);
+  ulong priv=0;
+  ulong priv_needed= ALTER_ACL;
+  bool result;
+
+  DBUG_ENTER("Alter_table_statement::execute");
+
+  if (thd->is_fatal_error) /* out of memory creating a copy of alter_info */
+    DBUG_RETURN(TRUE);
+  /*
+    We also require DROP priv for ALTER TABLE ... DROP PARTITION, as well
+    as for RENAME TO, as being done by SQLCOM_RENAME_TABLE
+  */
+  if (alter_info.flags & (ALTER_DROP_PARTITION | ALTER_RENAME))
+    priv_needed|= DROP_ACL;
+
+  /* Must be set in the parser */
+  DBUG_ASSERT(select_lex->db);
+  DBUG_ASSERT(!(alter_info.flags & ALTER_ADMIN_PARTITION));
+  if (check_access(thd, priv_needed, first_table->db,
+                   &first_table->grant.privilege,
+                   &first_table->grant.m_internal,
+                   0, 0) ||
+      check_access(thd, INSERT_ACL | CREATE_ACL, select_lex->db,
+                   &priv,
+                   NULL, /* Don't use first_tab->grant with sel_lex->db */
+                   0, 0) ||
+      check_merge_table_access(thd, first_table->db,
+                               create_info.merge_list.first))
+    DBUG_RETURN(TRUE);                  /* purecov: inspected */
+
+  if (check_grant(thd, priv_needed, first_table, FALSE, UINT_MAX, FALSE))
+    DBUG_RETURN(TRUE);                  /* purecov: inspected */
+
+  if (lex->name.str && !test_all_bits(priv, INSERT_ACL | CREATE_ACL))
+  {
+    // Rename of table
+    TABLE_LIST tmp_table;
+    bzero((char*) &tmp_table,sizeof(tmp_table));
+    tmp_table.table_name= lex->name.str;
+    tmp_table.db= select_lex->db;
+    tmp_table.grant.privilege= priv;
+    if (check_grant(thd, INSERT_ACL | CREATE_ACL, &tmp_table, FALSE,
+                    UINT_MAX, FALSE))
+      DBUG_RETURN(TRUE);                  /* purecov: inspected */
+  }
+
+  /* Don't yet allow changing of symlinks with ALTER TABLE */
+  if (create_info.data_file_name)
+    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+                        WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED),
+                        "DATA DIRECTORY");
+  if (create_info.index_file_name)
+    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+                        WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED),
+                        "INDEX DIRECTORY");
+  create_info.data_file_name= create_info.index_file_name= NULL;
+
+  thd->enable_slow_log= opt_log_slow_admin_statements;
+
+  result= mysql_alter_table(thd, select_lex->db, lex->name.str,
+                            &create_info,
+                            first_table,
+                            &alter_info,
+                            select_lex->order_list.elements,
+                            select_lex->order_list.first,
+                            lex->ignore);
+
+  DBUG_RETURN(result);
+}

sql/sql_alter_table.h

+/* 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_ALTER_TABLE_H
+#define SQL_ALTER_TABLE_H
+
+/**
+  Alter_table_common represents the common properties of the ALTER TABLE
+  statements.
+  @todo move Alter_info and other ALTER generic structures from Lex here.
+*/
+class Alter_table_common : public Sql_statement
+{
+protected:
+  /**
+    Constructor.
+    @param lex the LEX structure for this statement.
+  */
+  Alter_table_common(LEX *lex)
+    : Sql_statement(lex)
+  {}
+
+  virtual ~Alter_table_common()
+  {}
+
+};
+
+/**
+  Alter_table_statement represents the generic ALTER TABLE statement.
+  @todo move Alter_info and other ALTER specific structures from Lex here.
+*/
+class Alter_table_statement : public Alter_table_common
+{
+public:
+  /**
+    Constructor, used to represent a ALTER TABLE statement.
+    @param lex the LEX structure for this statement.
+  */
+  Alter_table_statement(LEX *lex)
+    : Alter_table_common(lex)
+  {}
+
+  ~Alter_table_statement()
+  {}
+
+  /**
+    Execute a ALTER TABLE statement at runtime.
+    @param thd the current thread.
+    @return false on success.
+  */
+  bool execute(THD *thd);
+};
+
+#endif

sql/sql_lex.cc

@@ -401,6 +401,7 @@ void lex_start(THD *thd)
   lex->spname= NULL;
   lex->sphead= NULL;
   lex->spcont= NULL;
+  lex->m_stmt= NULL;
   lex->proc_list.first= 0;
   lex->escape_used= FALSE;
   lex->query_tables= 0;

sql/sql_lex.h

@@ -919,6 +919,24 @@ enum enum_alter_table_change_level
   ALTER_TABLE_INDEX_CHANGED= 2
 };
 
+
+/**
+  Temporary hack to enable a class bound forward declaration
+  of the enum_alter_table_change_level enumeration. To be
+  removed once Alter_info is moved to the sql_alter_table.h
+  header.
+*/
+class Alter_table_change_level
+{
+private:
+  typedef enum enum_alter_table_change_level enum_type;
+  enum_type value;
+public:
+  void operator = (enum_type v) { value = v; }
+  operator enum_type () { return value; }
+};
+
+
 /**
   @brief Parsing data for CREATE or ALTER TABLE.
 

sql/sql_parse.cc

@@ -50,6 +50,7 @@
                               // mysql_backup_table,
                               // mysql_restore_table
 #include "sql_truncate.h"     // mysql_truncate_table
+#include "sql_table_maintenance.h"   // mysql_assign_to_keycache
 #include "sql_connect.h"      // check_user,
                               // decrease_user_connections,
                               // thd_init_client_charset, check_mqh,
@@ -659,8 +660,7 @@ end:
     every child. Set 'db' for every child if not present.
 */
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
-static bool check_merge_table_access(THD *thd, char *db,
-                                     TABLE_LIST *table_list)
+bool check_merge_table_access(THD *thd, char *db, TABLE_LIST *table_list)
 {
   int error= 0;
 
@@ -2831,77 +2831,6 @@ end_with_restore_list:
   }
 #endif /* HAVE_REPLICATION */
 
-  case SQLCOM_ALTER_TABLE:
-    DBUG_ASSERT(first_table == all_tables && first_table != 0);
-    {
-      ulong priv=0;
-      ulong priv_needed= ALTER_ACL;
-      /*
-        Code in mysql_alter_table() may modify its HA_CREATE_INFO argument,
-        so we have to use a copy of this structure to make execution
-        prepared statement- safe. A shallow copy is enough as no memory
-        referenced from this structure will be modified.
-      */
-      HA_CREATE_INFO create_info(lex->create_info);
-      Alter_info alter_info(lex->alter_info, thd->mem_root);
-
-      if (thd->is_fatal_error) /* out of memory creating a copy of alter_info */
-        goto error;
-      /*
-        We also require DROP priv for ALTER TABLE ... DROP PARTITION, as well
-        as for RENAME TO, as being done by SQLCOM_RENAME_TABLE
-      */
-      if (alter_info.flags & (ALTER_DROP_PARTITION | ALTER_RENAME))
-        priv_needed|= DROP_ACL;
-
-      /* Must be set in the parser */
-      DBUG_ASSERT(select_lex->db);
-      if (check_access(thd, priv_needed, first_table->db,
-                       &first_table->grant.privilege,
-                       &first_table->grant.m_internal,
-                       0, 0) ||
-          check_access(thd, INSERT_ACL | CREATE_ACL, select_lex->db,
-                       &priv,
-                       NULL, /* Do not use first_table->grant with select_lex->db */
-                       0, 0) ||
-	  check_merge_table_access(thd, first_table->db,
-				   create_info.merge_list.first))
-	goto error;				/* purecov: inspected */
-      if (check_grant(thd, priv_needed, all_tables, FALSE, UINT_MAX, FALSE))
-        goto error;
-      if (lex->name.str && !test_all_bits(priv,INSERT_ACL | CREATE_ACL))
-      { // Rename of table
-          TABLE_LIST tmp_table;
-          bzero((char*) &tmp_table,sizeof(tmp_table));
-          tmp_table.table_name= lex->name.str;
-          tmp_table.db=select_lex->db;
-          tmp_table.grant.privilege=priv;
-          if (check_grant(thd, INSERT_ACL | CREATE_ACL, &tmp_table, FALSE,
-              UINT_MAX, FALSE))
-            goto error;
-      }
-
-      /* Don't yet allow changing of symlinks with ALTER TABLE */
-      if (create_info.data_file_name)
-        push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
-                            WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED),
-                            "DATA DIRECTORY");
-      if (create_info.index_file_name)
-        push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
-                            WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED),
-                            "INDEX DIRECTORY");
-      create_info.data_file_name= create_info.index_file_name= NULL;
-
-      thd->enable_slow_log= opt_log_slow_admin_statements;
-      res= mysql_alter_table(thd, select_lex->db, lex->name.str,
-                             &create_info,
-                             first_table,
-                             &alter_info,
-                             select_lex->order_list.elements,
-                             select_lex->order_list.first,
-                             lex->ignore);
-      break;
-    }
   case SQLCOM_RENAME_TABLE:
   {
     DBUG_ASSERT(first_table == all_tables && first_table != 0);
@@ -3021,81 +2950,6 @@ end_with_restore_list:
     res = mysql_checksum_table(thd, first_table, &lex->check_opt);
     break;
   }
-  case SQLCOM_REPAIR:
-  {
-    DBUG_ASSERT(first_table == all_tables && first_table != 0);
-    if (check_table_access(thd, SELECT_ACL | INSERT_ACL, all_tables,
-                           FALSE, UINT_MAX, FALSE))
-      goto error; /* purecov: inspected */
-    thd->enable_slow_log= opt_log_slow_admin_statements;
-    res= mysql_repair_table(thd, first_table, &lex->check_opt);
-    /* ! we write after unlocking the table */
-    if (!res && !lex->no_write_to_binlog)
-    {
-      /*
-        Presumably, REPAIR and binlog writing doesn't require synchronization
-      */
-      res= write_bin_log(thd, TRUE, thd->query(), thd->query_length());
-    }
-    select_lex->table_list.first= first_table;
-    lex->query_tables=all_tables;
-    break;
-  }
-  case SQLCOM_CHECK:
-  {
-    DBUG_ASSERT(first_table == all_tables && first_table != 0);
-    if (check_table_access(thd, SELECT_ACL, all_tables,
-                           TRUE, UINT_MAX, FALSE))
-      goto error; /* purecov: inspected */
-    thd->enable_slow_log= opt_log_slow_admin_statements;
-    res = mysql_check_table(thd, first_table, &lex->check_opt);
-    select_lex->table_list.first= first_table;
-    lex->query_tables=all_tables;
-    break;
-  }
-  case SQLCOM_ANALYZE:
-  {
-    DBUG_ASSERT(first_table == all_tables && first_table != 0);
-    if (check_table_access(thd, SELECT_ACL | INSERT_ACL, all_tables,
-                           FALSE, UINT_MAX, FALSE))
-      goto error; /* purecov: inspected */
-    thd->enable_slow_log= opt_log_slow_admin_statements;
-    res= mysql_analyze_table(thd, first_table, &lex->check_opt);
-    /* ! we write after unlocking the table */
-    if (!res && !lex->no_write_to_binlog)
-    {
-      /*
-        Presumably, ANALYZE and binlog writing doesn't require synchronization
-      */
-      res= write_bin_log(thd, TRUE, thd->query(), thd->query_length());
-    }
-    select_lex->table_list.first= first_table;
-    lex->query_tables=all_tables;
-    break;
-  }
-
-  case SQLCOM_OPTIMIZE:
-  {
-    DBUG_ASSERT(first_table == all_tables && first_table != 0);
-    if (check_table_access(thd, SELECT_ACL | INSERT_ACL, all_tables,
-                           FALSE, UINT_MAX, FALSE))
-      goto error; /* purecov: inspected */
-    thd->enable_slow_log= opt_log_slow_admin_statements;
-    res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ?
-      mysql_recreate_table(thd, first_table) :
-      mysql_optimize_table(thd, first_table, &lex->check_opt);
-    /* ! we write after unlocking the table */
-    if (!res && !lex->no_write_to_binlog)
-    {
-      /*
-        Presumably, OPTIMIZE and binlog writing doesn't require synchronization
-      */
-      res= write_bin_log(thd, TRUE, thd->query(), thd->query_length());
-    }
-    select_lex->table_list.first= first_table;
-    lex->query_tables=all_tables;
-    break;
-  }
   case SQLCOM_UPDATE:
   {
     ha_rows found= 0, updated= 0;
@@ -3316,23 +3170,6 @@ end_with_restore_list:
 
     break;
   }
-  case SQLCOM_TRUNCATE:
-    DBUG_ASSERT(first_table == all_tables && first_table != 0);
-    if (check_one_table_access(thd, DROP_ACL, all_tables))
-      goto error;
-    /*
-      Don't allow this within a transaction because we want to use
-      re-generate table
-    */
-    if (thd->in_active_multi_stmt_transaction())
-    {
-      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
-                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
-      goto error;
-    }
-    if (! (res= mysql_truncate_table(thd, first_table)))
-      my_ok(thd);
-    break;
   case SQLCOM_DELETE:
   {
     DBUG_ASSERT(first_table == all_tables && first_table != 0);
@@ -4718,6 +4555,14 @@ create_sp_error:
     my_ok(thd, 1);
     break;
   }
+  case SQLCOM_ANALYZE:
+  case SQLCOM_CHECK:
+  case SQLCOM_OPTIMIZE:
+  case SQLCOM_REPAIR:
+  case SQLCOM_TRUNCATE:
+  case SQLCOM_ALTER_TABLE:
+      DBUG_ASSERT(first_table == all_tables && first_table != 0);
+    /* fall through */
   case SQLCOM_SIGNAL:
   case SQLCOM_RESIGNAL:
     DBUG_ASSERT(lex->m_stmt != NULL);
@@ -7853,6 +7698,7 @@ bool parse_sql(THD *thd,
 {
   bool ret_value;
   DBUG_ASSERT(thd->m_parser_state == NULL);
+  DBUG_ASSERT(thd->lex->m_stmt == NULL);
 
   MYSQL_QUERY_PARSE_START(thd->query());
   /* Backup creation context. */

sql/sql_parse.h

@@ -155,6 +155,7 @@ bool check_single_table_access(THD *thd, ulong privilege,
 bool check_routine_access(THD *thd,ulong want_access,char *db,char *name,
 			  bool is_proc, bool no_errors);
 bool check_some_access(THD *thd, ulong want_access, TABLE_LIST *table);
+bool check_merge_table_access(THD *thd, char *db, TABLE_LIST *table_list);
 bool check_some_routine_access(THD *thd, const char *db, const char *name, bool is_proc);
 bool check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
                   GRANT_INTERNAL_INFO *grant_internal_info,

sql/sql_partition_admin.cc

+/* 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 */
+
+#include "sql_parse.h"                      // check_one_table_access
+#include "sql_table.h"                      // mysql_alter_table, etc.
+#include "sql_lex.h"                        // Sql_statement
+#include "sql_truncate.h"                   // mysql_truncate_table,
+                                            // Truncate_statement
+#include "sql_table_maintenance.h"          // Analyze/Check/.._table_statement
+#include "sql_partition_admin.h"            // Alter_table_*_partition
+
+#ifndef WITH_PARTITION_STORAGE_ENGINE
+
+bool Partition_statement_unsupported::execute(THD *)
+{
+  DBUG_ENTER("Partition_statement_unsupported::execute");
+  /* error, partitioning support not compiled in... */
+  my_error(ER_FEATURE_DISABLED, MYF(0), "partitioning",
+           "--with-plugin-partition");
+  DBUG_RETURN(TRUE);
+}
+
+#else
+
+bool Alter_table_analyze_partition_statement::execute(THD *thd)
+{
+  bool res;
+  DBUG_ENTER("Alter_table_analyze_partition_statement::execute");
+
+  /*
+    Flag that it is an ALTER command which administrates partitions, used
+    by ha_partition
+  */
+  m_lex->alter_info.flags|= ALTER_ADMIN_PARTITION;
+
+  res= Analyze_table_statement::execute(thd);
+    
+  DBUG_RETURN(res);
+}
+
+
+bool Alter_table_check_partition_statement::execute(THD *thd)
+{
+  bool res;
+  DBUG_ENTER("Alter_table_check_partition_statement::execute");
+
+  /*
+    Flag that it is an ALTER command which administrates partitions, used
+    by ha_partition
+  */
+  m_lex->alter_info.flags|= ALTER_ADMIN_PARTITION;
+
+  res= Check_table_statement::execute(thd);
+
+  DBUG_RETURN(res);
+}
+
+
+bool Alter_table_optimize_partition_statement::execute(THD *thd)
+{
+  bool res;
+  DBUG_ENTER("Alter_table_optimize_partition_statement::execute");
+
+  /*
+    Flag that it is an ALTER command which administrates partitions, used
+    by ha_partition
+  */
+  m_lex->alter_info.flags|= ALTER_ADMIN_PARTITION;
+
+  res= Optimize_table_statement::execute(thd);
+
+  DBUG_RETURN(res);
+}
+
+
+bool Alter_table_repair_partition_statement::execute(THD *thd)
+{
+  bool res;
+  DBUG_ENTER("Alter_table_repair_partition_statement::execute");
+
+  /*
+    Flag that it is an ALTER command which administrates partitions, used
+    by ha_partition
+  */
+  m_lex->alter_info.flags|= ALTER_ADMIN_PARTITION;
+
+  res= Repair_table_statement::execute(thd);
+
+  DBUG_RETURN(res);
+}
+
+
+bool Alter_table_truncate_partition_statement::execute(THD *thd)
+{
+  TABLE_LIST *first_table= thd->lex->select_lex.table_list.first;
+  bool res;
+  enum_sql_command original_sql_command;
+  DBUG_ENTER("Alter_table_truncate_partition_statement::execute");
+
+  /*
+    Execute TRUNCATE PARTITION just like TRUNCATE TABLE.
+    Some storage engines (InnoDB, partition) checks thd_sql_command,
+    so we set it to SQLCOM_TRUNCATE during the execution.
+  */
+  original_sql_command= m_lex->sql_command;
+  m_lex->sql_command= SQLCOM_TRUNCATE;
+  
+  /*
+    Flag that it is an ALTER command which administrates partitions, used
+    by ha_partition.
+  */
+  m_lex->alter_info.flags|= ALTER_ADMIN_PARTITION;
+   
+  /*
+    Fix the lock types (not the same as ordinary ALTER TABLE).
+  */
+  first_table->lock_type= TL_WRITE;
+  first_table->mdl_request.set_type(MDL_SHARED_NO_READ_WRITE);
+
+  /* execute as a TRUNCATE TABLE */
+  res= Truncate_statement::execute(thd);
+
+  m_lex->sql_command= original_sql_command;
+  DBUG_RETURN(res);
+}
+
+#endif /* WITH_PARTITION_STORAGE_ENGINE */

sql/sql_partition_admin.h

+/* 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 */

sql/sql_table.h

@@ -19,7 +19,6 @@
 #include "my_global.h"                          /* my_bool */
 #include "my_sys.h"                             // pthread_mutex_t
 
-class Alter_info;
 class Alter_info;
 class Create_field;
 struct TABLE_LIST;
@@ -28,11 +27,12 @@ struct TABLE;
 struct handlerton;
 typedef struct st_ha_check_opt HA_CHECK_OPT;
 typedef struct st_ha_create_information HA_CREATE_INFO;
+typedef struct st_key KEY;
 typedef struct st_key_cache KEY_CACHE;
 typedef struct st_lock_param_type ALTER_PARTITION_PARAM_TYPE;
-typedef struct st_lock_param_type ALTER_PARTITION_PARAM_TYPE;
 typedef struct st_mysql_lex_string LEX_STRING;
 typedef struct st_order ORDER;
+class Alter_table_change_level;
 
 enum ddl_log_entry_code
 {
@@ -139,12 +139,23 @@ bool mysql_create_table_no_lock(THD *thd, const char *db,
                                 HA_CREATE_INFO *create_info,
                                 Alter_info *alter_info,
                                 bool tmp_table, uint select_field_count);
-
+bool mysql_prepare_alter_table(THD *thd, TABLE *table,
+                               HA_CREATE_INFO *create_info,
+                               Alter_info *alter_info);
 bool mysql_alter_table(THD *thd, char *new_db, char *new_name,
                        HA_CREATE_INFO *create_info,
                        TABLE_LIST *table_list,
                        Alter_info *alter_info,
                        uint order_num, ORDER *order, bool ignore);
+bool mysql_compare_tables(TABLE *table,
+                          Alter_info *alter_info,
+                          HA_CREATE_INFO *create_info,
+                          uint order_num,
+                          Alter_table_change_level *need_copy_table,
+                          KEY **key_info_buffer,
+                          uint **index_drop_buffer, uint *index_drop_count,
+                          uint **index_add_buffer, uint *index_add_count,
+                          uint *candidate_key_count);
 bool mysql_recreate_table(THD *thd, TABLE_LIST *table_list);
 bool mysql_create_like_table(THD *thd, TABLE_LIST *table,
                              TABLE_LIST *src_table,
@@ -158,19 +169,6 @@ bool mysql_restore_table(THD* thd, TABLE_LIST* table_list);
 
 bool mysql_checksum_table(THD* thd, TABLE_LIST* table_list,
                           HA_CHECK_OPT* check_opt);
-bool mysql_check_table(THD* thd, TABLE_LIST* table_list,
-                       HA_CHECK_OPT* check_opt);
-bool mysql_repair_table(THD* thd, TABLE_LIST* table_list,
-                        HA_CHECK_OPT* check_opt);
-bool mysql_analyze_table(THD* thd, TABLE_LIST* table_list,
-                         HA_CHECK_OPT* check_opt);
-bool mysql_optimize_table(THD* thd, TABLE_LIST* table_list,
-                          HA_CHECK_OPT* check_opt);
-bool mysql_assign_to_keycache(THD* thd, TABLE_LIST* table_list,
-                              LEX_STRING *key_cache_name);
-bool mysql_preload_keys(THD* thd, TABLE_LIST* table_list);
-int reassign_keycache_tables(THD* thd, KEY_CACHE *src_cache,
-                             KEY_CACHE *dst_cache);
 bool mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists,
                     my_bool drop_temporary);
 int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,

sql/sql_table_maintenance.h

+/* 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_TABLE_MAINTENANCE_H
+#define SQL_TABLE_MAINTENANCE_H
+
+
+bool mysql_assign_to_keycache(THD* thd, TABLE_LIST* table_list,
+                              LEX_STRING *key_cache_name);
+bool mysql_preload_keys(THD* thd, TABLE_LIST* table_list);
+int reassign_keycache_tables(THD* thd, KEY_CACHE *src_cache,
+                             KEY_CACHE *dst_cache);
+
+/**
+  Analyze_statement represents the ANALYZE TABLE statement.
+*/
+class Analyze_table_statement : public Sql_statement
+{
+public:
+  /**
+    Constructor, used to represent a ANALYZE TABLE statement.
+    @param lex the LEX structure for this statement.
+  */
+  Analyze_table_statement(LEX *lex)
+    : Sql_statement(lex)
+  {}
+
+  ~Analyze_table_statement()
+  {}
+
+  /**
+    Execute a ANALYZE TABLE statement at runtime.
+    @param thd the current thread.
+    @return false on success.
+  */
+  bool execute(THD *thd);
+};
+
+
+
+/**
+  Check_table_statement represents the CHECK TABLE statement.
+*/
+class Check_table_statement : public Sql_statement
+{
+public:
+  /**
+    Constructor, used to represent a CHECK TABLE statement.
+    @param lex the LEX structure for this statement.
+  */
+  Check_table_statement(LEX *lex)
+    : Sql_statement(lex)
+  {}
+
+  ~Check_table_statement()
+  {}
+
+  /**
+    Execute a CHECK TABLE statement at runtime.
+    @param thd the current thread.
+    @return false on success.
+  */
+  bool execute(THD *thd);
+};
+
+
+
+/**
+  Optimize_table_statement represents the OPTIMIZE TABLE statement.
+*/
+class Optimize_table_statement : public Sql_statement
+{
+public:
+  /**
+    Constructor, used to represent a OPTIMIZE TABLE statement.
+    @param lex the LEX structure for this statement.
+  */
+  Optimize_table_statement(LEX *lex)
+    : Sql_statement(lex)
+  {}
+
+  ~Optimize_table_statement()
+  {}
+
+  /**
+    Execute a OPTIMIZE TABLE statement at runtime.
+    @param thd the current thread.
+    @return false on success.
+  */
+  bool execute(THD *thd);
+};
+
+
+
+/**
+  Repair_table_statement represents the REPAIR TABLE statement.
+*/
+class Repair_table_statement : public Sql_statement
+{
+public:
+  /**
+    Constructor, used to represent a REPAIR TABLE statement.
+    @param lex the LEX structure for this statement.
+  */
+  Repair_table_statement(LEX *lex)
+    : Sql_statement(lex)
+  {}
+
+  ~Repair_table_statement()
+  {}
+
+  /**
+    Execute a REPAIR TABLE statement at runtime.
+    @param thd the current thread.
+    @return false on success.
+  */
+  bool execute(THD *thd);
+};
+
+#endif

sql/sql_truncate.cc

@@ -13,7 +13,6 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
 
-#include "sql_truncate.h"
 #include "sql_priv.h"
 #include "transaction.h"
 #include "debug_sync.h"
@@ -25,6 +24,9 @@
 #include "sql_handler.h" // mysql_ha_rm_tables
 #include "datadict.h"    // dd_recreate_table()
 #include "lock.h"        // MYSQL_OPEN_TEMPORARY_ONLY
+#include "sql_acl.h"     // DROP_ACL
+#include "sql_parse.h"   // check_one_table_access()
+#include "sql_truncate.h"
 
 
 /*
@@ -242,6 +244,7 @@ static bool open_and_lock_table_for_truncate(THD *thd, TABLE_LIST *table_ref,
                                              MDL_ticket **ticket_downgrade)
 {
   TABLE *table= NULL;
+  handlerton *table_type;
   DBUG_ENTER("open_and_lock_table_for_truncate");
 
   DBUG_ASSERT(table_ref->lock_type == TL_WRITE);
@@ -265,7 +268,8 @@ static bool open_and_lock_table_for_truncate(THD *thd, TABLE_LIST *table_ref,
                                             table_ref->table_name, FALSE)))
       DBUG_RETURN(TRUE);
 
-    *hton_can_recreate= ha_check_storage_engine_flag(table->s->db_type(),
+    table_type= table->s->db_type();
+    *hton_can_recreate= ha_check_storage_engine_flag(table_type,
                                                      HTON_CAN_RECREATE);
     table_ref->mdl_request.ticket= table->mdl_ticket;
   }
@@ -281,11 +285,25 @@ static bool open_and_lock_table_for_truncate(THD *thd, TABLE_LIST *table_ref,
                          MYSQL_OPEN_SKIP_TEMPORARY))
       DBUG_RETURN(TRUE);
 
-    if (dd_check_storage_engine_flag(thd, table_ref->db, table_ref->table_name,
-                                     HTON_CAN_RECREATE, hton_can_recreate))
+    if (dd_frm_storage_engine(thd, table_ref->db, table_ref->table_name,
+                              &table_type))
       DBUG_RETURN(TRUE);
+    *hton_can_recreate= ha_check_storage_engine_flag(table_type,
+                                                     HTON_CAN_RECREATE);
   }
 
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  /*
+    TODO: Add support for TRUNCATE PARTITION for NDB and other engines
+    supporting native partitioning.
+  */
+  if (thd->lex->alter_info.flags & ALTER_ADMIN_PARTITION &&
+      table_type != partition_hton)
+  {
+    my_error(ER_PARTITION_MGMT_ON_NONPARTITIONED, MYF(0));
+    DBUG_RETURN(TRUE);
+  }
+#endif
   DEBUG_SYNC(thd, "lock_table_for_truncate");
 
   if (*hton_can_recreate)
@@ -477,3 +495,27 @@ bool mysql_truncate_table(THD *thd, TABLE_LIST *table_ref)
   DBUG_RETURN(test(error));
 }
 
+
+bool Truncate_statement::execute(THD *thd)
+{
+  TABLE_LIST *first_table= thd->lex->select_lex.table_list.first;
+  bool res= TRUE;
+  DBUG_ENTER("Truncate_statement::execute");
+
+  if (check_one_table_access(thd, DROP_ACL, first_table))
+    goto error;
+  /*
+    Don't allow this within a transaction because we want to use
+    re-generate table
+  */
+  if (thd->in_active_multi_stmt_transaction())
+  {
+    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
+               ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
+    goto error;
+  }
+  if (! (res= mysql_truncate_table(thd, first_table)))
+    my_ok(thd);
+error:
+  DBUG_RETURN(res);
+}

sql/sql_truncate.h

@@ -20,4 +20,30 @@ struct TABLE_LIST;
 
 bool mysql_truncate_table(THD *thd, TABLE_LIST *table_ref);
 
+/**
+  Truncate_statement represents the TRUNCATE statement.
+*/
+class Truncate_statement : public Sql_statement
+{
+public:
+  /**
+    Constructor, used to represent a ALTER TABLE statement.
+    @param lex the LEX structure for this statement.
+  */
+  Truncate_statement(LEX *lex)
+    : Sql_statement(lex)
+  {}
+
+  ~Truncate_statement()
+  {}
+
+  /**
+    Execute a TRUNCATE statement at runtime.
+    @param thd the current thread.
+    @return false on success.
+  */
+  bool execute(THD *thd);
+};
+
+
 #endif

sql/sql_yacc.yy

@@ -51,6 +51,10 @@
 #include "sp_pcontext.h"
 #include "sp_rcontext.h"
 #include "sp.h"
+#include "sql_alter_table.h"                   // Alter_table*_statement
+#include "sql_truncate.h"                      // Truncate_statement
+#include "sql_table_maintenance.h"             // Analyze/Check..._table_stmt
+#include "sql_partition_admin.h"               // Alter_table_*_partition_stmt
 #include "sql_signal.h"
 #include "event_parse_data.h"
 #include <myisam.h>
@@ -6172,9 +6176,20 @@ alter:
             lex->no_write_to_binlog= 0;
             lex->create_info.storage_media= HA_SM_DEFAULT;
             lex->create_last_non_select_table= lex->last_table();
+            DBUG_ASSERT(!lex->m_stmt);
           }
           alter_commands
-          {}
+          {
+            THD *thd= YYTHD;
+            LEX *lex= thd->lex;
+            if (!lex->m_stmt)
+            {
+              /* Create a generic ALTER TABLE statment. */
+              lex->m_stmt= new (thd->mem_root) Alter_table_statement(lex);
+              if (lex->m_stmt == NULL)
+                MYSQL_YYABORT;
+            }
+          }
         | ALTER DATABASE ident_or_empty
           {
             Lex->create_info.default_table_charset= NULL;
@@ -6393,38 +6408,54 @@ alter_commands:
         | OPTIMIZE PARTITION_SYM opt_no_write_to_binlog
           all_or_alt_part_name_list
           {
-            LEX *lex= Lex;
-            lex->sql_command= SQLCOM_OPTIMIZE;
-            lex->alter_info.flags|= ALTER_ADMIN_PARTITION;
+            THD *thd= YYTHD;
+            LEX *lex= thd->lex;
             lex->no_write_to_binlog= $3;
             lex->check_opt.init();
+            DBUG_ASSERT(!lex->m_stmt);
+            lex->m_stmt= new (thd->mem_root)
+                          Alter_table_optimize_partition_statement(lex);
+            if (lex->m_stmt == NULL)
+              MYSQL_YYABORT;
           }
           opt_no_write_to_binlog
         | ANALYZE_SYM PARTITION_SYM opt_no_write_to_binlog
           all_or_alt_part_name_list
           {
-            LEX *lex= Lex;
-            lex->sql_command= SQLCOM_ANALYZE;
-            lex->alter_info.flags|= ALTER_ADMIN_PARTITION;
+            THD *thd= YYTHD;
+            LEX *lex= thd->lex;
             lex->no_write_to_binlog= $3;
             lex->check_opt.init();
+            DBUG_ASSERT(!lex->m_stmt);
+            lex->m_stmt= new (thd->mem_root)
+                          Alter_table_analyze_partition_statement(lex);
+            if (lex->m_stmt == NULL)
+              MYSQL_YYABORT;
           }
         | CHECK_SYM PARTITION_SYM all_or_alt_part_name_list
           {
-            LEX *lex= Lex;
-            lex->sql_command= SQLCOM_CHECK;
-            lex->alter_info.flags|= ALTER_ADMIN_PARTITION;
+            THD *thd= YYTHD;
+            LEX *lex= thd->lex;
             lex->check_opt.init();
+            DBUG_ASSERT(!lex->m_stmt);
+            lex->m_stmt= new (thd->mem_root)
+                          Alter_table_check_partition_statement(lex);
+            if (lex->m_stmt == NULL)
+              MYSQL_YYABORT;
           }
           opt_mi_check_type
         | REPAIR PARTITION_SYM opt_no_write_to_binlog
           all_or_alt_part_name_list
           {
-            LEX *lex= Lex;
-            lex->sql_command= SQLCOM_REPAIR;
-            lex->alter_info.flags|= ALTER_ADMIN_PARTITION;
+            THD *thd= YYTHD;
+            LEX *lex= thd->lex;
             lex->no_write_to_binlog= $3;
             lex->check_opt.init();
+            DBUG_ASSERT(!lex->m_stmt);
+            lex->m_stmt= new (thd->mem_root)
+                          Alter_table_repair_partition_statement(lex);
+            if (lex->m_stmt == NULL)
+              MYSQL_YYABORT;
           }
           opt_mi_repair_type
         | COALESCE PARTITION_SYM opt_no_write_to_binlog real_ulong_num
@@ -6436,12 +6467,14 @@ alter_commands:
           }
         | TRUNCATE_SYM PARTITION_SYM all_or_alt_part_name_list
           {
-            LEX *lex= Lex;
-            lex->sql_command= SQLCOM_TRUNCATE;
-            lex->alter_info.flags|= ALTER_ADMIN_PARTITION;
+            THD *thd= YYTHD;
+            LEX *lex= thd->lex;
             lex->check_opt.init();
-            lex->query_tables->mdl_request.set_type(MDL_SHARED_NO_READ_WRITE);
-            lex->query_tables->lock_type= TL_WRITE;
+            DBUG_ASSERT(!lex->m_stmt);
+            lex->m_stmt= new (thd->mem_root)
+                          Alter_table_truncate_partition_statement(lex);
+            if (lex->m_stmt == NULL)
+              MYSQL_YYABORT;
           }
         | reorg_partition_rule
         ;
@@ -6878,7 +6911,14 @@ repair:
             YYPS->m_lock_type= TL_UNLOCK;
           }
           table_list opt_mi_repair_type
-          {}
+          {
+            THD *thd= YYTHD;
+            LEX* lex= thd->lex;
+            DBUG_ASSERT(!lex->m_stmt);
+            lex->m_stmt= new (thd->mem_root) Repair_table_statement(lex);
+            if (lex->m_stmt == NULL)
+              MYSQL_YYABORT;
+          }
         ;
 
 opt_mi_repair_type:
@@ -6909,7 +6949,14 @@ analyze:
             YYPS->m_lock_type= TL_UNLOCK;
           }
           table_list
-          {}
+          {
+            THD *thd= YYTHD;
+            LEX* lex= thd->lex;
+            DBUG_ASSERT(!lex->m_stmt);
+            lex->m_stmt= new (thd->mem_root) Analyze_table_statement(lex);
+            if (lex->m_stmt == NULL)
+              MYSQL_YYABORT;
+          }
         ;
 
 binlog_base64_event:
@@ -6937,7 +6984,14 @@ check:
             YYPS->m_lock_type= TL_UNLOCK;
           }
           table_list opt_mi_check_type
-          {}
+          {
+            THD *thd= YYTHD;
+            LEX* lex= thd->lex;
+            DBUG_ASSERT(!lex->m_stmt);
+            lex->m_stmt= new (thd->mem_root) Check_table_statement(lex);
+            if (lex->m_stmt == NULL)
+              MYSQL_YYABORT;
+          }
         ;
 
 opt_mi_check_type:
@@ -6971,7 +7025,14 @@ optimize:
             YYPS->m_lock_type= TL_UNLOCK;
           }
           table_list
-          {}
+          {
+            THD *thd= YYTHD;
+            LEX* lex= thd->lex;
+            DBUG_ASSERT(!lex->m_stmt);
+            lex->m_stmt= new (thd->mem_root) Optimize_table_statement(lex);
+            if (lex->m_stmt == NULL)
+              MYSQL_YYABORT;
+          }
         ;
 
 opt_no_write_to_binlog:
@@ -10698,7 +10759,14 @@ truncate:
             YYPS->m_mdl_type= MDL_SHARED_NO_READ_WRITE;
           }
           table_name
-          {}
+          {
+            THD *thd= YYTHD;
+            LEX* lex= thd->lex;
+            DBUG_ASSERT(!lex->m_stmt);
+            lex->m_stmt= new (thd->mem_root) Truncate_statement(lex);
+            if (lex->m_stmt == NULL)
+              MYSQL_YYABORT;
+          }
         ;
 
 opt_table_sym: