List:Commits« Previous MessageNext Message »
From:Mattias Jonsson Date:August 16 2010 6:25pm
Subject:bzr commit into mysql-trunk-bugfixing branch (mattias.jonsson:3209)
View as plain text  
#At file:///Users/mattiasj/mysql-bzr/topush-trunk-bugfixing_2/ based on revid:alexey.kopytov@stripped

 3209 Mattias Jonsson	2010-08-16 [merge]
      merge

    added:
      sql/sql_admin.cc
      sql/sql_admin.h
    renamed:
      sql/sql_alter_table.cc => sql/sql_alter.cc
      sql/sql_alter_table.h => sql/sql_alter.h
    modified:
      .bzrignore
      libmysqld/CMakeLists.txt
      libmysqld/Makefile.am
      mysql-test/r/not_partition.result
      mysql-test/r/partition_disabled.result
      mysql-test/r/partition_truncate.result
      mysql-test/suite/parts/inc/partition_mgm.inc
      mysql-test/suite/parts/r/partition_debug_sync_innodb.result
      mysql-test/suite/parts/r/partition_mgm_lc0_archive.result
      mysql-test/suite/parts/r/partition_mgm_lc1_archive.result
      mysql-test/suite/parts/r/partition_mgm_lc2_archive.result
      mysql-test/suite/parts/t/partition_debug_sync_innodb.test
      mysql-test/t/not_partition.test
      mysql-test/t/partition_truncate.test
      sql/CMakeLists.txt
      sql/Makefile.am
      sql/datadict.cc
      sql/datadict.h
      sql/sql_lex.h
      sql/sql_parse.cc
      sql/sql_partition_admin.cc
      sql/sql_partition_admin.h
      sql/sql_table.cc
      sql/sql_table.h
      sql/sql_truncate.cc
      sql/sql_truncate.h
      sql/sql_yacc.yy
      sql/sql_alter.cc
=== modified file '.bzrignore'
--- a/.bzrignore	2010-07-30 18:25:50 +0000
+++ b/.bzrignore	2010-08-16 15:07:53 +0000
@@ -3117,5 +3117,5 @@ sql/.empty
 libmysqld/sql_bootstrap.cc
 mysys/thr_lock
 libmysqld/binlog.cc
-libmysqld/sql_alter_table.cc
+libmysqld/sql_alter.cc
 libmysqld/sql_partition_admin.cc

