Merge lp:~brianaker/drizzle/regression-622465 into lp:drizzle/7.0

[Brian Aker]

We need to modify the names of the FK toward the name of the new table.

[Lee Bieber (kalebral-deactivatedaccount)]

Getting test failures - regression.592690 microtime_type.decimal microtime_type.max

--- .././tests/suite/microtime_type/r/decimal.result 2011-01-14 05:58:28.446261000 +0300
+++ .././tests/suite/microtime_type/r/decimal.reject 2011-01-14 21:34:44.103791539 +0300
@@ -14,6 +14,6 @@
 SELECT _value FROM t2;
 _value
 2003-01-01 00:00:00.000000
-2003-01-01 00:00:00.125000
-2003-01-01 00:00:00.898437
[phone]:00:00.123456
[phone]:00:00.900000
 DROP TABLE t1,t2;

microtime_type.max [ fail ]
drizzletest: At line 6: query 'INSERT into t2 VALUES ("20660101000000.00000")' failed: 1685: Received an invalid value '20660101000000.00000' for a UNIX timestamp.

The result from queries just before the failure was:
CREATE TABLE t2 (
_value TIMESTAMP(6)
);
INSERT into t2 VALUES ("20660101000000.00000");

mysql_compatibility.zerofill [ pass ] 2
regression.592690 [ fail ]
--- .././tests/suite/regression/r/592690.result 2011-01-14 05:58:28.446261000 +0300
+++ .././tests/suite/regression/r/592690.reject 2011-01-14 21:34:30.083175783 +0300
@@ -1,3 +1,5 @@
 select from_unixtime(1272945599.90000), from_unixtime(1272945599), from_unixtime("1272945599.90000");
 from_unixtime(1272945599.90000) from_unixtime(1272945599) from_unixtime("1272945599.90000")
-2010-05-04 03:59:59.900000 2010-05-04 03:59:59 2010-05-04 03:59:59.900000
[phone]:00:00 2010-05-04 03:59:59 2010-05-04 03:59:59
+Warnings:
+Warning 1292 Truncated incorrect INTEGER value: '1272945599.90000'

microtime_type.decimal [ fail ]
--- .././tests/suite/microtime_type/r/decimal.result 2011-01-14 05:58:28.446261000 +0300
+++ .././tests/suite/microtime_type/r/decimal.reject 2011-01-14 21:34:44.103791539 +0300
@@ -14,6 +14,6 @@
 SELECT _value FROM t2;
 _value
 2003-01-01 00:00:00.000000
-2003-01-01 00:00:00.125000
-2003-01-01 00:00:00.898437
[phone]:00:00.123456
[phone]:00:00.900000
 DROP TABLE t1,t2;

review: Needs Fixing

