Merge witty.:/Users/mattiasj/clones/mysql-5.1-bug31931.2

into  witty.:/Users/mattiasj/clones/topush-51

mysql-test/r/partition.result

@@ -530,11 +530,9 @@ t1	CREATE TABLE `t1` (
 alter table t1
 partition by key(a)
 (partition p0, partition p1 engine=heap);
-ERROR HY000: The mix of handlers in the partitions is not allowed in this version of MySQL
 alter table t1
 partition by key(a)
 (partition p0 engine=heap, partition p1);
-ERROR HY000: The mix of handlers in the partitions is not allowed in this version of MySQL
 alter table t1
 engine=heap
 partition by key (a)

mysql-test/r/partition_innodb.result

@@ -79,8 +79,7 @@ engine = innodb
 partition by list (a)
 (partition p0 values in (0));
 alter table t1 engine = x;
-Warnings:
-Warning	1286	Unknown table engine 'x'
+ERROR HY000: The mix of handlers in the partitions is not allowed in this version of MySQL
 show create table t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -151,9 +150,11 @@ DROP TABLE t1;
 create table t1 (int_column int, char_column char(5))
 PARTITION BY RANGE (int_column) subpartition by key (char_column) subpartitions 2
 (PARTITION p1 VALUES LESS THAN (5) ENGINE = InnoDB);
-alter table t1 PARTITION BY RANGE (int_column)
+alter table t1
+ENGINE = MyISAM
+PARTITION BY RANGE (int_column)
 subpartition by key (char_column) subpartitions 2
-(PARTITION p1 VALUES LESS THAN (5) ENGINE = myisam);
+(PARTITION p1 VALUES LESS THAN (5));
 show create table t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (

mysql-test/suite/ndb/r/ndb_partition_key.result

@@ -105,6 +105,12 @@ PARTITION BY KEY(a)
 drop table t1;
 CREATE TABLE t1 (a int not null primary key);
 ALTER TABLE t1
+ENGINE = NDB
+PARTITION BY KEY(a)
+(PARTITION p0 ENGINE = NDB, PARTITION p1 ENGINE = NDB);
+drop table t1;
+CREATE TABLE t1 (a int not null primary key) ENGINE = NDB;
+ALTER TABLE t1
 PARTITION BY KEY(a)
 (PARTITION p0 ENGINE = NDB, PARTITION p1 ENGINE = NDB);
 drop table t1;
@@ -160,7 +166,6 @@ t1	CREATE TABLE `t1` (
 alter table t1
 partition by key(a)
 (partition p0 engine=ndb, partition p1);
-ERROR HY000: The mix of handlers in the partitions is not allowed in this version of MySQL
 alter table t1
 engine=ndb
 partition by key(a)

mysql-test/suite/ndb/t/ndb_partition_key.test

@@ -79,6 +79,14 @@ drop table t1;
 
 CREATE TABLE t1 (a int not null primary key);
 ALTER TABLE t1
+ENGINE = NDB
+PARTITION BY KEY(a)
+(PARTITION p0 ENGINE = NDB, PARTITION p1 ENGINE = NDB);
+
+drop table t1;
+
+CREATE TABLE t1 (a int not null primary key) ENGINE = NDB;
+ALTER TABLE t1
 PARTITION BY KEY(a)
 (PARTITION p0 ENGINE = NDB, PARTITION p1 ENGINE = NDB);
 
@@ -116,7 +124,10 @@ show create table t1;
 alter table t1 remove partitioning;
 show create table t1;
 
---error ER_MIX_HANDLER_ERROR
+# after bug#31931 was fixed
+# this is OK, since the storage engine is specified
+# on table level before.
+#--error ER_MIX_HANDLER_ERROR
 alter table t1
 partition by key(a)
 (partition p0 engine=ndb, partition p1);

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

@@ -83,6 +83,7 @@ DROP TABLE t1;
 --echo # 3 Some but not all named partitions or subpartitions get a storage
 --echo #   engine assigned
 --echo #------------------------------------------------------------------------
+--error ER_MIX_HANDLER_ERROR
 eval CREATE TABLE t1 (
 $column_list
 )
@@ -90,10 +91,7 @@ PARTITION BY HASH(f_int1)
 ( PARTITION part1 STORAGE ENGINE = $engine,
   PARTITION part2
 );
-INSERT INTO t1(f_int1,f_int2,f_char1,f_char2,f_charbig)
-SELECT f_int1,f_int2,f_char1,f_char2,f_charbig FROM t0_template;
---source suite/parts/inc/partition_check.inc
-DROP TABLE t1;
+--error ER_MIX_HANDLER_ERROR
 eval CREATE TABLE t1 (
 $column_list
 )
@@ -101,10 +99,7 @@ PARTITION BY HASH(f_int1)
 ( PARTITION part1                         ,
   PARTITION part2 STORAGE ENGINE = $engine
 );
-INSERT INTO t1(f_int1,f_int2,f_char1,f_char2,f_charbig)
-SELECT f_int1,f_int2,f_char1,f_char2,f_charbig FROM t0_template;
---source suite/parts/inc/partition_check.inc
-DROP TABLE t1;
+--error ER_MIX_HANDLER_ERROR
 eval CREATE TABLE t1 (
 $column_list
 )
@@ -117,10 +112,8 @@ SUBPARTITION BY HASH(f_int1)
      (SUBPARTITION subpart21 STORAGE ENGINE = $engine,
       SUBPARTITION subpart22 STORAGE ENGINE = $engine)
 );
-INSERT INTO t1(f_int1,f_int2,f_char1,f_char2,f_charbig)
-SELECT f_int1,f_int2,f_char1,f_char2,f_charbig FROM t0_template;
---source suite/parts/inc/partition_check.inc
-DROP TABLE t1;
+--echo # this should fail with ER_MIX_HANDLER_ERROR
+--echo # after fixing Bug#33722
 eval CREATE TABLE t1 (
 $column_list
 )
@@ -142,6 +135,9 @@ DROP TABLE t1;
 --echo # 4 Storage engine assignment after partition name + after name of
 --echo #   subpartitions belonging to another partition
 --echo #------------------------------------------------------------------------
+--echo # this should work
+--echo # after fixing Bug#33722
+--error ER_MIX_HANDLER_ERROR
 eval CREATE TABLE t1 (
 $column_list
 )
@@ -154,10 +150,13 @@ SUBPARTITION BY HASH(f_int1)
      (SUBPARTITION subpart21 STORAGE ENGINE = $engine,
       SUBPARTITION subpart22 STORAGE ENGINE = $engine)
 );
-INSERT INTO t1(f_int1,f_int2,f_char1,f_char2,f_charbig)
-SELECT f_int1,f_int2,f_char1,f_char2,f_charbig FROM t0_template;
---source suite/parts/inc/partition_check.inc
-DROP TABLE t1;
+#INSERT INTO t1(f_int1,f_int2,f_char1,f_char2,f_charbig)
+#SELECT f_int1,f_int2,f_char1,f_char2,f_charbig FROM t0_template;
+#--source suite/parts/inc/partition_check.inc
+#DROP TABLE t1;
+--echo # this should work
+--echo # after fixing Bug#33722
+--error ER_MIX_HANDLER_ERROR
 eval CREATE TABLE t1 (
 $column_list
 )
@@ -170,10 +169,10 @@ SUBPARTITION BY HASH(f_int1)
      (SUBPARTITION subpart21,
       SUBPARTITION subpart22)
 );