=== modified file 'libmysqld/CMakeLists.txt'
--- a/libmysqld/CMakeLists.txt	2010-08-12 15:27:53 +0000
+++ b/libmysqld/CMakeLists.txt	2010-08-16 15:07:53 +0000
@@ -65,7 +65,7 @@ SET(SQL_EMBEDDED_SOURCES emb_qcache.cc l
            ../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_admin.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
@@ -81,7 +81,7 @@ SET(SQL_EMBEDDED_SOURCES emb_qcache.cc l
            ../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/sql_alter.cc ../sql/sql_partition_admin.cc
            ../sql/event_parse_data.cc
            ../sql/sql_signal.cc ../sql/rpl_handler.cc
 	       ../sql/rpl_utility.cc ../sql/binlog.cc

=== modified file 'libmysqld/Makefile.am'
--- a/libmysqld/Makefile.am	2010-07-30 18:25:50 +0000
+++ b/libmysqld/Makefile.am	2010-08-16 15:07:53 +0000
@@ -63,7 +63,7 @@ sqlsources = derror.cc field.cc field_co
 	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_admin.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 \
@@ -79,11 +79,10 @@ sqlsources = derror.cc field.cc field_co
 	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.cc \
 	sql_servers.cc event_parse_data.cc sql_signal.cc \
 	sql_bootstrap.cc \
 	binlog.cc rpl_handler.cc mdl.cc keycaches.cc sql_audit.cc \
-	sql_alter_table.cc \
 	sql_partition_admin.cc
 
 libmysqld_int_a_SOURCES= $(libmysqld_sources)

=== modified file 'mysql-test/r/not_partition.result'
--- a/mysql-test/r/not_partition.result	2009-12-24 20:18:53 +0000
+++ b/mysql-test/r/not_partition.result	2010-08-16 12:53:30 +0000
@@ -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);

=== modified file 'mysql-test/r/partition_disabled.result'
--- a/mysql-test/r/partition_disabled.result	2009-01-08 14:16:44 +0000
+++ b/mysql-test/r/partition_disabled.result	2010-08-16 12:53:30 +0000
@@ -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

=== modified file 'mysql-test/r/partition_truncate.result'
--- a/mysql-test/r/partition_truncate.result	2009-09-10 09:15:39 +0000
+++ b/mysql-test/r/partition_truncate.result	2010-08-16 12:53:30 +0000
@@ -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;

=== modified file 'mysql-test/suite/parts/inc/partition_mgm.inc'
--- a/mysql-test/suite/parts/inc/partition_mgm.inc	2010-06-23 10:48:39 +0000
+++ b/mysql-test/suite/parts/inc/partition_mgm.inc	2010-08-16 14:22:16 +0000
@@ -559,6 +559,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)
 {

=== modified file 'mysql-test/suite/parts/r/partition_debug_sync_innodb.result'
--- a/mysql-test/suite/parts/r/partition_debug_sync_innodb.result	2010-05-11 16:02:50 +0000
+++ b/mysql-test/suite/parts/r/partition_debug_sync_innodb.result	2010-08-16 12:53:30 +0000
@@ -1,4 +1,38 @@
 #
+# 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)

=== modified file 'mysql-test/suite/parts/r/partition_mgm_lc0_archive.result'
--- a/mysql-test/suite/parts/r/partition_mgm_lc0_archive.result	2010-06-23 10:48:39 +0000
+++ b/mysql-test/suite/parts/r/partition_mgm_lc0_archive.result	2010-08-16 14:22:16 +0000
@@ -999,6 +999,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;

=== modified file 'mysql-test/suite/parts/r/partition_mgm_lc1_archive.result'
--- a/mysql-test/suite/parts/r/partition_mgm_lc1_archive.result	2010-06-23 10:48:39 +0000
+++ b/mysql-test/suite/parts/r/partition_mgm_lc1_archive.result	2010-08-16 14:22:16 +0000
@@ -966,6 +966,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;

=== modified file 'mysql-test/suite/parts/r/partition_mgm_lc2_archive.result'
--- a/mysql-test/suite/parts/r/partition_mgm_lc2_archive.result	2010-06-23 10:48:39 +0000
+++ b/mysql-test/suite/parts/r/partition_mgm_lc2_archive.result	2010-08-16 14:22:16 +0000
@@ -966,6 +966,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;

=== modified file 'mysql-test/suite/parts/t/partition_debug_sync_innodb.test'
--- a/mysql-test/suite/parts/t/partition_debug_sync_innodb.test	2010-06-21 14:45:59 +0000
+++ b/mysql-test/suite/parts/t/partition_debug_sync_innodb.test	2010-08-16 14:22:16 +0000
@@ -5,6 +5,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
 create table t1 (a int)

=== modified file 'mysql-test/t/not_partition.test'
--- a/mysql-test/t/not_partition.test	2009-12-24 20:18:53 +0000
+++ b/mysql-test/t/not_partition.test	2010-08-16 12:53:30 +0000
@@ -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;

=== modified file 'mysql-test/t/partition_truncate.test'
--- a/mysql-test/t/partition_truncate.test	2009-09-10 09:15:39 +0000
+++ b/mysql-test/t/partition_truncate.test	2010-08-16 12:53:30 +0000
@@ -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;

=== modified file 'sql/CMakeLists.txt'
--- a/sql/CMakeLists.txt	2010-08-12 15:27:53 +0000
+++ b/sql/CMakeLists.txt	2010-08-16 15:07:53 +0000
@@ -73,9 +73,10 @@ SET (SQL_SOURCE
                sql_bootstrap.cc
                sql_signal.cc mdl.cc
                sql_alloc_error_handler.cc
-               transaction.cc sys_vars.cc  rpl_handler.cc sql_truncate.cc datadict.cc
+               transaction.cc sys_vars.cc  rpl_handler.cc sql_truncate.cc
+               datadict.cc
                sql_partition_admin.cc
-               sql_alter_table.cc
+               sql_admin.cc sql_alter.cc
                ${GEN_SOURCES}
                ${MYSYS_LIBWRAP_SOURCE})
 

=== modified file 'sql/Makefile.am'
--- a/sql/Makefile.am	2010-07-30 18:25:50 +0000
+++ b/sql/Makefile.am	2010-08-16 15:07:53 +0000
@@ -128,11 +128,11 @@ noinst_HEADERS =	item.h item_func.h item
 			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_alter_table.h sql_partition_admin.h \
+			sql_audit.h sql_alter.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_admin.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 \
@@ -150,7 +150,8 @@ mysqld_SOURCES =	sql_lex.cc sql_handler.
 			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_admin.cc \
+                        sql_truncate.cc \
 			log.cc init.cc derror.cc sql_acl.cc \
 			unireg.cc des_key_file.cc \
 			discover.cc sql_time.cc opt_range.cc opt_sum.cc \
@@ -173,7 +174,7 @@ mysqld_SOURCES =	sql_lex.cc sql_handler.
 			sql_servers.cc event_parse_data.cc sql_signal.cc \
 			mdl.cc transaction.cc sql_audit.cc  \
 			sha2.cc \
-			sql_alter_table.cc \
+			sql_alter.cc \
 			sql_partition_admin.cc
 
 nodist_mysqld_SOURCES =	mini_client_errors.c pack.c client.c my_time.c my_user.c 

=== modified file 'sql/datadict.cc'
--- a/sql/datadict.cc	2010-06-06 11:19:29 +0000
+++ b/sql/datadict.cc	2010-08-16 12:53:30 +0000
@@ -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
 
 
 /**
-  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.
+  Given a table name, check type of .frm and legacy table type.
 
-  @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[out]  table_type   handlerton of the table if FRMTYPE_TABLE,
+                            otherwise undefined.
 
-  @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.
+  @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 *t
     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;

=== modified file 'sql/datadict.h'
--- a/sql/datadict.h	2010-05-25 20:01:38 +0000
+++ b/sql/datadict.h	2010-08-16 12:53:30 +0000
@@ -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,

=== added file 'sql/sql_admin.cc'
--- a/sql/sql_admin.cc	1970-01-01 00:00:00 +0000
+++ b/sql/sql_admin.cc	2010-08-16 14:25:23 +0000
@@ -0,0 +1,1004 @@
+/* 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_class.h"                       // THD
+#include "keycaches.h"                       // get_key_cache
+#include "sql_base.h"                        // Open_table_context
+#include "lock.h"                            // MYSQL_OPEN_*
+#include "sql_handler.h"                     // mysql_ha_rm_tables
+#include "partition_element.h"               // PART_ADMIN
+#include "sql_partition.h"                   // set_part_state
+#include "transaction.h"                     // trans_rollback_stmt
+#include "sql_view.h"                        // view_checksum
+#include "sql_table.h"                       // mysql_recreate_table
+#include "debug_sync.h"                      // DEBUG_SYNC
+#include "sql_acl.h"                         // *_ACL
+#include "sp.h"                              // Sroutine_hash_entry
+#include "sql_parse.h"                       // check_table_access
+#include "sql_admin.h"
+
+static int send_check_errmsg(THD *thd, TABLE_LIST* table,
+			     const char* operator_name, const char* errmsg)
+
+{
+  Protocol *protocol= thd->protocol;
+  protocol->prepare_for_resend();
+  protocol->store(table->alias, system_charset_info);
+  protocol->store((char*) operator_name, system_charset_info);
+  protocol->store(STRING_WITH_LEN("error"), system_charset_info);
+  protocol->store(errmsg, system_charset_info);
+  thd->clear_error();
+  if (protocol->write())
+    return -1;
+  return 1;
+}
+
+
+static int prepare_for_repair(THD *thd, TABLE_LIST *table_list,
+			      HA_CHECK_OPT *check_opt)
+{
+  int error= 0;
+  TABLE tmp_table, *table;
+  TABLE_SHARE *share;
+  bool has_mdl_lock= FALSE;
+  char from[FN_REFLEN],tmp[FN_REFLEN+32];
+  const char **ext;
+  MY_STAT stat_info;
+  Open_table_context ot_ctx(thd, (MYSQL_OPEN_IGNORE_FLUSH |
+                                  MYSQL_OPEN_HAS_MDL_LOCK |
+                                  MYSQL_LOCK_IGNORE_TIMEOUT));
+  DBUG_ENTER("prepare_for_repair");
+
+  if (!(check_opt->sql_flags & TT_USEFRM))
+    DBUG_RETURN(0);
+
+  if (!(table= table_list->table))
+  {
+    char key[MAX_DBKEY_LENGTH];
+    uint key_length;
+    /*
+      If the table didn't exist, we have a shared metadata lock
+      on it that is left from mysql_admin_table()'s attempt to 
+      open it. Release the shared metadata lock before trying to
+      acquire the exclusive lock to satisfy MDL asserts and avoid
+      deadlocks.
+    */
+    thd->mdl_context.release_transactional_locks();
+    /*
+      Attempt to do full-blown table open in mysql_admin_table() has failed.
+      Let us try to open at least a .FRM for this table.
+    */
+    my_hash_value_type hash_value;
+
+    key_length= create_table_def_key(thd, key, table_list, 0);
+    table_list->mdl_request.init(MDL_key::TABLE,
+                                 table_list->db, table_list->table_name,
+                                 MDL_EXCLUSIVE);
+
+    if (lock_table_names(thd, table_list, table_list->next_global,
+                         thd->variables.lock_wait_timeout,
+                         MYSQL_OPEN_SKIP_TEMPORARY))
+      DBUG_RETURN(0);
+    has_mdl_lock= TRUE;
+
+    hash_value= my_calc_hash(&table_def_cache, (uchar*) key, key_length);
+    mysql_mutex_lock(&LOCK_open);
+    if (!(share= (get_table_share(thd, table_list, key, key_length, 0,
+                                  &error, hash_value))))
+    {
+      mysql_mutex_unlock(&LOCK_open);
+      DBUG_RETURN(0);				// Can't open frm file
+    }
+
+    if (open_table_from_share(thd, share, "", 0, 0, 0, &tmp_table, FALSE))
+    {
+      release_table_share(share);
+      mysql_mutex_unlock(&LOCK_open);
+      DBUG_RETURN(0);                           // Out of memory
+    }
+    mysql_mutex_unlock(&LOCK_open);
+    table= &tmp_table;
+  }
+
+  /* A MERGE table must not come here. */
+  DBUG_ASSERT(table->file->ht->db_type != DB_TYPE_MRG_MYISAM);
+
+  /*
+    REPAIR TABLE ... USE_FRM for temporary tables makes little sense.
+  */
+  if (table->s->tmp_table)
+  {
+    error= send_check_errmsg(thd, table_list, "repair",
+			     "Cannot repair temporary table from .frm file");
+    goto end;
+  }
+
+  /*
+    User gave us USE_FRM which means that the header in the index file is
+    trashed.
+    In this case we will try to fix the table the following way:
+    - Rename the data file to a temporary name
+    - Truncate the table
+    - Replace the new data file with the old one
+    - Run a normal repair using the new index file and the old data file
+  */
+
+  if (table->s->frm_version != FRM_VER_TRUE_VARCHAR)
+  {
+    error= send_check_errmsg(thd, table_list, "repair",
+                             "Failed repairing incompatible .frm file");
+    goto end;
+  }
+
+  /*
+    Check if this is a table type that stores index and data separately,
+    like ISAM or MyISAM. We assume fixed order of engine file name
+    extentions array. First element of engine file name extentions array
+    is meta/index file extention. Second element - data file extention. 
+  */
+  ext= table->file->bas_ext();
+  if (!ext[0] || !ext[1])
+    goto end;					// No data file
+
+  // Name of data file
+  strxmov(from, table->s->normalized_path.str, ext[1], NullS);
+  if (!mysql_file_stat(key_file_misc, from, &stat_info, MYF(0)))
+    goto end;				// Can't use USE_FRM flag
+
+  my_snprintf(tmp, sizeof(tmp), "%s-%lx_%lx",
+	      from, current_pid, thd->thread_id);
+
+  if (table_list->table)
+  {
+    /*
+      Table was successfully open in mysql_admin_table(). Now we need
+      to close it, but leave it protected by exclusive metadata lock.
+    */
+    if (wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN))
+      goto end;
+    close_all_tables_for_name(thd, table_list->table->s, FALSE);
+    table_list->table= 0;
+  }
+  /*
+    After this point we have an exclusive metadata lock on our table
+    in both cases when table was successfully open in mysql_admin_table()
+    and when it was open in prepare_for_repair().
+  */
+
+  if (my_rename(from, tmp, MYF(MY_WME)))
+  {
+    error= send_check_errmsg(thd, table_list, "repair",
+			     "Failed renaming data file");
+    goto end;
+  }
+  if (dd_recreate_table(thd, table_list->db, table_list->table_name))
+  {
+    error= send_check_errmsg(thd, table_list, "repair",
+			     "Failed generating table from .frm file");
+    goto end;
+  }
+  /*
+    'FALSE' for 'using_transactions' means don't postpone
+    invalidation till the end of a transaction, but do it
+    immediately.
+  */
+  query_cache_invalidate3(thd, table_list, FALSE);
+  if (mysql_file_rename(key_file_misc, tmp, from, MYF(MY_WME)))
+  {
+    error= send_check_errmsg(thd, table_list, "repair",
+			     "Failed restoring .MYD file");
+    goto end;
+  }
+
+  if (thd->locked_tables_list.reopen_tables(thd))
+    goto end;
+
+  /*
+    Now we should be able to open the partially repaired table
+    to finish the repair in the handler later on.
+  */
+  if (open_table(thd, table_list, thd->mem_root, &ot_ctx))
+  {
+    error= send_check_errmsg(thd, table_list, "repair",
+                             "Failed to open partially repaired table");
+    goto end;
+  }
+
+end:
+  thd->locked_tables_list.unlink_all_closed_tables(thd, NULL, 0);
+  if (table == &tmp_table)
+  {
+    mysql_mutex_lock(&LOCK_open);
+    closefrm(table, 1);				// Free allocated memory
+    mysql_mutex_unlock(&LOCK_open);
+  }
+  /* In case of a temporary table there will be no metadata lock. */
+  if (error && has_mdl_lock)
+    thd->mdl_context.release_transactional_locks();
+
+  DBUG_RETURN(error);
+}
+
+
+
+/*
+  RETURN VALUES
+    FALSE Message sent to net (admin operation went ok)
+    TRUE  Message should be sent by caller 
+          (admin operation or network communication failed)
+*/
+static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
+                              HA_CHECK_OPT* check_opt,
+                              const char *operator_name,
+                              thr_lock_type lock_type,
+                              bool open_for_modify,
+                              bool no_warnings_for_error,
+                              uint extra_open_options,
+                              int (*prepare_func)(THD *, TABLE_LIST *,
+                                                  HA_CHECK_OPT *),
+                              int (handler::*operator_func)(THD *,
+                                                            HA_CHECK_OPT *),
+                              int (view_operator_func)(THD *, TABLE_LIST*))
+{
+  TABLE_LIST *table;
+  SELECT_LEX *select= &thd->lex->select_lex;
+  List<Item> field_list;
+  Item *item;
+  Protocol *protocol= thd->protocol;
+  LEX *lex= thd->lex;
+  int result_code;
+  DBUG_ENTER("mysql_admin_table");
+
+  field_list.push_back(item = new Item_empty_string("Table", NAME_CHAR_LEN*2));
+  item->maybe_null = 1;
+  field_list.push_back(item = new Item_empty_string("Op", 10));
+  item->maybe_null = 1;
+  field_list.push_back(item = new Item_empty_string("Msg_type", 10));
+  item->maybe_null = 1;
+  field_list.push_back(item = new Item_empty_string("Msg_text", 255));
+  item->maybe_null = 1;
+  if (protocol->send_result_set_metadata(&field_list,
+                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
+    DBUG_RETURN(TRUE);
+
+  mysql_ha_rm_tables(thd, tables);
+
+  for (table= tables; table; table= table->next_local)
+  {
+    char table_name[NAME_LEN*2+2];
+    char* db = table->db;
+    bool fatal_error=0;
+    bool open_error;
+
+    DBUG_PRINT("admin", ("table: '%s'.'%s'", table->db, table->table_name));
+    DBUG_PRINT("admin", ("extra_open_options: %u", extra_open_options));
+    strxmov(table_name, db, ".", table->table_name, NullS);
+    thd->open_options|= extra_open_options;
+    table->lock_type= lock_type;
+    /*
+      To make code safe for re-execution we need to reset type of MDL
+      request as code below may change it.
+      To allow concurrent execution of read-only operations we acquire
+      weak metadata lock for them.
+    */
+    table->mdl_request.set_type((lock_type >= TL_WRITE_ALLOW_WRITE) ?
+                                MDL_SHARED_NO_READ_WRITE : MDL_SHARED_READ);
+    /* open only one table from local list of command */
+    {
+      TABLE_LIST *save_next_global, *save_next_local;
+      save_next_global= table->next_global;
+      table->next_global= 0;
+      save_next_local= table->next_local;
+      table->next_local= 0;
+      select->table_list.first= table;
+      /*
+        Time zone tables and SP tables can be add to lex->query_tables list,
+        so it have to be prepared.
+        TODO: Investigate if we can put extra tables into argument instead of
+        using lex->query_tables
+      */
+      lex->query_tables= table;
+      lex->query_tables_last= &table->next_global;
+      lex->query_tables_own_last= 0;
+      thd->no_warnings_for_error= no_warnings_for_error;
+      if (view_operator_func == NULL)
+        table->required_type=FRMTYPE_TABLE;
+
+      open_error= open_and_lock_tables(thd, table, TRUE, 0);
+      thd->no_warnings_for_error= 0;
+      table->next_global= save_next_global;
+      table->next_local= save_next_local;
+      thd->open_options&= ~extra_open_options;
+      /*
+        Under locked tables, we know that the table can be opened,
+        so any errors opening the table are logical errors.
+        In these cases it does not make sense to try to repair.
+      */
+      if (open_error && thd->locked_tables_mode)
+      {
+        result_code= HA_ADMIN_FAILED;
+        goto send_result;
+      }
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+      if (table->table)
+      {
+        /*
+          Set up which partitions that should be processed
+          if ALTER TABLE t ANALYZE/CHECK/OPTIMIZE/REPAIR PARTITION ..
+          CACHE INDEX/LOAD INDEX for specified partitions
+        */
+        Alter_info *alter_info= &lex->alter_info;
+
+        if (alter_info->flags & ALTER_ADMIN_PARTITION)
+        {
+          if (!table->table->part_info)
+          {
+            my_error(ER_PARTITION_MGMT_ON_NONPARTITIONED, MYF(0));
+            DBUG_RETURN(TRUE);
+          }
+          uint num_parts_found;
+          uint num_parts_opt= alter_info->partition_names.elements;
+          num_parts_found= set_part_state(alter_info, table->table->part_info,
+                                          PART_ADMIN);
+          if (num_parts_found != num_parts_opt &&
+              (!(alter_info->flags & ALTER_ALL_PARTITION)))
+          {
+            char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
+            size_t length;
+            DBUG_PRINT("admin", ("sending non existent partition error"));
+            protocol->prepare_for_resend();
+            protocol->store(table_name, system_charset_info);
+            protocol->store(operator_name, system_charset_info);
+            protocol->store(STRING_WITH_LEN("error"), system_charset_info);
+            length= my_snprintf(buff, sizeof(buff),
+                                ER(ER_DROP_PARTITION_NON_EXISTENT),
+                                table_name);
+            protocol->store(buff, length, system_charset_info);
+            if(protocol->write())
+              goto err;
+            my_eof(thd);
+            goto err;
+          }
+        }
+      }
+#endif
+    }
+    DBUG_PRINT("admin", ("table: 0x%lx", (long) table->table));
+
+    if (prepare_func)
+    {
+      DBUG_PRINT("admin", ("calling prepare_func"));
+      switch ((*prepare_func)(thd, table, check_opt)) {
+      case  1:           // error, message written to net
+        trans_rollback_stmt(thd);
+        trans_rollback(thd);
+        close_thread_tables(thd);
+        thd->mdl_context.release_transactional_locks();
+        DBUG_PRINT("admin", ("simple error, admin next table"));
+        continue;
+      case -1:           // error, message could be written to net
+        /* purecov: begin inspected */
+        DBUG_PRINT("admin", ("severe error, stop"));
+        goto err;
+        /* purecov: end */
+      default:           // should be 0 otherwise
+        DBUG_PRINT("admin", ("prepare_func succeeded"));
+        ;
+      }
+    }
+
+    /*
+      CHECK TABLE command is only command where VIEW allowed here and this
+      command use only temporary teble method for VIEWs resolving => there
+      can't be VIEW tree substitition of join view => if opening table
+      succeed then table->table will have real TABLE pointer as value (in
+      case of join view substitution table->table can be 0, but here it is
+      impossible)
+    */
+    if (!table->table)
+    {
+      DBUG_PRINT("admin", ("open table failed"));
+      if (thd->warning_info->is_empty())
+        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+                     ER_CHECK_NO_SUCH_TABLE, ER(ER_CHECK_NO_SUCH_TABLE));
+      /* if it was a view will check md5 sum */
+      if (table->view &&
+          view_checksum(thd, table) == HA_ADMIN_WRONG_CHECKSUM)
+        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+                     ER_VIEW_CHECKSUM, ER(ER_VIEW_CHECKSUM));
+      if (thd->stmt_da->is_error() &&
+          (thd->stmt_da->sql_errno() == ER_NO_SUCH_TABLE ||
+           thd->stmt_da->sql_errno() == ER_FILE_NOT_FOUND))
+        /* A missing table is just issued as a failed command */
+        result_code= HA_ADMIN_FAILED;
+      else
+        /* Default failure code is corrupt table */
+        result_code= HA_ADMIN_CORRUPT;
+      goto send_result;
+    }
+
+    if (table->view)
+    {
+      DBUG_PRINT("admin", ("calling view_operator_func"));
+      result_code= (*view_operator_func)(thd, table);
+      goto send_result;
+    }
+
+    if (table->schema_table)
+    {
+      result_code= HA_ADMIN_NOT_IMPLEMENTED;
+      goto send_result;
+    }
+
+    if ((table->table->db_stat & HA_READ_ONLY) && open_for_modify)
+    {
+      /* purecov: begin inspected */
+      char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
+      size_t length;
+      enum_sql_command save_sql_command= lex->sql_command;
+      DBUG_PRINT("admin", ("sending error message"));
+      protocol->prepare_for_resend();
+      protocol->store(table_name, system_charset_info);
+      protocol->store(operator_name, system_charset_info);
+      protocol->store(STRING_WITH_LEN("error"), system_charset_info);
+      length= my_snprintf(buff, sizeof(buff), ER(ER_OPEN_AS_READONLY),
+                          table_name);
+      protocol->store(buff, length, system_charset_info);
+      trans_commit_stmt(thd);
+      trans_commit(thd);
+      close_thread_tables(thd);
+      thd->mdl_context.release_transactional_locks();
+      lex->reset_query_tables_list(FALSE);
+      /*
+        Restore Query_tables_list::sql_command value to make statement
+        safe for re-execution.
+      */
+      lex->sql_command= save_sql_command;
+      table->table=0;				// For query cache
+      if (protocol->write())
+	goto err;
+      thd->stmt_da->reset_diagnostics_area();
+      continue;
+      /* purecov: end */
+    }
+
+    /*
+      Close all instances of the table to allow MyISAM "repair"
+      to rename files.
+      @todo: This code does not close all instances of the table.
+      It only closes instances in other connections, but if this
+      connection has LOCK TABLE t1 a READ, t1 b WRITE,
+      both t1 instances will be kept open.
+      There is no need to execute this branch for InnoDB, which does
+      repair by recreate. There is no need to do it for OPTIMIZE,
+      which doesn't move files around.
+      Hence, this code should be moved to prepare_for_repair(),
+      and executed only for MyISAM engine.
+    */
+    if (lock_type == TL_WRITE && !table->table->s->tmp_table)
+    {
+      if (wait_while_table_is_used(thd, table->table,
+                                   HA_EXTRA_PREPARE_FOR_RENAME))
+        goto err;
+      DEBUG_SYNC(thd, "after_admin_flush");
+      /* Flush entries in the query cache involving this table. */
+      query_cache_invalidate3(thd, table->table, 0);
+      /*
+        XXX: hack: switch off open_for_modify to skip the
+        flush that is made later in the execution flow. 
+      */
+      open_for_modify= 0;
+    }
+
+    if (table->table->s->crashed && operator_func == &handler::ha_check)
+    {
+      /* purecov: begin inspected */
+      DBUG_PRINT("admin", ("sending crashed warning"));
+      protocol->prepare_for_resend();
+      protocol->store(table_name, system_charset_info);
+      protocol->store(operator_name, system_charset_info);
+      protocol->store(STRING_WITH_LEN("warning"), system_charset_info);
+      protocol->store(STRING_WITH_LEN("Table is marked as crashed"),
+                      system_charset_info);
+      if (protocol->write())
+        goto err;
+      /* purecov: end */
+    }
+
+    if (operator_func == &handler::ha_repair &&
+        !(check_opt->sql_flags & TT_USEFRM))
+    {
+      if ((table->table->file->check_old_types() == HA_ADMIN_NEEDS_ALTER) ||
+          (table->table->file->ha_check_for_upgrade(check_opt) ==
+           HA_ADMIN_NEEDS_ALTER))
+      {
+        DBUG_PRINT("admin", ("recreating table"));
+        trans_rollback_stmt(thd);
+        trans_rollback(thd);
+        close_thread_tables(thd);
+        thd->mdl_context.release_transactional_locks();
+        tmp_disable_binlog(thd); // binlogging is done by caller if wanted
+        result_code= mysql_recreate_table(thd, table);
+        reenable_binlog(thd);
+        /*
+          mysql_recreate_table() can push OK or ERROR.
+          Clear 'OK' status. If there is an error, keep it:
+          we will store the error message in a result set row 
+          and then clear.
+        */
+        if (thd->stmt_da->is_ok())
+          thd->stmt_da->reset_diagnostics_area();
+        table->table= NULL;
+        result_code= result_code ? HA_ADMIN_FAILED : HA_ADMIN_OK;
+        goto send_result;
+      }
+    }
+
+    DBUG_PRINT("admin", ("calling operator_func '%s'", operator_name));
+    result_code = (table->table->file->*operator_func)(thd, check_opt);
+    DBUG_PRINT("admin", ("operator_func returned: %d", result_code));
+
+send_result:
+
+    lex->cleanup_after_one_table_open();
+    thd->clear_error();  // these errors shouldn't get client
+    {
+      List_iterator_fast<MYSQL_ERROR> it(thd->warning_info->warn_list());
+      MYSQL_ERROR *err;
+      while ((err= it++))
+      {
+        protocol->prepare_for_resend();
+        protocol->store(table_name, system_charset_info);
+        protocol->store((char*) operator_name, system_charset_info);
+        protocol->store(warning_level_names[err->get_level()].str,
+                        warning_level_names[err->get_level()].length,
+                        system_charset_info);
+        protocol->store(err->get_message_text(), system_charset_info);
+        if (protocol->write())
+          goto err;
+      }
+      thd->warning_info->clear_warning_info(thd->query_id);
+    }
+    protocol->prepare_for_resend();
+    protocol->store(table_name, system_charset_info);
+    protocol->store(operator_name, system_charset_info);
+
+send_result_message:
+
+    DBUG_PRINT("info", ("result_code: %d", result_code));
+    switch (result_code) {
+    case HA_ADMIN_NOT_IMPLEMENTED:
+      {
+       char buf[MYSQL_ERRMSG_SIZE];
+       size_t length=my_snprintf(buf, sizeof(buf),
+				ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);
+	protocol->store(STRING_WITH_LEN("note"), system_charset_info);
+	protocol->store(buf, length, system_charset_info);
+      }
+      break;
+
+    case HA_ADMIN_NOT_BASE_TABLE:
+      {
+        char buf[MYSQL_ERRMSG_SIZE];
+        size_t length= my_snprintf(buf, sizeof(buf),
+                                 ER(ER_BAD_TABLE_ERROR), table_name);
+        protocol->store(STRING_WITH_LEN("note"), system_charset_info);
+        protocol->store(buf, length, system_charset_info);
+      }
+      break;
+
+    case HA_ADMIN_OK:
+      protocol->store(STRING_WITH_LEN("status"), system_charset_info);
+      protocol->store(STRING_WITH_LEN("OK"), system_charset_info);
+      break;
+
+    case HA_ADMIN_FAILED:
+      protocol->store(STRING_WITH_LEN("status"), system_charset_info);
+      protocol->store(STRING_WITH_LEN("Operation failed"),
+                      system_charset_info);
+      break;
+
+    case HA_ADMIN_REJECT:
+      protocol->store(STRING_WITH_LEN("status"), system_charset_info);
+      protocol->store(STRING_WITH_LEN("Operation need committed state"),
+                      system_charset_info);
+      open_for_modify= FALSE;
+      break;
+
+    case HA_ADMIN_ALREADY_DONE:
+      protocol->store(STRING_WITH_LEN("status"), system_charset_info);
+      protocol->store(STRING_WITH_LEN("Table is already up to date"),
+                      system_charset_info);
+      break;
+
+    case HA_ADMIN_CORRUPT:
+      protocol->store(STRING_WITH_LEN("error"), system_charset_info);
+      protocol->store(STRING_WITH_LEN("Corrupt"), system_charset_info);
+      fatal_error=1;
+      break;
+
+    case HA_ADMIN_INVALID:
+      protocol->store(STRING_WITH_LEN("error"), system_charset_info);
+      protocol->store(STRING_WITH_LEN("Invalid argument"),
+                      system_charset_info);
+      break;
+
+    case HA_ADMIN_TRY_ALTER:
+    {
+      /*
+        This is currently used only by InnoDB. ha_innobase::optimize() answers
+        "try with alter", so here we close the table, do an ALTER TABLE,
+        reopen the table and do ha_innobase::analyze() on it.
+        We have to end the row, so analyze could return more rows.
+      */
+      trans_commit_stmt(thd);
+      trans_commit(thd);
+      close_thread_tables(thd);
+      thd->mdl_context.release_transactional_locks();
+      DEBUG_SYNC(thd, "ha_admin_try_alter");
+      protocol->store(STRING_WITH_LEN("note"), system_charset_info);
+      protocol->store(STRING_WITH_LEN(
+          "Table does not support optimize, doing recreate + analyze instead"),
+                      system_charset_info);
+      if (protocol->write())
+        goto err;
+      DBUG_PRINT("info", ("HA_ADMIN_TRY_ALTER, trying analyze..."));
+      TABLE_LIST *save_next_local= table->next_local,
+                 *save_next_global= table->next_global;
+      table->next_local= table->next_global= 0;
+      tmp_disable_binlog(thd); // binlogging is done by caller if wanted
+      result_code= mysql_recreate_table(thd, table);
+      reenable_binlog(thd);
+      /*
+        mysql_recreate_table() can push OK or ERROR.
+        Clear 'OK' status. If there is an error, keep it:
+        we will store the error message in a result set row 
+        and then clear.
+      */
+      if (thd->stmt_da->is_ok())
+        thd->stmt_da->reset_diagnostics_area();
+      trans_commit_stmt(thd);
+      trans_commit(thd);
+      close_thread_tables(thd);
+      thd->mdl_context.release_transactional_locks();
+      table->table= NULL;
+      if (!result_code) // recreation went ok
+      {
+        /* Clear the ticket released above. */
+        table->mdl_request.ticket= NULL;
+        DEBUG_SYNC(thd, "ha_admin_open_ltable");
+        table->mdl_request.set_type(MDL_SHARED_WRITE);
+        if ((table->table= open_ltable(thd, table, lock_type, 0)))
+        {
+          result_code= table->table->file->ha_analyze(thd, check_opt);
+          if (result_code == HA_ADMIN_ALREADY_DONE)
+            result_code= HA_ADMIN_OK;
+          else if (result_code)  // analyze failed
+            table->table->file->print_error(result_code, MYF(0));
+        }
+        else
+          result_code= -1; // open failed
+      }
+      /* Start a new row for the final status row */
+      protocol->prepare_for_resend();
+      protocol->store(table_name, system_charset_info);
+      protocol->store(operator_name, system_charset_info);
+      if (result_code) // either mysql_recreate_table or analyze failed
+      {
+        DBUG_ASSERT(thd->is_error());
+        if (thd->is_error())
+        {
+          const char *err_msg= thd->stmt_da->message();
+          if (!thd->vio_ok())
+          {
+            sql_print_error("%s", err_msg);
+          }
+          else
+          {
+            /* Hijack the row already in-progress. */
+            protocol->store(STRING_WITH_LEN("error"), system_charset_info);
+            protocol->store(err_msg, system_charset_info);
+            if (protocol->write())
+              goto err;
+            /* Start off another row for HA_ADMIN_FAILED */
+            protocol->prepare_for_resend();
+            protocol->store(table_name, system_charset_info);
+            protocol->store(operator_name, system_charset_info);
+          }
+          thd->clear_error();
+        }
+      }
+      result_code= result_code ? HA_ADMIN_FAILED : HA_ADMIN_OK;
+      table->next_local= save_next_local;
+      table->next_global= save_next_global;
+      goto send_result_message;
+    }
+    case HA_ADMIN_WRONG_CHECKSUM:
+    {
+      protocol->store(STRING_WITH_LEN("note"), system_charset_info);
+      protocol->store(ER(ER_VIEW_CHECKSUM), strlen(ER(ER_VIEW_CHECKSUM)),
+                      system_charset_info);
+      break;
+    }
+
+    case HA_ADMIN_NEEDS_UPGRADE:
+    case HA_ADMIN_NEEDS_ALTER:
+    {
+      char buf[MYSQL_ERRMSG_SIZE];
+      size_t length;
+
+      protocol->store(STRING_WITH_LEN("error"), system_charset_info);
+      length=my_snprintf(buf, sizeof(buf), ER(ER_TABLE_NEEDS_UPGRADE),
+                         table->table_name);
+      protocol->store(buf, length, system_charset_info);
+      fatal_error=1;
+      break;
+    }
+
+    default:				// Probably HA_ADMIN_INTERNAL_ERROR
+      {
+        char buf[MYSQL_ERRMSG_SIZE];
+        size_t length=my_snprintf(buf, sizeof(buf),
+                                "Unknown - internal error %d during operation",
+                                result_code);
+        protocol->store(STRING_WITH_LEN("error"), system_charset_info);
+        protocol->store(buf, length, system_charset_info);
+        fatal_error=1;
+        break;
+      }
+    }
+    if (table->table)
+    {
+      if (table->table->s->tmp_table)
+      {
+        /*
+          If the table was not opened successfully, do not try to get
+          status information. (Bug#47633)
+        */
+        if (open_for_modify && !open_error)
+          table->table->file->info(HA_STATUS_CONST);
+      }
+      else if (open_for_modify || fatal_error)
+      {
+        mysql_mutex_lock(&LOCK_open);
+        tdc_remove_table(thd, TDC_RT_REMOVE_UNUSED,
+                         table->db, table->table_name);
+        mysql_mutex_unlock(&LOCK_open);
+        /*
+          May be something modified. Consequently, we have to
+          invalidate the query cache.
+        */
+        table->table= 0;                        // For query cache
+        query_cache_invalidate3(thd, table, 0);
+      }
+    }
+    /* Error path, a admin command failed. */
+    trans_commit_stmt(thd);
+    trans_commit_implicit(thd);
+    close_thread_tables(thd);
+    thd->mdl_context.release_transactional_locks();
+
+    /*
+      If it is CHECK TABLE v1, v2, v3, and v1, v2, v3 are views, we will run
+      separate open_tables() for each CHECK TABLE argument.
+      Right now we do not have a separate method to reset the prelocking
+      state in the lex to the state after parsing, so each open will pollute
+      this state: add elements to lex->srotuines_list, TABLE_LISTs to
+      lex->query_tables. Below is a lame attempt to recover from this
+      pollution.
+      @todo: have a method to reset a prelocking context, or use separate
+      contexts for each open.
+    */
+    for (Sroutine_hash_entry *rt=
+           (Sroutine_hash_entry*)thd->lex->sroutines_list.first;
+         rt; rt= rt->next)
+      rt->mdl_request.ticket= NULL;
+
+    if (protocol->write())
+      goto err;
+  }
+
+  my_eof(thd);
+  DBUG_RETURN(FALSE);
+
+err:
+  trans_rollback_stmt(thd);
+  trans_rollback(thd);
+  close_thread_tables(thd);			// Shouldn't be needed
+  thd->mdl_context.release_transactional_locks();
+  if (table)
+    table->table=0;
+  DBUG_RETURN(TRUE);
+}
+
+
+/*
+  Assigned specified indexes for a table into key cache
+
+  SYNOPSIS
+    mysql_assign_to_keycache()
+    thd		Thread object
+    tables	Table list (one table only)
+
+  RETURN VALUES
+   FALSE ok
+   TRUE  error
+*/
+
+bool mysql_assign_to_keycache(THD* thd, TABLE_LIST* tables,
+			     LEX_STRING *key_cache_name)
+{
+  HA_CHECK_OPT check_opt;
+  KEY_CACHE *key_cache;
+  DBUG_ENTER("mysql_assign_to_keycache");
+
+  check_opt.init();
+  mysql_mutex_lock(&LOCK_global_system_variables);
+  if (!(key_cache= get_key_cache(key_cache_name)))
+  {
+    mysql_mutex_unlock(&LOCK_global_system_variables);
+    my_error(ER_UNKNOWN_KEY_CACHE, MYF(0), key_cache_name->str);
+    DBUG_RETURN(TRUE);
+  }
+  mysql_mutex_unlock(&LOCK_global_system_variables);
+  check_opt.key_cache= key_cache;
+  DBUG_RETURN(mysql_admin_table(thd, tables, &check_opt,
+				"assign_to_keycache", TL_READ_NO_INSERT, 0, 0,
+				0, 0, &handler::assign_to_keycache, 0));
+}
+
+
+/*
+  Preload specified indexes for a table into key cache
+
+  SYNOPSIS
+    mysql_preload_keys()
+    thd		Thread object
+    tables	Table list (one table only)
+
+  RETURN VALUES
+    FALSE ok
+    TRUE  error
+*/
+
+bool mysql_preload_keys(THD* thd, TABLE_LIST* tables)
+{
+  DBUG_ENTER("mysql_preload_keys");
+  /*
+    We cannot allow concurrent inserts. The storage engine reads
+    directly from the index file, bypassing the cache. It could read
+    outdated information if parallel inserts into cache blocks happen.
+  */
+  DBUG_RETURN(mysql_admin_table(thd, tables, 0,
+				"preload_keys", TL_READ_NO_INSERT, 0, 0, 0, 0,
+				&handler::preload_keys, 0));
+}
+
+
+bool Analyze_table_statement::execute(THD *thd)
+{
+  TABLE_LIST *first_table= m_lex->select_lex.table_list.first;
+  bool res= TRUE;
+  thr_lock_type lock_type = TL_READ_NO_INSERT;
+  DBUG_ENTER("Analyze_table_statement::execute");
+
+  if (check_table_access(thd, SELECT_ACL | INSERT_ACL, first_table,
+                         FALSE, UINT_MAX, FALSE))
+    goto error;
+  thd->enable_slow_log= opt_log_slow_admin_statements;
+  res= mysql_admin_table(thd, first_table, &m_lex->check_opt,
+                         "analyze", lock_type, 1, 0, 0, 0,
+                         &handler::ha_analyze, 0);
+  /* ! we write after unlocking the table */
+  if (!res && !m_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());
+  }
+  m_lex->select_lex.table_list.first= first_table;
+  m_lex->query_tables= first_table;
+
+error:
+  DBUG_RETURN(res);
+}
+
+
+bool Check_table_statement::execute(THD *thd)
+{
+  TABLE_LIST *first_table= m_lex->select_lex.table_list.first;
+  thr_lock_type lock_type = TL_READ_NO_INSERT;
+  bool res= TRUE;
+  DBUG_ENTER("Check_table_statement::execute");
+
+  if (check_table_access(thd, SELECT_ACL, first_table,
+                         TRUE, UINT_MAX, FALSE))
+    goto error; /* purecov: inspected */
+  thd->enable_slow_log= opt_log_slow_admin_statements;
+
+  res= mysql_admin_table(thd, first_table, &m_lex->check_opt, "check",
+                         lock_type, 0, 0, HA_OPEN_FOR_REPAIR, 0,
+                         &handler::ha_check, &view_checksum);
+
+  m_lex->select_lex.table_list.first= first_table;
+  m_lex->query_tables= first_table;
+
+error:
+  DBUG_RETURN(res);
+}
+
+
+bool Optimize_table_statement::execute(THD *thd)
+{
+  TABLE_LIST *first_table= m_lex->select_lex.table_list.first;
+  bool res= TRUE;
+  DBUG_ENTER("Optimize_table_statement::execute");
+
+  if (check_table_access(thd, SELECT_ACL | INSERT_ACL, first_table,
+                         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_admin_table(thd, first_table, &m_lex->check_opt,
+                      "optimize", TL_WRITE, 1, 0, 0, 0,
+                      &handler::ha_optimize, 0);
+  /* ! we write after unlocking the table */
+  if (!res && !m_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());
+  }
+  m_lex->select_lex.table_list.first= first_table;
+  m_lex->query_tables= first_table;
+
+error:
+  DBUG_RETURN(res);
+}
+
+
+bool Repair_table_statement::execute(THD *thd)
+{
+  TABLE_LIST *first_table= m_lex->select_lex.table_list.first;
+  bool res= TRUE;
+  DBUG_ENTER("Repair_table_statement::execute");
+
+  if (check_table_access(thd, SELECT_ACL | INSERT_ACL, first_table,
+                         FALSE, UINT_MAX, FALSE))
+    goto error; /* purecov: inspected */
+  thd->enable_slow_log= opt_log_slow_admin_statements;
+  res= mysql_admin_table(thd, first_table, &m_lex->check_opt, "repair",
+                         TL_WRITE, 1,
+                         test(m_lex->check_opt.sql_flags & TT_USEFRM),
+                         HA_OPEN_FOR_REPAIR, &prepare_for_repair,
+                         &handler::ha_repair, 0);
+
+  /* ! we write after unlocking the table */
+  if (!res && !m_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());
+  }
+  m_lex->select_lex.table_list.first= first_table;
+  m_lex->query_tables= first_table;
+
+error:
+  DBUG_RETURN(res);
+}