=== modified file 'drizzled/cursor.h'
--- drizzled/cursor.h	2011-01-07 04:13:17 +0000
+++ drizzled/cursor.h	2011-01-14 01:53:54 +0000
@@ -681,11 +681,11 @@
                                 bool is_if_not_exists);
 
 bool create_like_table(Session* session,
-                             const TableIdentifier &destination_identifier,
-                             TableList* table, TableList* src_table,
-                             message::Table &create_table_proto,
-                             bool is_if_not_exists,
-                             bool is_engine_set);
+                       TableIdentifier::const_reference destination_identifier,
+                       TableIdentifier::const_reference source_identifier,
+                       message::Table &create_table_proto,
+                       bool is_if_not_exists,
+                       bool is_engine_set);
 
 bool rename_table(Session &session,
                         plugin::StorageEngine *base,

=== modified file 'drizzled/error.cc'
--- drizzled/error.cc	2011-01-13 09:25:42 +0000
+++ drizzled/error.cc	2011-01-14 01:53:54 +0000
@@ -482,6 +482,7 @@
   ADD_ERROR_MESSAGE(ER_TABLE_DROP, N_("Cannot drop table '%s'"));
   ADD_ERROR_MESSAGE(ER_TABLE_DROP_ERROR_OCCURRED, N_("Error occurred while dropping table '%s'"));
   ADD_ERROR_MESSAGE(ER_TABLE_PERMISSION_DENIED, N_("Permission denied to create '%s'"));
+  ADD_ERROR_MESSAGE(ER_TABLE_UNKNOWN, N_("Unknown table '%s'"));
 
   ADD_ERROR_MESSAGE(ER_SCHEMA_DOES_NOT_EXIST, N_("Schema does not exist: %s"));
   ADD_ERROR_MESSAGE(ER_ALTER_SCHEMA, N_("Error altering schema: %s"));

=== modified file 'drizzled/error_t.h'
--- drizzled/error_t.h	2011-01-13 09:25:42 +0000
+++ drizzled/error_t.h	2011-01-14 01:53:54 +0000
@@ -844,17 +844,28 @@
   ER_INVALID_BOOLEAN_VALUE,
   ER_ASSERT,
   ER_ASSERT_NULL,
+<<<<<<< TREE
   ER_TABLE_DROP,
+=======
+>>>>>>> MERGE-SOURCE
   ER_CATALOG_CANNOT_CREATE,
   ER_CATALOG_CANNOT_CREATE_PERMISSION,
   ER_CATALOG_CANNOT_DROP,
+<<<<<<< TREE
   ER_CATALOG_CANNOT_DROP_PERMISSION,
   ER_CATALOG_DOES_NOT_EXIST,
   ER_CATALOG_NO_DROP_LOCAL,
+=======
+  ER_CATALOG_DOES_NOT_EXIST,
+  ER_CATALOG_NO_DROP_LOCAL,
+>>>>>>> MERGE-SOURCE
   ER_CATALOG_NO_LOCK,
   ER_CORRUPT_CATALOG_DEFINITION,
+  ER_TABLE_DROP,
   ER_TABLE_DROP_ERROR_OCCURRED,
   ER_TABLE_PERMISSION_DENIED,
+  ER_TABLE_UNKNOWN,
+
   ER_INVALID_CAST_TO_BOOLEAN,
 
   // Leave ER_INVALID_BOOLEAN_VALUE as LAST, and force people to use tags

=== modified file 'drizzled/sql_table.cc'
--- drizzled/sql_table.cc	2011-01-13 07:24:48 +0000
+++ drizzled/sql_table.cc	2011-01-14 01:53:54 +0000
@@ -1999,48 +1999,63 @@
     during the call to plugin::StorageEngine::createTable().
     See bug #28614 for more info.
   */
-static bool create_table_wrapper(Session &session, const message::Table& create_table_proto,
-                                 const TableIdentifier &destination_identifier,
-                                 const TableIdentifier &src_table,
+static bool create_table_wrapper(Session &session,
+                                 const message::Table& create_table_proto,
+                                 TableIdentifier::const_reference destination_identifier,
+                                 TableIdentifier::const_reference source_identifier,
                                  bool is_engine_set)
 {
-  int protoerr;
-  message::Table new_proto;
-  message::table::shared_ptr src_proto;
-
-  protoerr= plugin::StorageEngine::getTableDefinition(session,
-                                                      src_table,
-                                                      src_proto);
-  new_proto.CopyFrom(*src_proto);
+  // We require an additional table message because during parsing we used
+  // a "new" message and it will not have all of the information that the
+  // source table message would have.
+  message::Table new_table_message;
+  drizzled::error_t error;
+
+  message::table::shared_ptr source_table_message= plugin::StorageEngine::getTableMessage(session, source_identifier, error);
+
+  if (not source_table_message)
+  {
+    my_error(ER_TABLE_UNKNOWN, source_identifier);
+    return false;
+  }
+
+  new_table_message.CopyFrom(*source_table_message);
 
   if (destination_identifier.isTmp())
   {
-    new_proto.set_type(message::Table::TEMPORARY);
+    new_table_message.set_type(message::Table::TEMPORARY);
   }
   else
   {
-    new_proto.set_type(message::Table::STANDARD);
+    new_table_message.set_type(message::Table::STANDARD);
   }
 
   if (is_engine_set)
   {
-    new_proto.mutable_engine()->set_name(create_table_proto.engine().name());
+    new_table_message.mutable_engine()->set_name(create_table_proto.engine().name());
   }
 
   { // We now do a selective copy of elements on to the new table.
-    new_proto.set_name(create_table_proto.name());
-    new_proto.set_schema(create_table_proto.schema());
-    new_proto.set_catalog(create_table_proto.catalog());
+    new_table_message.set_name(create_table_proto.name());
+    new_table_message.set_schema(create_table_proto.schema());
+    new_table_message.set_catalog(create_table_proto.catalog());
   }
 
-  if (protoerr && protoerr != EEXIST)
+  /* Fix names of foreign keys being added */
+  for (int32_t j= 0; j < new_table_message.fk_constraint_size(); j++)
   {
-    if (errno == ENOENT)
-      my_error(ER_BAD_DB_ERROR,MYF(0), destination_identifier.getSchemaName().c_str());
-    else
-      my_error(ER_CANT_CREATE_FILE, MYF(0), destination_identifier.getPath().c_str(), errno);
-
-    return false;
+    if (new_table_message.fk_constraint(j).has_name())
+    {
+      std::string name(new_table_message.name());
+      char number[20];
+
+      name.append("_ibfk_");
+      snprintf(number, sizeof(number), "%d", j+1);
+      name.append(number);
+
+      message::Table::ForeignKeyConstraint *pfkey= new_table_message.mutable_fk_constraint(j);
+      pfkey->set_name(name);
+    }
   }
 
   /*
@@ -2049,12 +2064,12 @@
   */
   bool success= plugin::StorageEngine::createTable(session,
                                                    destination_identifier,
-                                                   new_proto);
+                                                   new_table_message);
 
   if (success && not destination_identifier.isTmp())
   {
     TransactionServices &transaction_services= TransactionServices::singleton();
-    transaction_services.createTable(&session, new_proto);
+    transaction_services.createTable(&session, new_table_message);
   }
 
   return success;
@@ -2076,31 +2091,14 @@
 */
 
 bool create_like_table(Session* session,
-                       const TableIdentifier &destination_identifier,
-                       TableList* table, TableList* src_table,
+                       TableIdentifier::const_reference destination_identifier,
+                       TableIdentifier::const_reference source_identifier,
                        message::Table &create_table_proto,
                        bool is_if_not_exists,
                        bool is_engine_set)
 {
   bool res= true;
-  uint32_t not_used;
-
-  /*
-    By opening source table we guarantee that it exists and no concurrent
-    DDL operation will mess with it. Later we also take an exclusive
-    name-lock on target table name, which makes copying of .frm cursor,
-    call to plugin::StorageEngine::createTable() and binlogging atomic
-    against concurrent DML and DDL operations on target table.
-    Thus by holding both these "locks" we ensure that our statement is
-    properly isolated from all concurrent operations which matter.
-  */
-  if (session->open_tables_from_list(&src_table, &not_used))
-    return true;
-
-  TableIdentifier src_identifier(src_table->table->getShare()->getSchemaName(),
-                                 src_table->table->getShare()->getTableName(), src_table->table->getShare()->getType());
-
-
+  bool table_exists= false;
 
   /*
     Check that destination tables does not exist. Note that its name
@@ -2108,7 +2106,6 @@
 
     For temporary tables we don't aim to grab locks.
   */
-  bool table_exists= false;
   if (destination_identifier.isTmp())
   {
     if (session->find_temporary_table(destination_identifier))
@@ -2117,8 +2114,11 @@
     }
     else
     {
-      bool was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,
-                                             src_identifier, is_engine_set);
+      bool was_created= create_table_wrapper(*session,
+                                             create_table_proto,
+                                             destination_identifier,
+                                             source_identifier,
+                                             is_engine_set);
       if (not was_created) // This is pretty paranoid, but we assume something might not clean up after itself
       {
         (void) session->rm_temporary_table(destination_identifier, true);
@@ -2163,7 +2163,7 @@
       {
         boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* We lock for CREATE TABLE LIKE to copy table definition */
         was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,
-                                               src_identifier, is_engine_set);
+                                          source_identifier, is_engine_set);
       }
 
       // So we blew the creation of the table, and we scramble to clean up
@@ -2191,18 +2191,18 @@
     {
       char warn_buff[DRIZZLE_ERRMSG_SIZE];
       snprintf(warn_buff, sizeof(warn_buff),
-               ER(ER_TABLE_EXISTS_ERROR), table->getTableName());
+               ER(ER_TABLE_EXISTS_ERROR), destination_identifier.getTableName().c_str());
       push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
-                   ER_TABLE_EXISTS_ERROR,warn_buff);
-      res= false;
-    }
-    else
-    {
-      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table->getTableName());
-    }
+                   ER_TABLE_EXISTS_ERROR, warn_buff);
+      return false;
+    }
+
+    my_error(ER_TABLE_EXISTS_ERROR, destination_identifier);
+
+    return true;
   }
 