-INSERT INTO t1(f_int1,f_int2,f_char1,f_char2,f_charbig)
-SELECT f_int1,f_int2,f_char1,f_char2,f_charbig FROM t0_template;
---source suite/parts/inc/partition_check.inc
-DROP TABLE t1;
+#INSERT INTO t1(f_int1,f_int2,f_char1,f_char2,f_charbig)
+#SELECT f_int1,f_int2,f_char1,f_char2,f_charbig FROM t0_template;
+#--source suite/parts/inc/partition_check.inc
+#DROP TABLE t1;
 #
 --echo #------------------------------------------------------------------------
 --echo # 5 Precedence of storage engine assignments (if there is any)
@@ -210,6 +209,9 @@ DROP TABLE t1;
 --echo # 6.2 Storage engine assignment after partition name + after
 --echo #     subpartition name
 #     in partition part + in sub partition part
+--echo # this should work
+--echo # after fixing Bug#33722
+--error ER_MIX_HANDLER_ERROR
 eval CREATE TABLE t1 (
 $column_list
 )
@@ -222,10 +224,10 @@ SUBPARTITION BY HASH(f_int1)
      (SUBPARTITION subpart21 STORAGE ENGINE = $engine,
       SUBPARTITION subpart22 STORAGE ENGINE = $engine)
 );