=== added file 'sql/sql_admin.h'
--- a/sql/sql_admin.h	1970-01-01 00:00:00 +0000
+++ b/sql/sql_admin.h	2010-08-16 14:25:23 +0000
@@ -0,0 +1,132 @@
+/* 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

=== renamed file 'sql/sql_alter_table.cc' => 'sql/sql_alter.cc'
--- a/sql/sql_alter_table.cc	2010-06-17 10:37:03 +0000
+++ b/sql/sql_alter.cc	2010-08-16 15:07:53 +0000
@@ -17,7 +17,7 @@
                                              // check_merge_table_access
 #include "sql_table.h"                       // mysql_alter_table,
                                              // mysql_exchange_partition
-#include "sql_alter_table.h"
+#include "sql_alter.h"
 
 bool Alter_table_statement::execute(THD *thd)
 {
@@ -53,6 +53,7 @@ bool Alter_table_statement::execute(THD 
   /* Must be set in the parser */
   DBUG_ASSERT(select_lex->db);
   DBUG_ASSERT(!(alter_info.flags & ALTER_EXCHANGE_PARTITION));
+  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,
@@ -74,10 +75,10 @@ bool Alter_table_statement::execute(THD 
     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))
+    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 */
   }
 
@@ -94,8 +95,10 @@ bool Alter_table_statement::execute(THD 
 
   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,
+  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);