-  return(res);
+  return res;
 }
 
 

=== modified file 'drizzled/sql_table.h'
--- drizzled/sql_table.h	2010-12-24 07:15:43 +0000
+++ drizzled/sql_table.h	2011-01-14 01:53:54 +0000
@@ -50,11 +50,11 @@
                               enum ha_extra_function function);
 
 bool check_table(Session* session, TableList* table_list,
-                       HA_CHECK_OPT* check_opt);
+                 HA_CHECK_OPT* check_opt);
 bool analyze_table(Session* session, TableList* table_list,
-                         HA_CHECK_OPT* check_opt);
+                   HA_CHECK_OPT* check_opt);
 bool optimize_table(Session* session, TableList* table_list,
-                          HA_CHECK_OPT* check_opt);
+                    HA_CHECK_OPT* check_opt);
 
 void write_bin_log(Session *session, const std::string &query);
 

=== modified file 'drizzled/statement/create_table.cc'
--- drizzled/statement/create_table.cc	2011-01-09 22:15:22 +0000
+++ drizzled/statement/create_table.cc	2011-01-14 01:53:54 +0000
@@ -129,7 +129,8 @@
   Select_Lex *select_lex= &session->lex->select_lex;
   TableList *select_tables= session->lex->query_tables;
 
-  do {
+  do 
+  {
     if (select_lex->item_list.elements)		// With select
     {
       Select_Lex_Unit *unit= &session->lex->unit;
@@ -201,8 +202,8 @@
       {
         res= create_like_table(session, 
                                new_table_identifier,
-                               create_table_list, 
-                               select_tables,
+                               TableIdentifier(select_tables->getSchemaName(),
+                                               select_tables->getTableName()),
                                createTableMessage(),
                                session->getLex()->exists(),
                                is_engine_set);

=== modified file 'tests/r/create.result'
--- tests/r/create.result	2011-01-11 05:13:54 +0000
+++ tests/r/create.result	2011-01-14 01:53:54 +0000
@@ -362,15 +362,15 @@
 select * from t2;
 id	name
 create table t3 like t1;
-ERROR 42S01: Table 't3' already exists
+ERROR 42S01: Table 'test.t3' already exists
 create table t3 like mysqltest.t3;
-ERROR 42S01: Table 't3' already exists
+ERROR 42S01: Table 'test.t3' already exists
 create table non_existing_database.t1 like t1;
 ERROR 42000: Unknown schema 'non_existing_database'
-create table t3 like non_existing_table;
-ERROR 42S02: Table 'test.non_existing_table' doesn't exist
+create table t4 like non_existing_table;
+ERROR HY000: Unknown table 'test.non_existing_table'
 create temporary table t3 like t1;
-ERROR 42S01: Table 't3' already exists
+ERROR 42S01: Table 'test.#t3' already exists
 drop table t1, t2, t3;
 drop database mysqltest;
 SET SESSION storage_engine="MEMORY";

=== added file 'tests/suite/regression/r/622465.result'
--- tests/suite/regression/r/622465.result	1970-01-01 00:00:00 +0000
+++ tests/suite/regression/r/622465.result	2011-01-14 01:53:54 +0000
@@ -0,0 +1,12 @@
+CREATE TABLE t1 (id INT PRIMARY KEY);
+CREATE TABLE `t2` LIKE `t1`;
+ALTER TABLE `t2` ADD FOREIGN KEY (`id`) REFERENCES `t1`(`id`);
+CREATE TABLE `t3` LIKE `t2`;
+SHOW CREATE TABLE t3;
+Table	Create Table
+t3	CREATE TABLE `t3` (
+  `id` INT NOT NULL,
+  PRIMARY KEY (`id`),
+  CONSTRAINT `t3_ibfk_1` FOREIGN KEY (`id`) REFERENCES `t1` (`id`)
+) ENGINE=InnoDB COLLATE = utf8_general_ci
+DROP TABLE t2, t3, t1;

=== added file 'tests/suite/regression/t/622465.test'
--- tests/suite/regression/t/622465.test	1970-01-01 00:00:00 +0000
+++ tests/suite/regression/t/622465.test	2011-01-14 01:53:54 +0000
@@ -0,0 +1,10 @@
+# Make sure that foreign keys transfer with CREATE TABLE LIKE
+CREATE TABLE t1 (id INT PRIMARY KEY);
+
+CREATE TABLE `t2` LIKE `t1`;
+ALTER TABLE `t2` ADD FOREIGN KEY (`id`) REFERENCES `t1`(`id`);
+
+CREATE TABLE `t3` LIKE `t2`;
+SHOW CREATE TABLE t3;
+
+DROP TABLE t2, t3, t1;

=== modified file 'tests/t/create.test'
--- tests/t/create.test	2011-01-11 05:13:54 +0000
+++ tests/t/create.test	2011-01-14 01:53:54 +0000
@@ -314,20 +314,28 @@
 create database mysqltest;
 create table mysqltest.t3 like t1;
 create temporary table t3 like mysqltest.t3;
+
 --replace_regex /ENGINE=[a-zA-Z]+/ENGINE=DEFAULT/
 show create table t3;
+
 create table t2 like t3;
+
 --replace_regex /ENGINE=[a-zA-Z]+/ENGINE=DEFAULT/
 show create table t2;
 select * from t2;
+
 --error ER_TABLE_EXISTS_ERROR
 create table t3 like t1;
+
 --error ER_TABLE_EXISTS_ERROR
 create table t3 like mysqltest.t3;
+
 --error ER_BAD_DB_ERROR
 create table non_existing_database.t1 like t1;
---error ER_NO_SUCH_TABLE
-create table t3 like non_existing_table;
+
+--error ER_TABLE_UNKNOWN
+create table t4 like non_existing_table;
+
 --error ER_TABLE_EXISTS_ERROR
 create temporary table t3 like t1;
 drop table t1, t2, t3;