-INSERT INTO t1(f_int1,f_int2,f_char1,f_char2,f_charbig)
-SELECT f_int1,f_int2,f_char1,f_char2,f_charbig FROM t0_template;
---source suite/parts/inc/partition_check.inc
-DROP TABLE t1;
+#INSERT INTO t1(f_int1,f_int2,f_char1,f_char2,f_charbig)
+#SELECT f_int1,f_int2,f_char1,f_char2,f_charbig FROM t0_template;
+#--source suite/parts/inc/partition_check.inc
+#DROP TABLE t1;
 
 --echo #------------------------------------------------------------------------
 --echo # 6 Session default engine differs from engine used within create table

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

@@ -88,6 +88,12 @@ PARTITION BY KEY(a)
 drop table t1;
 CREATE TABLE t1 (a int not null primary key);
 ALTER TABLE t1
+ENGINE = NDB
+PARTITION BY KEY(a)
+(PARTITION p0 ENGINE = NDB, PARTITION p1 ENGINE = NDB);
+drop table t1;
+CREATE TABLE t1 (a int not null primary key) ENGINE = NDB;
+ALTER TABLE t1
 PARTITION BY KEY(a)
 (PARTITION p0 ENGINE = NDB, PARTITION p1 ENGINE = NDB);
 drop table t1;