=== renamed file 'sql/sql_alter_table.h' => 'sql/sql_alter.h'
=== modified file 'sql/sql_lex.h'
--- a/sql/sql_lex.h	2010-08-10 11:58:46 +0000
+++ b/sql/sql_lex.h	2010-08-16 15:07:53 +0000
@@ -935,7 +935,7 @@ enum enum_alter_table_change_level
 /**
   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 ta the sql_alter_table.h
+  removed once Alter_info is moved to the sql_alter.h
   header.
 */
 class Alter_table_change_level

=== modified file 'sql/sql_parse.cc'
--- a/sql/sql_parse.cc	2010-08-12 13:56:53 +0000
+++ b/sql/sql_parse.cc	2010-08-16 15:07:53 +0000
@@ -50,6 +50,7 @@
                               // mysql_backup_table,
                               // mysql_restore_table
 #include "sql_truncate.h"     // mysql_truncate_table
+#include "sql_admin.h"        // mysql_assign_to_keycache
 #include "sql_connect.h"      // check_user,
                               // decrease_user_connections,
                               // thd_init_client_charset, check_mqh,
@@ -2941,81 +2942,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;
@@ -3236,23 +3162,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);
@@ -4638,6 +4547,11 @@ 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 */

=== modified file 'sql/sql_partition_admin.cc'
--- a/sql/sql_partition_admin.cc	2010-06-23 10:48:39 +0000
+++ b/sql/sql_partition_admin.cc	2010-08-16 15:07:53 +0000
@@ -15,13 +15,18 @@
 
 #include "sql_parse.h"                      // check_access,
                                             // check_merge_table_access