@@ -143,7 +149,6 @@ t1	CREATE TABLE `t1` (
 alter table t1
 partition by key(a)
 (partition p0 engine=ndb, partition p1);
-ERROR HY000: The mix of handlers in the partitions is not allowed in this version of MySQL
 alter table t1
 engine=ndb
 partition by key(a)

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

@@ -75,6 +75,14 @@ drop table t1;
 
 CREATE TABLE t1 (a int not null primary key);
 ALTER TABLE t1
+ENGINE = NDB
+PARTITION BY KEY(a)
+(PARTITION p0 ENGINE = NDB, PARTITION p1 ENGINE = NDB);
+
+drop table t1;
+
+CREATE TABLE t1 (a int not null primary key) ENGINE = NDB;
+ALTER TABLE t1
 PARTITION BY KEY(a)
 (PARTITION p0 ENGINE = NDB, PARTITION p1 ENGINE = NDB);
 
@@ -112,7 +120,9 @@ show create table t1;
 alter table t1 remove partitioning;
 show create table t1;
 
---error ER_MIX_HANDLER_ERROR
+#--error ER_MIX_HANDLER_ERROR
+# after fixing bug#31931 this works
+# since it already have ndb on table level
 alter table t1
 partition by key(a)
 (partition p0 engine=ndb, partition p1);

mysql-test/t/partition.test

@@ -53,6 +53,7 @@ create table t1 (id int auto_increment, s1 int, primary key (id));
 insert into t1 values (null,1);
 insert into t1 values (null,6);
 
+-- sorted_result
 select * from t1;
 
 alter table t1 partition by range (id) (
@@ -604,12 +605,14 @@ partition by key (a)
 (partition p0, partition p1);
 show create table t1;
 
---error ER_MIX_HANDLER_ERROR
+# Since alter, it already have ENGINE=HEAP from before on table level
+# -> OK
 alter table t1
 partition by key(a)
 (partition p0, partition p1 engine=heap);
 
---error ER_MIX_HANDLER_ERROR
+# Since alter, it already have ENGINE=HEAP from before on table level
+# -> OK
 alter table t1
 partition by key(a)
 (partition p0 engine=heap, partition p1);

mysql-test/t/partition_innodb.test

@@ -86,6 +86,7 @@ engine = innodb
 partition by list (a)
 (partition p0 values in (0));
 
+-- error ER_MIX_HANDLER_ERROR
 alter table t1 engine = x;
 show create table t1;
 drop table t1;
@@ -164,8 +165,10 @@ DROP TABLE t1;
 create table t1 (int_column int, char_column char(5))
   PARTITION BY RANGE (int_column) subpartition by key (char_column) subpartitions 2
   (PARTITION p1 VALUES LESS THAN (5) ENGINE = InnoDB);
-alter table t1 PARTITION BY RANGE (int_column)
+alter table t1
+ENGINE = MyISAM
+PARTITION BY RANGE (int_column)
    subpartition by key (char_column) subpartitions 2
-  (PARTITION p1 VALUES LESS THAN (5) ENGINE = myisam);
+  (PARTITION p1 VALUES LESS THAN (5));
 show create table t1;
 drop table t1;

sql/partition_info.cc

@@ -419,41 +419,167 @@ char *partition_info::has_unique_names()
 
 
 /*
-  Check that all partitions use the same storage engine.
-  This is currently a limitation in this version.
+  Check that the partition/subpartition is setup to use the correct
+  storage engine
+  SYNOPSIS
+    check_engine_condition()
+    p_elem                   Partition element
+    table_engine_set         Have user specified engine on table level
+    inout::engine_type       Current engine used
+    inout::first             Is it first partition
+  RETURN VALUE
+    TRUE                     Failed check
+    FALSE                    Ok
+  DESCRIPTION
+    Specified engine for table and partitions p0 and pn
+    Must be correct both on CREATE and ALTER commands
+    table p0 pn res (0 - OK, 1 - FAIL)
+        -  -  - 0
+        -  -  x 1
+        -  x  - 1
+        -  x  x 0
+        x  -  - 0
+        x  -  x 0
+        x  x  - 0
+        x  x  x 0
+    i.e:
+    - All subpartitions must use the same engine
+      AND it must be the same as the partition.
+    - All partitions must use the same engine
+      AND it must be the same as the table.
+    - if one does NOT specify an engine on the table level
+      then one must either NOT specify any engine on any
+      partition/subpartition OR for ALL partitions/subpartitions
+    Note:
+    When ALTER a table, the engines are already set for all levels
+    (table, all partitions and subpartitions). So if one want to
+    change the storage engine, one must specify it on the table level
+
+*/
+
+static bool check_engine_condition(partition_element *p_elem,
+                                   bool table_engine_set,
+                                   handlerton **engine_type,
+                                   bool *first)
+{
+  DBUG_ENTER("check_engine_condition");
+
+  DBUG_PRINT("enter", ("p_eng %u t_eng %u t_eng_set %u first %u state %u",
+                       ha_legacy_type(p_elem->engine_type),
+                       ha_legacy_type(*engine_type),
+                       table_engine_set, *first, p_elem->part_state));
+  if (*first && !table_engine_set)
+  {
+    *engine_type= p_elem->engine_type;
+    DBUG_PRINT("info", ("setting table_engine = %u",
+                         ha_legacy_type(*engine_type)));
+  }
+  *first= FALSE;
+  if ((table_engine_set &&
+      (p_elem->engine_type != (*engine_type) &&
+       p_elem->engine_type)) ||
+      (!table_engine_set &&
+       p_elem->engine_type != (*engine_type)))
+  {
+    DBUG_RETURN(TRUE);
+  }
+  else
+  {
+    DBUG_RETURN(FALSE);
+  }
+}
 
+
+/*
+  Check engine mix that it is correct
+  Current limitation is that all partitions and subpartitions
+  must use the same storage engine.
   SYNOPSIS
     check_engine_mix()
-    engine_array           An array of engine identifiers
-    no_parts               Total number of partitions
-
+    inout::engine_type       Current engine used
+    table_engine_set         Have user specified engine on table level
   RETURN VALUE
     TRUE                     Error, mixed engines
     FALSE                    Ok, no mixed engines
   DESCRIPTION
     Current check verifies only that all handlers are the same.
     Later this check will be more sophisticated.
+    (specified partition handler ) specified table handler
+    (NDB, NDB) NDB           OK
+    (MYISAM, MYISAM) -       OK
+    (MYISAM, -)      -       NOT OK
+    (MYISAM, -)    MYISAM    OK
+    (- , MYISAM)   -         NOT OK
+    (- , -)        MYISAM    OK
+    (-,-)          -         OK
+    (NDB, MYISAM) *          NOT OK
 */
 
-bool partition_info::check_engine_mix(handlerton **engine_array, uint no_parts)
+bool partition_info::check_engine_mix(handlerton *engine_type,
+                                      bool table_engine_set)
 {
-  uint i= 0;
+  handlerton *old_engine_type= engine_type;
+  bool first= TRUE;
+  uint no_parts= partitions.elements;
   DBUG_ENTER("partition_info::check_engine_mix");
-
+  DBUG_PRINT("info", ("in: engine_type = %u, table_engine_set = %u",
+                       ha_legacy_type(engine_type),
+                       table_engine_set));
+  if (no_parts)
+  {
+    List_iterator<partition_element> part_it(partitions);
+    uint i= 0;
     do
     {
-    if (engine_array[i] != engine_array[0])
+      partition_element *part_elem= part_it++;
+      DBUG_PRINT("info", ("part = %d engine = %d table_engine_set %u",
+                 i, ha_legacy_type(part_elem->engine_type),
+                 table_engine_set));
+      if (is_sub_partitioned() &&
+          part_elem->subpartitions.elements)
       {
-      my_error(ER_MIX_HANDLER_ERROR, MYF(0));
-      DBUG_RETURN(TRUE);
+        uint no_subparts= part_elem->subpartitions.elements;
+        uint j= 0;
+        List_iterator<partition_element> sub_it(part_elem->subpartitions);
+        do
+        {
+          partition_element *sub_elem= sub_it++;
+          DBUG_PRINT("info", ("sub = %d engine = %u table_engie_set %u",
+                     j, ha_legacy_type(sub_elem->engine_type),
+                     table_engine_set));
+          if (check_engine_condition(sub_elem, table_engine_set,
+                                     &engine_type, &first))
+            goto error;
+        } while (++j < no_subparts);
+        /* ensure that the partition also has correct engine */
+        if (check_engine_condition(part_elem, table_engine_set,
+                                   &engine_type, &first))
+          goto error;
       }
+      else if (check_engine_condition(part_elem, table_engine_set,
+                                      &engine_type, &first))
+        goto error;
     } while (++i < no_parts);
-  if (engine_array[0]->flags & HTON_NO_PARTITION)
+  }
+  DBUG_PRINT("info", ("engine_type = %u",
+                       ha_legacy_type(engine_type)));
+  if (!engine_type)
+    engine_type= old_engine_type;
+  if (engine_type->flags & HTON_NO_PARTITION)
   {
     my_error(ER_PARTITION_MERGE_ERROR, MYF(0));
     DBUG_RETURN(TRUE);
   }
+  DBUG_PRINT("info", ("out: engine_type = %u",
+                       ha_legacy_type(engine_type)));
+  DBUG_ASSERT(engine_type != partition_hton);
   DBUG_RETURN(FALSE);
+error:
+  /*
+    Mixed engines not yet supported but when supported it will need
+    the partition handler
+  */
+  DBUG_RETURN(TRUE);
 }
 
 
@@ -726,12 +852,12 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type,
                                           handler *file, HA_CREATE_INFO *info,
                                           bool check_partition_function)
 {
-  handlerton **engine_array= NULL;
-  uint part_count= 0;
+  handlerton *table_engine= default_engine_type;
   uint i, tot_partitions;
-  bool result= TRUE;
+  bool result= TRUE, table_engine_set;
   char *same_name;
   DBUG_ENTER("partition_info::check_partition_info");
+  DBUG_ASSERT(default_engine_type != partition_hton);
 
   if (check_partition_function)
   {
@@ -777,23 +903,49 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type,
     my_error(ER_TOO_MANY_PARTITIONS_ERROR, MYF(0));
     goto end;
   }
+  /*
+    if NOT specified ENGINE = <engine>:
+      If Create, always use create_info->db_type
+      else, use previous tables db_type 
+      either ALL or NONE partition should be set to
+      default_engine_type when not table_engine_set
+      Note: after a table is created its storage engines for
+      the table and all partitions/subpartitions are set.
+      So when ALTER it is already set on table level
+  */
+  if (thd->lex->create_info.used_fields & HA_CREATE_USED_ENGINE)
+  {
+    table_engine_set= TRUE;
+    table_engine= thd->lex->create_info.db_type;
+  }
+  else
+  {
+    table_engine_set= FALSE;
+    if (thd->lex->sql_command != SQLCOM_CREATE_TABLE)
+    {
+      table_engine_set= TRUE;
+      DBUG_ASSERT(table_engine && table_engine != partition_hton);
+    }
+  }
+
   if ((same_name= has_unique_names()))
   {
     my_error(ER_SAME_NAME_PARTITION, MYF(0), same_name);
     goto end;
   }
-  engine_array= (handlerton**)my_malloc(tot_partitions * sizeof(handlerton *), 
-                                        MYF(MY_WME));
-  if (unlikely(!engine_array))
-    goto end;
   i= 0;
   {
     List_iterator<partition_element> part_it(partitions);
+    uint no_parts_not_set= 0;
+    uint prev_no_subparts_not_set= no_subparts + 1;
     do
     {
       partition_element *part_elem= part_it++;
       if (part_elem->engine_type == NULL)
+      {
+        no_parts_not_set++;
         part_elem->engine_type= default_engine_type;
+      }
 #ifdef HAVE_READLINK
       if (!my_use_symdir || (thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE))
 #endif
@@ -814,13 +966,13 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type,
           my_error(ER_WRONG_PARTITION_NAME, MYF(0));
           goto end;
         }
-        DBUG_PRINT("info", ("engine = %d",
-                   ha_legacy_type(part_elem->engine_type)));
-        engine_array[part_count++]= part_elem->engine_type;
+        DBUG_PRINT("info", ("part = %d engine = %d",
+                   i, ha_legacy_type(part_elem->engine_type)));
       }
       else
       {
         uint j= 0;
+        uint no_subparts_not_set= 0;
         List_iterator<partition_element> sub_it(part_elem->subpartitions);
         do
         {
@@ -832,19 +984,49 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type,
             goto end;
           }
           if (sub_elem->engine_type == NULL)
+          {
             sub_elem->engine_type= default_engine_type;
-          DBUG_PRINT("info", ("engine = %u",
-                     ha_legacy_type(sub_elem->engine_type)));
-          engine_array[part_count++]= sub_elem->engine_type;
+            no_subparts_not_set++;
+          }
+          DBUG_PRINT("info", ("part = %d sub = %d engine = %u",
+                     i, j, ha_legacy_type(sub_elem->engine_type)));
         } while (++j < no_subparts);
+        if (prev_no_subparts_not_set == (no_subparts + 1))
+          prev_no_subparts_not_set= no_subparts_not_set;
+        if (!table_engine_set &&
+            prev_no_subparts_not_set == no_subparts_not_set &&
+            no_subparts_not_set != 0 &&
+            no_subparts_not_set != no_subparts)
+        {
+          DBUG_PRINT("info", ("no_subparts_not_set = %u no_subparts = %u",
+                     no_subparts_not_set, no_subparts));
+          my_error(ER_MIX_HANDLER_ERROR, MYF(0));
+          goto end;
+        }
       }
     } while (++i < no_parts);