+                                            // check_one_table_access
 #include "sql_table.h"                      // mysql_alter_table, etc.
-#include "sql_alter_table.h"                // Alter_table_statement
-#include "sql_partition_admin.h"            // Alter_table_exchange_*
+#include "sql_lex.h"                        // Sql_statement
+#include "sql_alter.h"                      // Alter_table_statement
 #include "sql_partition.h"                  // struct partition_info, etc.
 #include "sql_handler.h"                    // mysql_ha_rm_tables
 #include "sql_base.h"                       // open_and_lock_tables, etc
 #include "debug_sync.h"                     // DEBUG_SYNC
+#include "sql_truncate.h"                   // mysql_truncate_table,
+                                            // Truncate_statement
+#include "sql_admin.h"                      // Analyze/Check/.._table_statement
+#include "sql_partition_admin.h"            // Alter_table_*_partition
 
 #ifndef WITH_PARTITION_STORAGE_ENGINE
 
@@ -628,4 +633,107 @@ err:
   DBUG_RETURN(error);
 }
 
+
+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 */

=== modified file 'sql/sql_partition_admin.h'
--- a/sql/sql_partition_admin.h	2010-06-16 20:13:52 +0000
+++ b/sql/sql_partition_admin.h	2010-08-16 14:22:16 +0000
@@ -22,11 +22,11 @@
   Stub class that returns a error if the partition storage engine is
   not supported.
 */
-class Partition_statement_unsupported : public Alter_table_common
+class Partition_statement_unsupported : public Sql_statement
 {
 public:
   Partition_statement_unsupported(LEX *lex)
-    : Alter_table_common(lex)
+    : Sql_statement(lex)
   {}
 
   ~Partition_statement_unsupported()
@@ -35,6 +35,7 @@ public:
   bool execute(THD *thd);
 };
 
+
 class Alter_table_exchange_partition_statement :
   public Partition_statement_unsupported
 {
@@ -47,6 +48,71 @@ public:
   {}
 };
 
+
+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
 
 /**
@@ -78,5 +144,135 @@ private:
   bool exchange_partition(THD *thd, TABLE_LIST *, Alter_info *);
 };
 
+
+/**
+  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 */

=== modified file 'sql/sql_table.cc'
--- a/sql/sql_table.cc	2010-08-16 06:40:26 +0000
+++ b/sql/sql_table.cc	2010-08-16 14:22:16 +0000
@@ -52,7 +52,6 @@
 #include "sql_parse.h"
 #include "sql_show.h"
 #include "transaction.h"
-#include "keycaches.h"
 #include "datadict.h"  // dd_frm_type()
 
 #ifdef __WIN__
@@ -4566,885 +4565,6 @@ mysql_rename_table(handlerton *base, con
 }
 
 