+    if (!table_engine_set &&
+        no_parts_not_set != 0 &&
+        no_parts_not_set != no_parts)
+    {
+      DBUG_PRINT("info", ("no_parts_not_set = %u no_parts = %u",
+                 no_parts_not_set, no_subparts));
+      my_error(ER_MIX_HANDLER_ERROR, MYF(0));
+      goto end;
+    }
   }
-  if (unlikely(partition_info::check_engine_mix(engine_array, part_count)))
+  if (unlikely(check_engine_mix(table_engine, table_engine_set)))
+  {
+    my_error(ER_MIX_HANDLER_ERROR, MYF(0));
     goto end;
+  }
 
+  if (table_engine == partition_hton)
+    DBUG_PRINT("info", ("Table engine set to partition_hton"));
+  DBUG_ASSERT(default_engine_type == table_engine);
   if (eng_type)
-    *eng_type= (handlerton*)engine_array[0];
+    *eng_type= table_engine;
+
 
   /*
     We need to check all constant expressions that they are of the correct
@@ -860,7 +1042,6 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type,
   }
   result= FALSE;
 end:
-  my_free((char*)engine_array,MYF(MY_ALLOW_ZERO_PTR));
   DBUG_RETURN(result);
 }
 

sql/partition_info.h

@@ -269,7 +269,7 @@ public:
   bool set_up_defaults_for_partitioning(handler *file, HA_CREATE_INFO *info,
                                         uint start_no);
   char *has_unique_names();
-  static bool check_engine_mix(handlerton **engine_array, uint no_parts);
+  bool check_engine_mix(handlerton *engine_type, bool default_engine);
   bool check_range_constants();
   bool check_list_constants();
   bool check_partition_info(THD *thd, handlerton **eng_type,

sql/sql_partition.cc

@@ -3863,6 +3863,8 @@ bool mysql_unpack_partition(THD *thd,
   if (!part_info->default_engine_type)
     part_info->default_engine_type= default_db_type;
   DBUG_ASSERT(part_info->default_engine_type == default_db_type);
+  DBUG_ASSERT(part_info->default_engine_type->db_type != DB_TYPE_UNKNOWN);
+  DBUG_ASSERT(part_info->default_engine_type != partition_hton);
 
   {
   /*
@@ -3996,56 +3998,6 @@ static int fast_end_partition(THD *thd, ulonglong copied,
 }
 
 
-/*
-  Check engine mix that it is correct
-  SYNOPSIS
-    check_engine_condition()
-    p_elem                   Partition element
-    default_engine           Have user specified engine on table level
-    inout::engine_type       Current engine used
-    inout::first             Is it first partition
-  RETURN VALUE
-    TRUE                     Failed check
-    FALSE                    Ok
-  DESCRIPTION
-    (specified partition handler ) specified table handler
-    (NDB, NDB) NDB           OK
-    (MYISAM, MYISAM) -       OK
-    (MYISAM, -)      -       NOT OK
-    (MYISAM, -)    MYISAM    OK
-    (- , MYISAM)   -         NOT OK
-    (- , -)        MYISAM    OK
-    (-,-)          -         OK
-    (NDB, MYISAM) *          NOT OK
-*/
-
-static bool check_engine_condition(partition_element *p_elem,
-                                   bool default_engine,
-                                   handlerton **engine_type,
-                                   bool *first)
-{
-  DBUG_ENTER("check_engine_condition");
-
-  DBUG_PRINT("enter", ("def_eng = %u, first = %u", default_engine, *first));
-  if (*first && default_engine)
-  {
-    *engine_type= p_elem->engine_type;
-  }
-  *first= FALSE;
-  if ((!default_engine &&
-      (p_elem->engine_type != (*engine_type) &&
-       p_elem->engine_type)) ||
-      (default_engine &&
-       p_elem->engine_type != (*engine_type)))
-  {
-    DBUG_RETURN(TRUE);
-  }
-  else
-  {
-    DBUG_RETURN(FALSE);
-  }
-}
-
 /*
   We need to check if engine used by all partitions can handle
   partitioning natively.
@@ -4070,52 +4022,30 @@ static bool check_engine_condition(partition_element *p_elem,
 static bool check_native_partitioned(HA_CREATE_INFO *create_info,bool *ret_val,
                                      partition_info *part_info, THD *thd)
 {
-  List_iterator<partition_element> part_it(part_info->partitions);
-  bool first= TRUE;
-  bool default_engine;
-  handlerton *engine_type= create_info->db_type;
+  bool table_engine_set;
+  handlerton *engine_type= part_info->default_engine_type;
   handlerton *old_engine_type= engine_type;
-  uint i= 0;
-  uint no_parts= part_info->partitions.elements;
   DBUG_ENTER("check_native_partitioned");
 
-  default_engine= (create_info->used_fields & HA_CREATE_USED_ENGINE) ?
-                   FALSE : TRUE;
-  DBUG_PRINT("info", ("engine_type = %u, default = %u",
-                       ha_legacy_type(engine_type),
-                       default_engine));
-  if (no_parts)
+  if (create_info->used_fields & HA_CREATE_USED_ENGINE)
   {
-    do
-    {
-      partition_element *part_elem= part_it++;
-      if (part_info->is_sub_partitioned() &&
-          part_elem->subpartitions.elements)
+    table_engine_set= TRUE;
+    engine_type= create_info->db_type;
+  }
+  else
   {
-        uint no_subparts= part_elem->subpartitions.elements;
-        uint j= 0;
-        List_iterator<partition_element> sub_it(part_elem->subpartitions);
-        do
+    table_engine_set= FALSE;
+    if (thd->lex->sql_command != SQLCOM_CREATE_TABLE)
     {
-          partition_element *sub_elem= sub_it++;
-          if (check_engine_condition(sub_elem, default_engine,
-                                     &engine_type, &first))
-            goto error;
-        } while (++j < no_subparts);
-        /*
-          In case of subpartitioning and defaults we allow that only
-          subparts have specified engines, as long as the parts haven't
-          specified the wrong engine it's ok.
-        */
-        if (check_engine_condition(part_elem, FALSE,
-                                   &engine_type, &first))
-          goto error;
+      table_engine_set= TRUE;
+      DBUG_ASSERT(engine_type && engine_type != partition_hton);
     }