-static int send_check_errmsg(THD *thd, TABLE_LIST* table,
-			     const char* operator_name, const char* errmsg)
-
-{
-  Protocol *protocol= thd->protocol;
-  protocol->prepare_for_resend();
-  protocol->store(table->alias, system_charset_info);
-  protocol->store((char*) operator_name, system_charset_info);
-  protocol->store(STRING_WITH_LEN("error"), system_charset_info);
-  protocol->store(errmsg, system_charset_info);
-  thd->clear_error();
-  if (protocol->write())
-    return -1;
-  return 1;
-}
-
-
-static int prepare_for_repair(THD *thd, TABLE_LIST *table_list,
-			      HA_CHECK_OPT *check_opt)
-{
-  int error= 0;
-  TABLE tmp_table, *table;
-  TABLE_SHARE *share;
-  bool has_mdl_lock= FALSE;
-  char from[FN_REFLEN],tmp[FN_REFLEN+32];
-  const char **ext;
-  MY_STAT stat_info;
-  Open_table_context ot_ctx(thd, (MYSQL_OPEN_IGNORE_FLUSH |
-                                  MYSQL_OPEN_HAS_MDL_LOCK |
-                                  MYSQL_LOCK_IGNORE_TIMEOUT));
-  DBUG_ENTER("prepare_for_repair");
-
-  if (!(check_opt->sql_flags & TT_USEFRM))
-    DBUG_RETURN(0);
-
-  if (!(table= table_list->table))
-  {
-    char key[MAX_DBKEY_LENGTH];
-    uint key_length;
-    /*
-      If the table didn't exist, we have a shared metadata lock
-      on it that is left from mysql_admin_table()'s attempt to 
-      open it. Release the shared metadata lock before trying to
-      acquire the exclusive lock to satisfy MDL asserts and avoid
-      deadlocks.
-    */
-    thd->mdl_context.release_transactional_locks();
-    /*
-      Attempt to do full-blown table open in mysql_admin_table() has failed.
-      Let us try to open at least a .FRM for this table.
-    */
-    my_hash_value_type hash_value;
-
-    key_length= create_table_def_key(thd, key, table_list, 0);
-    table_list->mdl_request.init(MDL_key::TABLE,
-                                 table_list->db, table_list->table_name,
-                                 MDL_EXCLUSIVE);
-
-    if (lock_table_names(thd, table_list, table_list->next_global,
-                         thd->variables.lock_wait_timeout,
-                         MYSQL_OPEN_SKIP_TEMPORARY))
-      DBUG_RETURN(0);
-    has_mdl_lock= TRUE;
-
-    hash_value= my_calc_hash(&table_def_cache, (uchar*) key, key_length);
-    mysql_mutex_lock(&LOCK_open);
-    if (!(share= (get_table_share(thd, table_list, key, key_length, 0,
-                                  &error, hash_value))))
-    {
-      mysql_mutex_unlock(&LOCK_open);
-      DBUG_RETURN(0);				// Can't open frm file
-    }
-
-    if (open_table_from_share(thd, share, "", 0, 0, 0, &tmp_table, FALSE))
-    {
-      release_table_share(share);
-      mysql_mutex_unlock(&LOCK_open);
-      DBUG_RETURN(0);                           // Out of memory
-    }
-    mysql_mutex_unlock(&LOCK_open);
-    table= &tmp_table;
-  }
-
-  /* A MERGE table must not come here. */
-  DBUG_ASSERT(table->file->ht->db_type != DB_TYPE_MRG_MYISAM);
-
-  /*
-    REPAIR TABLE ... USE_FRM for temporary tables makes little sense.
-  */
-  if (table->s->tmp_table)
-  {
-    error= send_check_errmsg(thd, table_list, "repair",
-			     "Cannot repair temporary table from .frm file");
-    goto end;
-  }
-
-  /*
-    User gave us USE_FRM which means that the header in the index file is
-    trashed.
-    In this case we will try to fix the table the following way:
-    - Rename the data file to a temporary name
-    - Truncate the table
-    - Replace the new data file with the old one
-    - Run a normal repair using the new index file and the old data file
-  */
-
-  if (table->s->frm_version != FRM_VER_TRUE_VARCHAR)
-  {
-    error= send_check_errmsg(thd, table_list, "repair",
-                             "Failed repairing incompatible .frm file");
-    goto end;
-  }
-
-  /*
-    Check if this is a table type that stores index and data separately,
-    like ISAM or MyISAM. We assume fixed order of engine file name
-    extentions array. First element of engine file name extentions array
-    is meta/index file extention. Second element - data file extention. 
-  */
-  ext= table->file->bas_ext();
-  if (!ext[0] || !ext[1])
-    goto end;					// No data file
-
-  // Name of data file
-  strxmov(from, table->s->normalized_path.str, ext[1], NullS);
-  if (!mysql_file_stat(key_file_misc, from, &stat_info, MYF(0)))
-    goto end;				// Can't use USE_FRM flag
-
-  my_snprintf(tmp, sizeof(tmp), "%s-%lx_%lx",
-	      from, current_pid, thd->thread_id);
-
-  if (table_list->table)
-  {
-    /*
-      Table was successfully open in mysql_admin_table(). Now we need
-      to close it, but leave it protected by exclusive metadata lock.
-    */
-    if (wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN))
-      goto end;
-    close_all_tables_for_name(thd, table_list->table->s, FALSE);
-    table_list->table= 0;
-  }
-  /*
-    After this point we have an exclusive metadata lock on our table
-    in both cases when table was successfully open in mysql_admin_table()
-    and when it was open in prepare_for_repair().
-  */
-
-  if (my_rename(from, tmp, MYF(MY_WME)))
-  {
-    error= send_check_errmsg(thd, table_list, "repair",
-			     "Failed renaming data file");
-    goto end;
-  }
-  if (dd_recreate_table(thd, table_list->db, table_list->table_name))
-  {
-    error= send_check_errmsg(thd, table_list, "repair",
-			     "Failed generating table from .frm file");
-    goto end;
-  }
-  /*
-    'FALSE' for 'using_transactions' means don't postpone
-    invalidation till the end of a transaction, but do it
-    immediately.
-  */
-  query_cache_invalidate3(thd, table_list, FALSE);
-  if (mysql_file_rename(key_file_misc, tmp, from, MYF(MY_WME)))
-  {
-    error= send_check_errmsg(thd, table_list, "repair",
-			     "Failed restoring .MYD file");
-    goto end;
-  }
-
-  if (thd->locked_tables_list.reopen_tables(thd))
-    goto end;
-
-  /*
-    Now we should be able to open the partially repaired table
-    to finish the repair in the handler later on.
-  */
-  if (open_table(thd, table_list, thd->mem_root, &ot_ctx))
-  {
-    error= send_check_errmsg(thd, table_list, "repair",
-                             "Failed to open partially repaired table");
-    goto end;
-  }
-
-end:
-  thd->locked_tables_list.unlink_all_closed_tables(thd, NULL, 0);
-  if (table == &tmp_table)
-  {
-    mysql_mutex_lock(&LOCK_open);
-    closefrm(table, 1);				// Free allocated memory
-    mysql_mutex_unlock(&LOCK_open);
-  }
-  /* In case of a temporary table there will be no metadata lock. */
-  if (error && has_mdl_lock)
-    thd->mdl_context.release_transactional_locks();
-
-  DBUG_RETURN(error);
-}
-
-
-
-/*
-  RETURN VALUES
-    FALSE Message sent to net (admin operation went ok)
-    TRUE  Message should be sent by caller 
-          (admin operation or network communication failed)
-*/
-static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
-                              HA_CHECK_OPT* check_opt,
-                              const char *operator_name,
-                              thr_lock_type lock_type,
-                              bool open_for_modify,
-                              bool no_warnings_for_error,
-                              uint extra_open_options,
-                              int (*prepare_func)(THD *, TABLE_LIST *,
-                                                  HA_CHECK_OPT *),
-                              int (handler::*operator_func)(THD *,
-                                                            HA_CHECK_OPT *),
-                              int (view_operator_func)(THD *, TABLE_LIST*))
-{
-  TABLE_LIST *table;
-  SELECT_LEX *select= &thd->lex->select_lex;
-  List<Item> field_list;
-  Item *item;
-  Protocol *protocol= thd->protocol;
-  LEX *lex= thd->lex;
-  int result_code;
-  DBUG_ENTER("mysql_admin_table");
-
-  field_list.push_back(item = new Item_empty_string("Table", NAME_CHAR_LEN*2));
-  item->maybe_null = 1;
-  field_list.push_back(item = new Item_empty_string("Op", 10));
-  item->maybe_null = 1;
-  field_list.push_back(item = new Item_empty_string("Msg_type", 10));
-  item->maybe_null = 1;
-  field_list.push_back(item = new Item_empty_string("Msg_text", 255));
-  item->maybe_null = 1;
-  if (protocol->send_result_set_metadata(&field_list,
-                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
-    DBUG_RETURN(TRUE);
-
-  mysql_ha_rm_tables(thd, tables);
-
-  for (table= tables; table; table= table->next_local)
-  {
-    char table_name[NAME_LEN*2+2];
-    char* db = table->db;
-    bool fatal_error=0;
-    bool open_error;
-
-    DBUG_PRINT("admin", ("table: '%s'.'%s'", table->db, table->table_name));
-    DBUG_PRINT("admin", ("extra_open_options: %u", extra_open_options));
-    strxmov(table_name, db, ".", table->table_name, NullS);
-    thd->open_options|= extra_open_options;
-    table->lock_type= lock_type;
-    /*
-      To make code safe for re-execution we need to reset type of MDL
-      request as code below may change it.
-      To allow concurrent execution of read-only operations we acquire
-      weak metadata lock for them.
-    */
-    table->mdl_request.set_type((lock_type >= TL_WRITE_ALLOW_WRITE) ?
-                                MDL_SHARED_NO_READ_WRITE : MDL_SHARED_READ);
-    /* open only one table from local list of command */
-    {
-      TABLE_LIST *save_next_global, *save_next_local;
-      save_next_global= table->next_global;
-      table->next_global= 0;
-      save_next_local= table->next_local;
-      table->next_local= 0;
-      select->table_list.first= table;
-      /*
-        Time zone tables and SP tables can be add to lex->query_tables list,
-        so it have to be prepared.
-        TODO: Investigate if we can put extra tables into argument instead of
-        using lex->query_tables
-      */
-      lex->query_tables= table;
-      lex->query_tables_last= &table->next_global;
-      lex->query_tables_own_last= 0;
-      thd->no_warnings_for_error= no_warnings_for_error;
-      if (view_operator_func == NULL)
-        table->required_type=FRMTYPE_TABLE;
-
-      open_error= open_and_lock_tables(thd, table, TRUE, 0);
-      thd->no_warnings_for_error= 0;
-      table->next_global= save_next_global;
-      table->next_local= save_next_local;
-      thd->open_options&= ~extra_open_options;
-      /*
-        Under locked tables, we know that the table can be opened,
-        so any errors opening the table are logical errors.
-        In these cases it does not make sense to try to repair.
-      */
-      if (open_error && thd->locked_tables_mode)
-      {
-        result_code= HA_ADMIN_FAILED;
-        goto send_result;
-      }
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-      if (table->table)
-      {
-        /*
-          Set up which partitions that should be processed
-          if ALTER TABLE t ANALYZE/CHECK/OPTIMIZE/REPAIR PARTITION ..
-          CACHE INDEX/LOAD INDEX for specified partitions
-        */
-        Alter_info *alter_info= &lex->alter_info;
-
-        if (alter_info->flags & ALTER_ADMIN_PARTITION)
-        {
-          if (!table->table->part_info)
-          {
-            my_error(ER_PARTITION_MGMT_ON_NONPARTITIONED, MYF(0));
-            DBUG_RETURN(TRUE);
-          }
-          uint num_parts_found;
-          uint num_parts_opt= alter_info->partition_names.elements;
-          num_parts_found= set_part_state(alter_info, table->table->part_info,
-                                          PART_ADMIN);
-          if (num_parts_found != num_parts_opt &&
-              (!(alter_info->flags & ALTER_ALL_PARTITION)))
-          {
-            char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
-            size_t length;
-            DBUG_PRINT("admin", ("sending non existent partition error"));
-            protocol->prepare_for_resend();
-            protocol->store(table_name, system_charset_info);
-            protocol->store(operator_name, system_charset_info);
-            protocol->store(STRING_WITH_LEN("error"), system_charset_info);
-            length= my_snprintf(buff, sizeof(buff),
-                                ER(ER_DROP_PARTITION_NON_EXISTENT),
-                                table_name);
-            protocol->store(buff, length, system_charset_info);
-            if(protocol->write())
-              goto err;
-            my_eof(thd);
-            goto err;
-          }
-        }
-      }
-#endif
-    }
-    DBUG_PRINT("admin", ("table: 0x%lx", (long) table->table));
-
-    if (prepare_func)
-    {
-      DBUG_PRINT("admin", ("calling prepare_func"));
-      switch ((*prepare_func)(thd, table, check_opt)) {
-      case  1:           // error, message written to net
-        trans_rollback_stmt(thd);
-        trans_rollback(thd);
-        close_thread_tables(thd);
-        thd->mdl_context.release_transactional_locks();
-        DBUG_PRINT("admin", ("simple error, admin next table"));
-        continue;
-      case -1:           // error, message could be written to net
-        /* purecov: begin inspected */
-        DBUG_PRINT("admin", ("severe error, stop"));
-        goto err;
-        /* purecov: end */
-      default:           // should be 0 otherwise
-        DBUG_PRINT("admin", ("prepare_func succeeded"));
-        ;
-      }
-    }
-
-    /*
-      CHECK TABLE command is only command where VIEW allowed here and this
-      command use only temporary teble method for VIEWs resolving => there
-      can't be VIEW tree substitition of join view => if opening table
-      succeed then table->table will have real TABLE pointer as value (in
-      case of join view substitution table->table can be 0, but here it is
-      impossible)
-    */
-    if (!table->table)
-    {
-      DBUG_PRINT("admin", ("open table failed"));
-      if (thd->warning_info->is_empty())
-        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
-                     ER_CHECK_NO_SUCH_TABLE, ER(ER_CHECK_NO_SUCH_TABLE));
-      /* if it was a view will check md5 sum */
-      if (table->view &&
-          view_checksum(thd, table) == HA_ADMIN_WRONG_CHECKSUM)
-        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
-                     ER_VIEW_CHECKSUM, ER(ER_VIEW_CHECKSUM));
-      if (thd->stmt_da->is_error() &&
-          (thd->stmt_da->sql_errno() == ER_NO_SUCH_TABLE ||
-           thd->stmt_da->sql_errno() == ER_FILE_NOT_FOUND))
-        /* A missing table is just issued as a failed command */
-        result_code= HA_ADMIN_FAILED;
-      else
-        /* Default failure code is corrupt table */
-        result_code= HA_ADMIN_CORRUPT;
-      goto send_result;
-    }
-
-    if (table->view)
-    {
-      DBUG_PRINT("admin", ("calling view_operator_func"));
-      result_code= (*view_operator_func)(thd, table);
-      goto send_result;
-    }
-
-    if (table->schema_table)
-    {
-      result_code= HA_ADMIN_NOT_IMPLEMENTED;
-      goto send_result;
-    }
-
-    if ((table->table->db_stat & HA_READ_ONLY) && open_for_modify)
-    {
-      /* purecov: begin inspected */
-      char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
-      size_t length;
-      enum_sql_command save_sql_command= lex->sql_command;
-      DBUG_PRINT("admin", ("sending error message"));
-      protocol->prepare_for_resend();
-      protocol->store(table_name, system_charset_info);
-      protocol->store(operator_name, system_charset_info);
-      protocol->store(STRING_WITH_LEN("error"), system_charset_info);
-      length= my_snprintf(buff, sizeof(buff), ER(ER_OPEN_AS_READONLY),
-                          table_name);
-      protocol->store(buff, length, system_charset_info);
-      trans_commit_stmt(thd);
-      trans_commit(thd);
-      close_thread_tables(thd);
-      thd->mdl_context.release_transactional_locks();
-      lex->reset_query_tables_list(FALSE);
-      /*
-        Restore Query_tables_list::sql_command value to make statement
-        safe for re-execution.
-      */
-      lex->sql_command= save_sql_command;
-      table->table=0;				// For query cache
-      if (protocol->write())
-	goto err;
-      thd->stmt_da->reset_diagnostics_area();
-      continue;
-      /* purecov: end */
-    }
-
-    /*
-      Close all instances of the table to allow MyISAM "repair"
-      to rename files.
-      @todo: This code does not close all instances of the table.
-      It only closes instances in other connections, but if this
-      connection has LOCK TABLE t1 a READ, t1 b WRITE,
-      both t1 instances will be kept open.
-      There is no need to execute this branch for InnoDB, which does
-      repair by recreate. There is no need to do it for OPTIMIZE,
-      which doesn't move files around.
-      Hence, this code should be moved to prepare_for_repair(),
-      and executed only for MyISAM engine.
-    */
-    if (lock_type == TL_WRITE && !table->table->s->tmp_table)
-    {
-      if (wait_while_table_is_used(thd, table->table,
-                                   HA_EXTRA_PREPARE_FOR_RENAME))
-        goto err;
-      DEBUG_SYNC(thd, "after_admin_flush");
-      /* Flush entries in the query cache involving this table. */
-      query_cache_invalidate3(thd, table->table, 0);
-      /*
-        XXX: hack: switch off open_for_modify to skip the
-        flush that is made later in the execution flow. 
-      */
-      open_for_modify= 0;
-    }
-
-    if (table->table->s->crashed && operator_func == &handler::ha_check)
-    {
-      /* purecov: begin inspected */
-      DBUG_PRINT("admin", ("sending crashed warning"));
-      protocol->prepare_for_resend();
-      protocol->store(table_name, system_charset_info);
-      protocol->store(operator_name, system_charset_info);
-      protocol->store(STRING_WITH_LEN("warning"), system_charset_info);
-      protocol->store(STRING_WITH_LEN("Table is marked as crashed"),
-                      system_charset_info);
-      if (protocol->write())
-        goto err;
-      /* purecov: end */
-    }
-
-    if (operator_func == &handler::ha_repair &&
-        !(check_opt->sql_flags & TT_USEFRM))
-    {
-      if ((table->table->file->check_old_types() == HA_ADMIN_NEEDS_ALTER) ||
-          (table->table->file->ha_check_for_upgrade(check_opt) ==
-           HA_ADMIN_NEEDS_ALTER))
-      {
-        DBUG_PRINT("admin", ("recreating table"));
-        trans_rollback_stmt(thd);
-        trans_rollback(thd);
-        close_thread_tables(thd);
-        thd->mdl_context.release_transactional_locks();
-        tmp_disable_binlog(thd); // binlogging is done by caller if wanted
-        result_code= mysql_recreate_table(thd, table);
-        reenable_binlog(thd);
-        /*
-          mysql_recreate_table() can push OK or ERROR.
-          Clear 'OK' status. If there is an error, keep it:
-          we will store the error message in a result set row 
-          and then clear.
-        */
-        if (thd->stmt_da->is_ok())
-          thd->stmt_da->reset_diagnostics_area();
-        table->table= NULL;
-        result_code= result_code ? HA_ADMIN_FAILED : HA_ADMIN_OK;
-        goto send_result;
-      }
-    }
-
-    DBUG_PRINT("admin", ("calling operator_func '%s'", operator_name));
-    result_code = (table->table->file->*operator_func)(thd, check_opt);
-    DBUG_PRINT("admin", ("operator_func returned: %d", result_code));
-
-send_result:
-
-    lex->cleanup_after_one_table_open();
-    thd->clear_error();  // these errors shouldn't get client
-    {
-      List_iterator_fast<MYSQL_ERROR> it(thd->warning_info->warn_list());
-      MYSQL_ERROR *err;
-      while ((err= it++))
-      {
-        protocol->prepare_for_resend();
-        protocol->store(table_name, system_charset_info);
-        protocol->store((char*) operator_name, system_charset_info);
-        protocol->store(warning_level_names[err->get_level()].str,
-                        warning_level_names[err->get_level()].length,
-                        system_charset_info);
-        protocol->store(err->get_message_text(), system_charset_info);
-        if (protocol->write())
-          goto err;
-      }
-      thd->warning_info->clear_warning_info(thd->query_id);
-    }
-    protocol->prepare_for_resend();
-    protocol->store(table_name, system_charset_info);
-    protocol->store(operator_name, system_charset_info);
-
-send_result_message:
-
-    DBUG_PRINT("info", ("result_code: %d", result_code));
-    switch (result_code) {
-    case HA_ADMIN_NOT_IMPLEMENTED:
-      {
-       char buf[MYSQL_ERRMSG_SIZE];
-       size_t length=my_snprintf(buf, sizeof(buf),
-				ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);
-	protocol->store(STRING_WITH_LEN("note"), system_charset_info);
-	protocol->store(buf, length, system_charset_info);
-      }
-      break;
-
-    case HA_ADMIN_NOT_BASE_TABLE:
-      {
-        char buf[MYSQL_ERRMSG_SIZE];
-        size_t length= my_snprintf(buf, sizeof(buf),
-                                 ER(ER_BAD_TABLE_ERROR), table_name);
-        protocol->store(STRING_WITH_LEN("note"), system_charset_info);
-        protocol->store(buf, length, system_charset_info);
-      }
-      break;
-
-    case HA_ADMIN_OK:
-      protocol->store(STRING_WITH_LEN("status"), system_charset_info);
-      protocol->store(STRING_WITH_LEN("OK"), system_charset_info);
-      break;
-
-    case HA_ADMIN_FAILED:
-      protocol->store(STRING_WITH_LEN("status"), system_charset_info);
-      protocol->store(STRING_WITH_LEN("Operation failed"),
-                      system_charset_info);
-      break;
-
-    case HA_ADMIN_REJECT:
-      protocol->store(STRING_WITH_LEN("status"), system_charset_info);
-      protocol->store(STRING_WITH_LEN("Operation need committed state"),
-                      system_charset_info);
-      open_for_modify= FALSE;
-      break;
-
-    case HA_ADMIN_ALREADY_DONE:
-      protocol->store(STRING_WITH_LEN("status"), system_charset_info);
-      protocol->store(STRING_WITH_LEN("Table is already up to date"),
-                      system_charset_info);
-      break;
-
-    case HA_ADMIN_CORRUPT:
-      protocol->store(STRING_WITH_LEN("error"), system_charset_info);
-      protocol->store(STRING_WITH_LEN("Corrupt"), system_charset_info);
-      fatal_error=1;
-      break;
-
-    case HA_ADMIN_INVALID:
-      protocol->store(STRING_WITH_LEN("error"), system_charset_info);
-      protocol->store(STRING_WITH_LEN("Invalid argument"),
-                      system_charset_info);
-      break;
-
-    case HA_ADMIN_TRY_ALTER:
-    {
-      /*
-        This is currently used only by InnoDB. ha_innobase::optimize() answers
-        "try with alter", so here we close the table, do an ALTER TABLE,
-        reopen the table and do ha_innobase::analyze() on it.
-        We have to end the row, so analyze could return more rows.
-      */
-      trans_commit_stmt(thd);
-      trans_commit(thd);
-      close_thread_tables(thd);
-      thd->mdl_context.release_transactional_locks();
-      DEBUG_SYNC(thd, "ha_admin_try_alter");
-      protocol->store(STRING_WITH_LEN("note"), system_charset_info);
-      protocol->store(STRING_WITH_LEN(
-          "Table does not support optimize, doing recreate + analyze instead"),
-                      system_charset_info);
-      if (protocol->write())
-        goto err;
-      DBUG_PRINT("info", ("HA_ADMIN_TRY_ALTER, trying analyze..."));
-      TABLE_LIST *save_next_local= table->next_local,
-                 *save_next_global= table->next_global;
-      table->next_local= table->next_global= 0;
-      tmp_disable_binlog(thd); // binlogging is done by caller if wanted
-      result_code= mysql_recreate_table(thd, table);
-      reenable_binlog(thd);
-      /*
-        mysql_recreate_table() can push OK or ERROR.
-        Clear 'OK' status. If there is an error, keep it:
-        we will store the error message in a result set row 
-        and then clear.
-      */
-      if (thd->stmt_da->is_ok())
-        thd->stmt_da->reset_diagnostics_area();
-      trans_commit_stmt(thd);
-      trans_commit(thd);
-      close_thread_tables(thd);
-      thd->mdl_context.release_transactional_locks();
-      table->table= NULL;
-      if (!result_code) // recreation went ok
-      {
-        /* Clear the ticket released above. */
-        table->mdl_request.ticket= NULL;
-        DEBUG_SYNC(thd, "ha_admin_open_ltable");
-        table->mdl_request.set_type(MDL_SHARED_WRITE);
-        if ((table->table= open_ltable(thd, table, lock_type, 0)))
-        {
-          result_code= table->table->file->ha_analyze(thd, check_opt);
-          if (result_code == HA_ADMIN_ALREADY_DONE)
-            result_code= HA_ADMIN_OK;
-          else if (result_code)  // analyze failed
-            table->table->file->print_error(result_code, MYF(0));
-        }
-        else
-          result_code= -1; // open failed
-      }
-      /* Start a new row for the final status row */
-      protocol->prepare_for_resend();
-      protocol->store(table_name, system_charset_info);
-      protocol->store(operator_name, system_charset_info);
-      if (result_code) // either mysql_recreate_table or analyze failed
-      {
-        DBUG_ASSERT(thd->is_error());
-        if (thd->is_error())
-        {
-          const char *err_msg= thd->stmt_da->message();
-          if (!thd->vio_ok())
-          {
-            sql_print_error("%s", err_msg);
-          }
-          else
-          {
-            /* Hijack the row already in-progress. */
-            protocol->store(STRING_WITH_LEN("error"), system_charset_info);
-            protocol->store(err_msg, system_charset_info);
-            if (protocol->write())
-              goto err;
-            /* Start off another row for HA_ADMIN_FAILED */
-            protocol->prepare_for_resend();
-            protocol->store(table_name, system_charset_info);
-            protocol->store(operator_name, system_charset_info);
-          }
-          thd->clear_error();
-        }
-      }
-      result_code= result_code ? HA_ADMIN_FAILED : HA_ADMIN_OK;
-      table->next_local= save_next_local;
-      table->next_global= save_next_global;
-      goto send_result_message;
-    }
-    case HA_ADMIN_WRONG_CHECKSUM:
-    {
-      protocol->store(STRING_WITH_LEN("note"), system_charset_info);
-      protocol->store(ER(ER_VIEW_CHECKSUM), strlen(ER(ER_VIEW_CHECKSUM)),
-                      system_charset_info);
-      break;
-    }
-
-    case HA_ADMIN_NEEDS_UPGRADE:
-    case HA_ADMIN_NEEDS_ALTER:
-    {
-      char buf[MYSQL_ERRMSG_SIZE];
-      size_t length;
-
-      protocol->store(STRING_WITH_LEN("error"), system_charset_info);
-      length=my_snprintf(buf, sizeof(buf), ER(ER_TABLE_NEEDS_UPGRADE),
-                         table->table_name);
-      protocol->store(buf, length, system_charset_info);
-      fatal_error=1;
-      break;
-    }
-
-    default:				// Probably HA_ADMIN_INTERNAL_ERROR
-      {
-        char buf[MYSQL_ERRMSG_SIZE];
-        size_t length=my_snprintf(buf, sizeof(buf),
-                                "Unknown - internal error %d during operation",
-                                result_code);
-        protocol->store(STRING_WITH_LEN("error"), system_charset_info);
-        protocol->store(buf, length, system_charset_info);
-        fatal_error=1;
-        break;
-      }
-    }
-    if (table->table)
-    {
-      if (table->table->s->tmp_table)
-      {
-        /*
-          If the table was not opened successfully, do not try to get
-          status information. (Bug#47633)
-        */
-        if (open_for_modify && !open_error)
-          table->table->file->info(HA_STATUS_CONST);
-      }
-      else if (open_for_modify || fatal_error)
-      {
-        mysql_mutex_lock(&LOCK_open);
-        tdc_remove_table(thd, TDC_RT_REMOVE_UNUSED,
-                         table->db, table->table_name);
-        mysql_mutex_unlock(&LOCK_open);
-        /*
-          May be something modified. Consequently, we have to
-          invalidate the query cache.
-        */
-        table->table= 0;			// For query cache
-        query_cache_invalidate3(thd, table, 0);
-      }
-    }
-    /* Error path, a admin command failed. */
-    trans_commit_stmt(thd);
-    trans_commit_implicit(thd);
-    close_thread_tables(thd);
-    thd->mdl_context.release_transactional_locks();
-
-    /*
-      If it is CHECK TABLE v1, v2, v3, and v1, v2, v3 are views, we will run
-      separate open_tables() for each CHECK TABLE argument.
-      Right now we do not have a separate method to reset the prelocking
-      state in the lex to the state after parsing, so each open will pollute
-      this state: add elements to lex->srotuines_list, TABLE_LISTs to
-      lex->query_tables. Below is a lame attempt to recover from this
-      pollution.
-      @todo: have a method to reset a prelocking context, or use separate
-      contexts for each open.
-    */
-    for (Sroutine_hash_entry *rt=
-           (Sroutine_hash_entry*)thd->lex->sroutines_list.first;
-         rt; rt= rt->next)
-      rt->mdl_request.ticket= NULL;
-
-    if (protocol->write())
-      goto err;
-  }
-
-  my_eof(thd);
-  DBUG_RETURN(FALSE);
-
-err:
-  trans_rollback_stmt(thd);
-  trans_rollback(thd);
-  close_thread_tables(thd);			// Shouldn't be needed
-  thd->mdl_context.release_transactional_locks();
-  if (table)
-    table->table=0;
-  DBUG_RETURN(TRUE);
-}
-
-
-bool mysql_repair_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
-{
-  DBUG_ENTER("mysql_repair_table");
-  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
-				"repair", TL_WRITE, 1,
-                                test(check_opt->sql_flags & TT_USEFRM),
-                                HA_OPEN_FOR_REPAIR,
-				&prepare_for_repair,
-				&handler::ha_repair, 0));
-}
-
-
-bool mysql_optimize_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
-{
-  DBUG_ENTER("mysql_optimize_table");
-  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
-				"optimize", TL_WRITE, 1,0,0,0,
-				&handler::ha_optimize, 0));
-}
-
-
-/*
-  Assigned specified indexes for a table into key cache
-
-  SYNOPSIS
-    mysql_assign_to_keycache()
-    thd		Thread object
-    tables	Table list (one table only)
-
-  RETURN VALUES
-   FALSE ok
-   TRUE  error
-*/
-
-bool mysql_assign_to_keycache(THD* thd, TABLE_LIST* tables,
-			     LEX_STRING *key_cache_name)
-{
-  HA_CHECK_OPT check_opt;
-  KEY_CACHE *key_cache;
-  DBUG_ENTER("mysql_assign_to_keycache");
-
-  check_opt.init();
-  mysql_mutex_lock(&LOCK_global_system_variables);
-  if (!(key_cache= get_key_cache(key_cache_name)))
-  {
-    mysql_mutex_unlock(&LOCK_global_system_variables);
-    my_error(ER_UNKNOWN_KEY_CACHE, MYF(0), key_cache_name->str);
-    DBUG_RETURN(TRUE);
-  }
-  mysql_mutex_unlock(&LOCK_global_system_variables);
-  check_opt.key_cache= key_cache;
-  DBUG_RETURN(mysql_admin_table(thd, tables, &check_opt,
-				"assign_to_keycache", TL_READ_NO_INSERT, 0, 0,
-				0, 0, &handler::assign_to_keycache, 0));
-}
-
-
-/*
-  Preload specified indexes for a table into key cache
-
-  SYNOPSIS
-    mysql_preload_keys()
-    thd		Thread object
-    tables	Table list (one table only)
-
-  RETURN VALUES
-    FALSE ok
-    TRUE  error
-*/
-
-bool mysql_preload_keys(THD* thd, TABLE_LIST* tables)
-{
-  DBUG_ENTER("mysql_preload_keys");
-  /*
-    We cannot allow concurrent inserts. The storage engine reads
-    directly from the index file, bypassing the cache. It could read
-    outdated information if parallel inserts into cache blocks happen.
-  */
-  DBUG_RETURN(mysql_admin_table(thd, tables, 0,
-				"preload_keys", TL_READ_NO_INSERT, 0, 0, 0, 0,
-				&handler::preload_keys, 0));
-}
-
-
 /*
   Create a table identical to the specified table
 
@@ -5608,29 +4728,6 @@ err:
 }
 
 
-bool mysql_analyze_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
-{
-  thr_lock_type lock_type = TL_READ_NO_INSERT;
-
-  DBUG_ENTER("mysql_analyze_table");
-  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
-				"analyze", lock_type, 1, 0, 0, 0,
-				&handler::ha_analyze, 0));
-}
-
-
-bool mysql_check_table(THD* thd, TABLE_LIST* tables,HA_CHECK_OPT* check_opt)
-{
-  thr_lock_type lock_type = TL_READ_NO_INSERT;
-
-  DBUG_ENTER("mysql_check_table");
-  DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
-				"check", lock_type,
-				0, 0, HA_OPEN_FOR_REPAIR, 0,
-				&handler::ha_check, &view_checksum));
-}
-
-
 /* table_list should contain just one table */
 static int
 mysql_discard_or_import_tablespace(THD *thd,
@@ -5741,7 +4838,7 @@ is_index_maintenance_unique (TABLE *tabl
 
 /*
   SYNOPSIS
-    compare_tables()
+    mysql_compare_tables()
       table                     The original table.
       alter_info                Alter options, fields and keys for the new
                                 table.
@@ -5818,7 +4915,7 @@ mysql_compare_tables(TABLE *table,
     mysql_prepare_create_table.  Unfortunately,
     mysql_prepare_create_table performs its transformations
     "in-place", that is, modifies the argument.  Since we would
-    like to keep compare_tables() idempotent (not altering any
+    like to keep mysql_compare_tables() idempotent (not altering any
     of the arguments) we create a copy of alter_info here and
     pass it to mysql_prepare_create_table, then use the result
     to evaluate possibility of fast ALTER TABLE, and then
@@ -6619,7 +5716,7 @@ err:
     Important is the fact, that this function tries to do as little work as
     possible, by finding out whether a intermediate table is needed to copy
     data into and when finishing the altering to use it as the original table.
-    For this reason the function compare_tables() is called, which decides
+    For this reason the function mysql_compare_tables() is called, which decides
     based on all kind of data how similar are the new and the original
     tables.
 
@@ -7579,7 +6676,7 @@ bool mysql_alter_table(THD *thd,char *ne
     it should become the actual table. Later, we will recycle the old table.
     However, in case of ALTER TABLE RENAME there might be no intermediate
     table. This is when the old and new tables are compatible, according to
-    compare_table(). Then, we need one additional call to
+    mysql_compare_table(). Then, we need one additional call to
     mysql_rename_table() with flag NO_FRM_RENAME, which does nothing else but
     actual rename in the SE and the FRM is not touched. Note that, if the
     table is renamed and the SE is also changed, then an intermediate table
@@ -8234,3 +7331,4 @@ static bool check_engine(THD *thd, const
   }
   return FALSE;
 }
+

=== modified file 'sql/sql_table.h'
--- a/sql/sql_table.h	2010-07-30 18:25:50 +0000
+++ b/sql/sql_table.h	2010-08-16 14:22:16 +0000
@@ -179,19 +179,6 @@ bool mysql_restore_table(THD* thd, TABLE
 
 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,

=== modified file 'sql/sql_truncate.cc'
--- a/sql/sql_truncate.cc	2010-07-13 08:39:24 +0000
+++ b/sql/sql_truncate.cc	2010-08-16 12:53:30 +0000
@@ -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_trun
                                              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_trun
                                             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_trun
                          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, TABL
   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);
+}

=== modified file 'sql/sql_truncate.h'
--- a/sql/sql_truncate.h	2010-05-27 21:11:55 +0000
+++ b/sql/sql_truncate.h	2010-08-16 12:53:30 +0000
@@ -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

=== modified file 'sql/sql_yacc.yy'
--- a/sql/sql_yacc.yy	2010-08-05 13:10:22 +0000
+++ b/sql/sql_yacc.yy	2010-08-16 15:07:53 +0000
@@ -51,8 +51,10 @@
 #include "sp_pcontext.h"
 #include "sp_rcontext.h"
 #include "sp.h"
-#include "sql_alter_table.h"                   // Alter_table*_statement
-#include "sql_partition_admin.h"               // Alter_table_*_partition_statement
+#include "sql_alter.h"                         // Alter_table*_statement
+#include "sql_truncate.h"                      // Truncate_statement
+#include "sql_admin.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>
@@ -6491,38 +6493,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
@@ -6534,12 +6552,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
         | EXCHANGE_SYM PARTITION_SYM alt_part_name_item
@@ -7004,7 +7024,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:
@@ -7035,7 +7062,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:
@@ -7063,7 +7097,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:
@@ -7097,7 +7138,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:
@@ -10875,7 +10923,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:


Attachment: [text/bzr-bundle] bzr/mattias.jonsson@oracle.com-20100816182439-fbkje0zvl68wlldd.bundle
Thread
bzr commit into mysql-trunk-bugfixing branch (mattias.jonsson:3209) Mattias Jonsson16 Aug