-      else if (check_engine_condition(part_elem, default_engine,
-                                      &engine_type, &first))
-        goto error;
-    } while (++i < no_parts);
   }
+  DBUG_PRINT("info", ("engine_type = %u, table_engine_set = %u",
+                       ha_legacy_type(engine_type),
+                       table_engine_set));
+  if (part_info->check_engine_mix(engine_type, table_engine_set))
+    goto error;
 
   /*
     All engines are of the same type. Check if this engine supports
@@ -4212,7 +4142,7 @@ uint prep_alter_part_table(THD *thd, TABLE *table, Alter_info *alter_info,
       my_error(ER_PARTITION_MGMT_ON_NONPARTITIONED, MYF(0));
       DBUG_RETURN(TRUE);
     }
-    if (alter_info->flags == ALTER_TABLE_REORG)
+    if (alter_info->flags & ALTER_TABLE_REORG)
     {
       uint new_part_no, curr_part_no;
       if (tab_part_info->part_type != HASH_PARTITION ||
@@ -4543,7 +4473,7 @@ that are reorganised.
         tab_part_info->is_auto_partitioned= FALSE;
       }
     }
-    else if (alter_info->flags == ALTER_DROP_PARTITION)
+    else if (alter_info->flags & ALTER_DROP_PARTITION)
     {
       /*
         Drop a partition from a range partition and list partitioning is
@@ -4747,7 +4677,7 @@ state of p1.
         tab_part_info->is_auto_partitioned= FALSE;
       }
     }
-    else if (alter_info->flags == ALTER_REORGANIZE_PARTITION)
+    else if (alter_info->flags & ALTER_REORGANIZE_PARTITION)
     {
       /*
         Reorganise partitions takes a number of partitions that are next
@@ -4928,8 +4858,8 @@ the generated partition syntax in a correct manner.
     }
     *partition_changed= TRUE;
     thd->work_part_info= tab_part_info;
-    if (alter_info->flags == ALTER_ADD_PARTITION ||
-        alter_info->flags == ALTER_REORGANIZE_PARTITION)
+    if (alter_info->flags & ALTER_ADD_PARTITION ||
+        alter_info->flags & ALTER_REORGANIZE_PARTITION)
     {
       if (tab_part_info->use_default_subpartitions &&
           !alt_part_info->use_default_subpartitions)
@@ -5056,13 +4986,21 @@ the generated partition syntax in a correct manner.
         DBUG_PRINT("info", ("partition changed"));
         *partition_changed= TRUE;
       }
-      if (create_info->db_type == partition_hton)
+      /*
+        Set up partition default_engine_type either from the create_info
+        or from the previus table
+      */
+      if (create_info->used_fields & HA_CREATE_USED_ENGINE)
+        part_info->default_engine_type= create_info->db_type;
+      else
       {
-        if (!part_info->default_engine_type)
+        if (table->part_info)
           part_info->default_engine_type= table->part_info->default_engine_type;
-      }
         else
           part_info->default_engine_type= create_info->db_type;
+      }
+      DBUG_ASSERT(part_info->default_engine_type &&
+                  part_info->default_engine_type != partition_hton);
       if (check_native_partitioned(create_info, &is_native_partitioned,
                                    part_info, thd))
       {
@@ -6160,7 +6098,7 @@ uint fast_alter_partition_table(THD *thd, TABLE *table,
       goto err;
     }
   }
-  else if (alter_info->flags == ALTER_DROP_PARTITION)
+  else if (alter_info->flags & ALTER_DROP_PARTITION)
   {
     /*
       Now after all checks and setting state on dropped partitions we can