Merge lp:~jaypipes/drizzle/replication-raw-sql into lp:~drizzle-trunk/drizzle/development

[Jay Pipes]

[Jay Pipes (jaypipes)]

Hi!

This patch removes 4 places where we were still using statement-based replication:

DROP SCHEMA
CREATE SCHEMA
DROP TABLE
CREATE TABLE

Now, all of the above are written to the replication stream as specific message::Statement subclasses describing the changes to be made to the server's state.

This also fixes Bug#527992 (Multi-column Primary Key not handled in replication)

Cheers,

Jay

[Brian Aker (brianaker)]

Hi!

Looks fine, but I may want to revisit how we are doing the
transformation messages at a later point (namely the API/etc).

I need to take a look at SHOW CREATE TABLE/SCHEMA and transform those
in functions. Then use the message output you have in transform.

Cheers,
 -Brian

=== modified file 'drizzled/cursor.cc'
--- drizzled/cursor.cc	2010-02-23 18:09:22 +0000
+++ drizzled/cursor.cc	2010-03-02 21:04:16 +0000
@@ -1353,6 +1353,18 @@
 
   switch (session->lex->sql_command)
   {
+  case SQLCOM_CREATE_TABLE:
+    /*
+     * We are in a CREATE TABLE ... SELECT statement
+     * and the kernel has already created the table
+     * and put a CreateTableStatement in the active
+     * Transaction message.  Here, we add a new InsertRecord
+     * to a new Transaction message (because the above
+     * CREATE TABLE will commit the transaction containing
+     * it).
+     */
+    result= replication_services.insertRecord(session, table);
+    break;
   case SQLCOM_REPLACE:
   case SQLCOM_REPLACE_SELECT:
     /*

=== modified file 'drizzled/db.cc'
--- drizzled/db.cc	2010-03-01 23:42:31 +0000
+++ drizzled/db.cc	2010-03-02 21:04:16 +0000
@@ -129,7 +129,7 @@
   }
   else // Created !
   {
-    replication_services.rawStatement(session, session->query);
+    replication_services.createSchema(session, schema_message);
     session->my_ok(1);
   }
 
@@ -275,7 +275,7 @@
     assert(! session->query.empty());
 
     ReplicationServices &replication_services= ReplicationServices::singleton();
-    replication_services.rawStatement(session, session->getQueryString());
+    replication_services.dropSchema(session, schema_name);
     session->clear_error();
     session->server_status|= SERVER_STATUS_DB_DROPPED;
     session->my_ok((uint32_t) deleted);

=== modified file 'drizzled/join.cc'
--- drizzled/join.cc	2010-02-11 20:01:37 +0000
+++ drizzled/join.cc	2010-03-02 21:04:16 +0000
@@ -337,6 +337,12 @@
   if (error)
     goto err;
 
+  /* 
+   * The below will create the new table for
+   * CREATE TABLE ... SELECT
+   *
+   * @see create_table_from_items() in drizzled/sql_insert.cc
+   */
   if (result && result->prepare(fields_list, unit_arg))
     goto err;
 

=== modified file 'drizzled/message/statement_transform.cc'
--- drizzled/message/statement_transform.cc	2010-02-08 01:10:03 +0000
+++ drizzled/message/statement_transform.cc	2010-03-02 21:04:16 +0000
@@ -2,10 +2,11 @@
  *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
  *
  *  Copyright (C) 2009 Sun Microsystems
+ *  Copyright (c) 2010 Jay Pipes
  *
  *  Authors:
  *
- *    Jay Pipes <[e-mail]>
+ *    Jay Pipes <[e-mail]>
  *
  *  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
@@ -36,23 +37,27 @@
 
 #include <string>
 #include <vector>
+#include <sstream>
 
 using namespace std;
 
 namespace drizzled
 {
 
-enum message::TransformSqlError
-message::transformStatementToSql(const message::Statement &source,
-                                 vector<string> &sql_strings,
-                                 enum message::TransformSqlVariant sql_variant,
-                                 bool already_in_transaction)
-{
-  message::TransformSqlError error= NONE;
+namespace message
+{
+
+enum TransformSqlError
+transformStatementToSql(const Statement &source,
+                        vector<string> &sql_strings,
+                        enum TransformSqlVariant sql_variant,
+                        bool already_in_transaction)
+{
+  TransformSqlError error= NONE;
 
   switch (source.type())
   {
-  case message::Statement::INSERT:
+  case Statement::INSERT:
     {
       if (! source.has_insert_header())
       {
@@ -65,8 +70,8 @@
         return error;
       }
 
-      const message::InsertHeader &insert_header= source.insert_header();
-      const message::InsertData &insert_data= source.insert_data();
+      const InsertHeader &insert_header= source.insert_header();
+      const InsertData &insert_data= source.insert_data();
       size_t num_keys= insert_data.record_size();
       size_t x;
 
@@ -79,7 +84,7 @@
 
         error= transformInsertRecordToSql(insert_header,
                                           insert_data.record(x),
-                                          &destination,
+                                          destination,
                                           sql_variant);
         if (error != NONE)
           break;
@@ -96,7 +101,7 @@
       }
     }
     break;
-  case message::Statement::UPDATE:
+  case Statement::UPDATE:
     {
       if (! source.has_update_header())
       {
@@ -109,8 +114,8 @@
         return error;
       }
 
-      const message::UpdateHeader &update_header= source.update_header();
-      const message::UpdateData &update_data= source.update_data();
+      const UpdateHeader &update_header= source.update_header();
+      const UpdateData &update_data= source.update_data();
       size_t num_keys= update_data.record_size();
       size_t x;
 
@@ -123,7 +128,7 @@
 
         error= transformUpdateRecordToSql(update_header,
                                           update_data.record(x),
-                                          &destination,
+                                          destination,
                                           sql_variant);
         if (error != NONE)
           break;
@@ -140,7 +145,7 @@
       }
     }
     break;
-  case message::Statement::DELETE:
+  case Statement::DELETE:
     {
       if (! source.has_delete_header())
       {
@@ -153,8 +158,8 @@
         return error;
       }
 
-      const message::DeleteHeader &delete_header= source.delete_header();
-      const message::DeleteData &delete_data= source.delete_data();
+      const DeleteHeader &delete_header= source.delete_header();
+      const DeleteData &delete_data= source.delete_data();
       size_t num_keys= delete_data.record_size();
       size_t x;
 
@@ -167,7 +172,7 @@
 
         error= transformDeleteRecordToSql(delete_header,
                                           delete_data.record(x),
-                                          &destination,
+                                          destination,
                                           sql_variant);
         if (error != NONE)
           break;
@@ -184,27 +189,67 @@
       }
     }
     break;
-  case message::Statement::TRUNCATE_TABLE:
+  case Statement::CREATE_TABLE:
+    {
+      assert(source.has_create_table_statement());
+      string destination;
+      error= transformCreateTableStatementToSql(source.create_table_statement(),
+                                                destination,
+                                                sql_variant);
+      sql_strings.push_back(destination);
+    }
+    break;
+  case Statement::TRUNCATE_TABLE:
     {
       assert(source.has_truncate_table_statement());
       string destination;
-      error= message::transformTruncateTableStatementToSql(source.truncate_table_statement(),
-                                                           &destination,
-                                                           sql_variant);
-      sql_strings.push_back(destination);
-    }
-    break;
-  case message::Statement::SET_VARIABLE:
+      error= transformTruncateTableStatementToSql(source.truncate_table_statement(),
+                                                  destination,
+                                                  sql_variant);
+      sql_strings.push_back(destination);
+    }
+    break;
+  case Statement::DROP_TABLE:
+    {
+      assert(source.has_drop_table_statement());
+      string destination;
+      error= transformDropTableStatementToSql(source.drop_table_statement(),
+                                              destination,
+                                              sql_variant);
+      sql_strings.push_back(destination);
+    }
+    break;
+  case Statement::CREATE_SCHEMA:
+    {
+      assert(source.has_create_schema_statement());
+      string destination;
+      error= transformCreateSchemaStatementToSql(source.create_schema_statement(),
+                                                 destination,
+                                                 sql_variant);
+      sql_strings.push_back(destination);
+    }
+    break;
+  case Statement::DROP_SCHEMA:
+    {
+      assert(source.has_drop_schema_statement());
+      string destination;
+      error= transformDropSchemaStatementToSql(source.drop_schema_statement(),
+                                               destination,
+                                               sql_variant);
+      sql_strings.push_back(destination);
+    }
+    break;
+  case Statement::SET_VARIABLE:
     {
       assert(source.has_set_variable_statement());
       string destination;
-      error= message::transformSetVariableStatementToSql(source.set_variable_statement(),
-                                                       &destination,
-                                                       sql_variant);
+      error= transformSetVariableStatementToSql(source.set_variable_statement(),
+                                                destination,
+                                                sql_variant);
       sql_strings.push_back(destination);
     }
     break;
-  case message::Statement::RAW_SQL:
+  case Statement::RAW_SQL:
   default:
     sql_strings.push_back(source.sql());
     break;
@@ -212,24 +257,24 @@
   return error;
 }
 
-enum message::TransformSqlError
-message::transformInsertHeaderToSql(const message::InsertHeader &header,
-                                    std::string *destination,
-                                    enum message::TransformSqlVariant sql_variant)
+enum TransformSqlError
+transformInsertHeaderToSql(const InsertHeader &header,
+                           string &destination,
+                           enum TransformSqlVariant sql_variant)
 {
   char quoted_identifier= '`';
   if (sql_variant == ANSI)
     quoted_identifier= '"';
 
-  destination->assign("INSERT INTO ", 12);
-  destination->push_back(quoted_identifier);
-  destination->append(header.table_metadata().schema_name());
-  destination->push_back(quoted_identifier);
-  destination->push_back('.');
-  destination->push_back(quoted_identifier);
-  destination->append(header.table_metadata().table_name());
-  destination->push_back(quoted_identifier);
-  destination->append(" (", 2);
+  destination.assign("INSERT INTO ", 12);
+  destination.push_back(quoted_identifier);
+  destination.append(header.table_metadata().schema_name());
+  destination.push_back(quoted_identifier);
+  destination.push_back('.');
+  destination.push_back(quoted_identifier);
+  destination.append(header.table_metadata().table_name());
+  destination.push_back(quoted_identifier);
+  destination.append(" (", 2);
 
   /* Add field list to SQL string... */
   size_t num_fields= header.field_metadata_size();
@@ -237,33 +282,33 @@
 
   for (x= 0; x < num_fields; ++x)
   {
-    const message::FieldMetadata &field_metadata= header.field_metadata(x);
+    const FieldMetadata &field_metadata= header.field_metadata(x);
     if (x != 0)
-      destination->push_back(',');
+      destination.push_back(',');
     
-    destination->push_back(quoted_identifier);
-    destination->append(field_metadata.name());
-    destination->push_back(quoted_identifier);
+    destination.push_back(quoted_identifier);
+    destination.append(field_metadata.name());
+    destination.push_back(quoted_identifier);
   }
 
   return NONE;
 }
 
-enum message::TransformSqlError
-message::transformInsertRecordToSql(const message::InsertHeader &header,
-                                    const message::InsertRecord &record,
-                                    std::string *destination,
-                                    enum message::TransformSqlVariant sql_variant)
+enum TransformSqlError
+transformInsertRecordToSql(const InsertHeader &header,
+                           const InsertRecord &record,
+                           string &destination,
+                           enum TransformSqlVariant sql_variant)
 {
-  enum message::TransformSqlError error= transformInsertHeaderToSql(header,
-                                                                    destination,
-                                                                    sql_variant);
+  enum TransformSqlError error= transformInsertHeaderToSql(header,
+                                                           destination,
+                                                           sql_variant);
 
   char quoted_identifier= '`';
   if (sql_variant == ANSI)
     quoted_identifier= '"';
 
-  destination->append(") VALUES (");
+  destination.append(") VALUES (");
 
   /* Add insert values */
   size_t num_fields= header.field_metadata_size();
@@ -273,16 +318,16 @@
   for (x= 0; x < num_fields; ++x)
   {
     if (x != 0)
-      destination->push_back(',');
-
-    const message::FieldMetadata &field_metadata= header.field_metadata(x);
-
-    should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
+      destination.push_back(',');
+
+    const FieldMetadata &field_metadata= header.field_metadata(x);
+
+    should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
 
     if (should_quote_field_value)
-      destination->push_back('\'');
+      destination.push_back('\'');
 
-    if (field_metadata.type() == message::Table::Field::BLOB)
+    if (field_metadata.type() == Table::Field::BLOB)
     {
       /* 
         * We do this here because BLOB data is returned
@@ -291,36 +336,36 @@
         * up to a \0 being output here.
         */
       string raw_data(record.insert_value(x));
-      destination->append(raw_data.c_str(), raw_data.size());
+      destination.append(raw_data.c_str(), raw_data.size());
     }
     else
     {
-      destination->append(record.insert_value(x));
+      destination.append(record.insert_value(x));
     }
 
     if (should_quote_field_value)
-      destination->push_back('\'');
+      destination.push_back('\'');
   }
-  destination->push_back(')');
+  destination.push_back(')');
 
   return error;
 }
 
-enum message::TransformSqlError
-message::transformInsertStatementToSql(const message::InsertHeader &header,
-                                       const message::InsertData &data,
-                                       std::string *destination,
-                                       enum message::TransformSqlVariant sql_variant)
+enum TransformSqlError
+transformInsertStatementToSql(const InsertHeader &header,
+                              const InsertData &data,
+                              string &destination,
+                              enum TransformSqlVariant sql_variant)
 {
-  enum message::TransformSqlError error= transformInsertHeaderToSql(header,
-                                                                    destination,
-                                                                    sql_variant);
+  enum TransformSqlError error= transformInsertHeaderToSql(header,
+                                                           destination,
+                                                           sql_variant);
 
   char quoted_identifier= '`';
   if (sql_variant == ANSI)
     quoted_identifier= '"';
 
-  destination->append(") VALUES (", 10);
+  destination.append(") VALUES (", 10);
 
   /* Add insert values */
   size_t num_records= data.record_size();
@@ -331,21 +376,21 @@
   for (x= 0; x < num_records; ++x)
   {
     if (x != 0)
-      destination->append("),(", 3);
+      destination.append("),(", 3);
 
     for (y= 0; y < num_fields; ++y)
     {
       if (y != 0)
-        destination->push_back(',');
+        destination.push_back(',');
 
-      const message::FieldMetadata &field_metadata= header.field_metadata(y);
+      const FieldMetadata &field_metadata= header.field_metadata(y);
       
-      should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
+      should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
 
       if (should_quote_field_value)
-        destination->push_back('\'');
+        destination.push_back('\'');
 
-      if (field_metadata.type() == message::Table::Field::BLOB)
+      if (field_metadata.type() == Table::Field::BLOB)
       {
         /* 
          * We do this here because BLOB data is returned
@@ -354,53 +399,53 @@
          * up to a \0 being output here.
          */
         string raw_data(data.record(x).insert_value(y));
-        destination->append(raw_data.c_str(), raw_data.size());
+        destination.append(raw_data.c_str(), raw_data.size());
       }
       else
       {
-        destination->append(data.record(x).insert_value(y));
+        destination.append(data.record(x).insert_value(y));
       }
 
       if (should_quote_field_value)
-        destination->push_back('\'');
+        destination.push_back('\'');
     }
   }
-  destination->push_back(')');
+  destination.push_back(')');
 
   return error;
 }
 
-enum message::TransformSqlError
-message::transformUpdateHeaderToSql(const message::UpdateHeader &header,
-                                    std::string *destination,
-                                    enum message::TransformSqlVariant sql_variant)
+enum TransformSqlError
+transformUpdateHeaderToSql(const UpdateHeader &header,
+                           string &destination,
+                           enum TransformSqlVariant sql_variant)
 {
   char quoted_identifier= '`';
   if (sql_variant == ANSI)
     quoted_identifier= '"';
 
-  destination->assign("UPDATE ", 7);
-  destination->push_back(quoted_identifier);
-  destination->append(header.table_metadata().schema_name());
-  destination->push_back(quoted_identifier);
-  destination->push_back('.');
-  destination->push_back(quoted_identifier);
-  destination->append(header.table_metadata().table_name());
-  destination->push_back(quoted_identifier);
-  destination->append(" SET ", 5);
+  destination.assign("UPDATE ", 7);
+  destination.push_back(quoted_identifier);
+  destination.append(header.table_metadata().schema_name());
+  destination.push_back(quoted_identifier);
+  destination.push_back('.');
+  destination.push_back(quoted_identifier);
+  destination.append(header.table_metadata().table_name());
+  destination.push_back(quoted_identifier);
+  destination.append(" SET ", 5);
 
   return NONE;
 }
 
-enum message::TransformSqlError
-message::transformUpdateRecordToSql(const message::UpdateHeader &header,
-                                    const message::UpdateRecord &record,
-                                    std::string *destination,
-                                    enum message::TransformSqlVariant sql_variant)
+enum TransformSqlError
+transformUpdateRecordToSql(const UpdateHeader &header,
+                           const UpdateRecord &record,
+                           string &destination,
+                           enum TransformSqlVariant sql_variant)
 {
-  enum message::TransformSqlError error= transformUpdateHeaderToSql(header,
-                                                                    destination,
-                                                                    sql_variant);
+  enum TransformSqlError error= transformUpdateHeaderToSql(header,
+                                                           destination,
+                                                           sql_variant);
 
   char quoted_identifier= '`';
   if (sql_variant == ANSI)
@@ -413,21 +458,21 @@
 
   for (x= 0; x < num_set_fields; ++x)
   {
-    const message::FieldMetadata &field_metadata= header.set_field_metadata(x);
+    const FieldMetadata &field_metadata= header.set_field_metadata(x);
     if (x != 0)
-      destination->push_back(',');
+      destination.push_back(',');
     
-    destination->push_back(quoted_identifier);
-    destination->append(field_metadata.name());
-    destination->push_back(quoted_identifier);
-    destination->push_back('=');
+    destination.push_back(quoted_identifier);
+    destination.append(field_metadata.name());
+    destination.push_back(quoted_identifier);
+    destination.push_back('=');
 
-    should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
+    should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
 
     if (should_quote_field_value)
-      destination->push_back('\'');
+      destination.push_back('\'');
 
-    if (field_metadata.type() == message::Table::Field::BLOB)
+    if (field_metadata.type() == Table::Field::BLOB)
     {
       /* 
        * We do this here because BLOB data is returned
@@ -436,39 +481,39 @@
        * up to a \0 being output here.
        */
       string raw_data(record.after_value(x));
-      destination->append(raw_data.c_str(), raw_data.size());
+      destination.append(raw_data.c_str(), raw_data.size());
     }
     else
     {
-      destination->append(record.after_value(x));
+      destination.append(record.after_value(x));
     }
 
     if (should_quote_field_value)
-      destination->push_back('\'');
+      destination.push_back('\'');
   }
 
   size_t num_key_fields= header.key_field_metadata_size();
 
-  destination->append(" WHERE ", 7);
+  destination.append(" WHERE ", 7);
   for (x= 0; x < num_key_fields; ++x) 
   {
-    const message::FieldMetadata &field_metadata= header.key_field_metadata(x);
+    const FieldMetadata &field_metadata= header.key_field_metadata(x);
     
     if (x != 0)
-      destination->append(" AND ", 5); /* Always AND condition with a multi-column PK */
-
-    destination->push_back(quoted_identifier);
-    destination->append(field_metadata.name());
-    destination->push_back(quoted_identifier);
-
-    destination->push_back('=');
-
-    should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
+      destination.append(" AND ", 5); /* Always AND condition with a multi-column PK */
+
+    destination.push_back(quoted_identifier);
+    destination.append(field_metadata.name());
+    destination.push_back(quoted_identifier);
+
+    destination.push_back('=');
+
+    should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
 
     if (should_quote_field_value)
-      destination->push_back('\'');
+      destination.push_back('\'');
 
-    if (field_metadata.type() == message::Table::Field::BLOB)
+    if (field_metadata.type() == Table::Field::BLOB)
     {
       /* 
        * We do this here because BLOB data is returned
@@ -477,52 +522,50 @@
        * up to a \0 being output here.
        */
       string raw_data(record.key_value(x));
-      destination->append(raw_data.c_str(), raw_data.size());
+      destination.append(raw_data.c_str(), raw_data.size());
     }
     else
     {
-      destination->append(record.key_value(x));
+      destination.append(record.key_value(x));
     }
 
     if (should_quote_field_value)
-      destination->push_back('\'');
+      destination.push_back('\'');
   }
-  if (num_key_fields > 1)
-    destination->push_back(')');
 
   return error;
 }
 
-enum message::TransformSqlError
-message::transformDeleteHeaderToSql(const message::DeleteHeader &header,
-                                    std::string *destination,
-                                    enum message::TransformSqlVariant sql_variant)
+enum TransformSqlError
+transformDeleteHeaderToSql(const DeleteHeader &header,
+                           string &destination,
+                           enum TransformSqlVariant sql_variant)
 {
   char quoted_identifier= '`';
   if (sql_variant == ANSI)
     quoted_identifier= '"';
 
-  destination->assign("DELETE FROM ", 12);
-  destination->push_back(quoted_identifier);
-  destination->append(header.table_metadata().schema_name());
-  destination->push_back(quoted_identifier);
-  destination->push_back('.');
-  destination->push_back(quoted_identifier);
-  destination->append(header.table_metadata().table_name());
-  destination->push_back(quoted_identifier);
+  destination.assign("DELETE FROM ", 12);
+  destination.push_back(quoted_identifier);
+  destination.append(header.table_metadata().schema_name());
+  destination.push_back(quoted_identifier);
+  destination.push_back('.');
+  destination.push_back(quoted_identifier);
+  destination.append(header.table_metadata().table_name());
+  destination.push_back(quoted_identifier);
 
   return NONE;
 }
 
-enum message::TransformSqlError
-message::transformDeleteRecordToSql(const message::DeleteHeader &header,
-                                    const message::DeleteRecord &record,
-                                    std::string *destination,
-                                    enum message::TransformSqlVariant sql_variant)
+enum TransformSqlError
+transformDeleteRecordToSql(const DeleteHeader &header,
+                           const DeleteRecord &record,
+                           string &destination,
+                           enum TransformSqlVariant sql_variant)
 {
-  enum message::TransformSqlError error= transformDeleteHeaderToSql(header,
-                                                                    destination,
-                                                                    sql_variant);
+  enum TransformSqlError error= transformDeleteHeaderToSql(header,
+                                                           destination,
+                                                           sql_variant);
   char quoted_identifier= '`';
   if (sql_variant == ANSI)
     quoted_identifier= '"';
@@ -532,26 +575,26 @@
   uint32_t x;
   bool should_quote_field_value= false;
 
-  destination->append(" WHERE ", 7);
+  destination.append(" WHERE ", 7);
   for (x= 0; x < num_key_fields; ++x) 
   {
-    const message::FieldMetadata &field_metadata= header.key_field_metadata(x);
+    const FieldMetadata &field_metadata= header.key_field_metadata(x);
     
     if (x != 0)
-      destination->append(" AND ", 5); /* Always AND condition with a multi-column PK */
-
-    destination->push_back(quoted_identifier);
-    destination->append(field_metadata.name());
-    destination->push_back(quoted_identifier);
-
-    destination->push_back('=');
-
-    should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
+      destination.append(" AND ", 5); /* Always AND condition with a multi-column PK */
+
+    destination.push_back(quoted_identifier);
+    destination.append(field_metadata.name());
+    destination.push_back(quoted_identifier);
+
+    destination.push_back('=');
+
+    should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
 
     if (should_quote_field_value)
-      destination->push_back('\'');
+      destination.push_back('\'');
 
-    if (field_metadata.type() == message::Table::Field::BLOB)
+    if (field_metadata.type() == Table::Field::BLOB)
     {
       /* 
        * We do this here because BLOB data is returned
@@ -560,29 +603,29 @@
        * up to a \0 being output here.
        */
       string raw_data(record.key_value(x));
-      destination->append(raw_data.c_str(), raw_data.size());
+      destination.append(raw_data.c_str(), raw_data.size());
     }
     else
     {
-      destination->append(record.key_value(x));
+      destination.append(record.key_value(x));
     }
 
     if (should_quote_field_value)
-      destination->push_back('\'');
+      destination.push_back('\'');
   }
 
   return error;
 }
 
-enum message::TransformSqlError
-message::transformDeleteStatementToSql(const message::DeleteHeader &header,
-                                       const message::DeleteData &data,
-                                       std::string *destination,
-                                       enum message::TransformSqlVariant sql_variant)
+enum TransformSqlError
+transformDeleteStatementToSql(const DeleteHeader &header,
+                              const DeleteData &data,
+                              string &destination,
+                              enum TransformSqlVariant sql_variant)
 {
-  enum message::TransformSqlError error= transformDeleteHeaderToSql(header,
-                                                                    destination,
-                                                                    sql_variant);
+  enum TransformSqlError error= transformDeleteHeaderToSql(header,
+                                                           destination,
+                                                           sql_variant);
   char quoted_identifier= '`';
   if (sql_variant == ANSI)
     quoted_identifier= '"';
@@ -593,34 +636,34 @@
   uint32_t x, y;
   bool should_quote_field_value= false;
 
-  destination->append(" WHERE ", 7);
+  destination.append(" WHERE ", 7);
   for (x= 0; x < num_key_records; ++x)
   {
     if (x != 0)
-      destination->append(" OR ", 4); /* Always OR condition for multiple key records */
+      destination.append(" OR ", 4); /* Always OR condition for multiple key records */
 
     if (num_key_fields > 1)
-      destination->push_back('(');
+      destination.push_back('(');
 
     for (y= 0; y < num_key_fields; ++y) 
     {
-      const message::FieldMetadata &field_metadata= header.key_field_metadata(y);
+      const FieldMetadata &field_metadata= header.key_field_metadata(y);
       
       if (y != 0)
-        destination->append(" AND ", 5); /* Always AND condition with a multi-column PK */
-
-      destination->push_back(quoted_identifier);
-      destination->append(field_metadata.name());
-      destination->push_back(quoted_identifier);
-
-      destination->push_back('=');
-
-      should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
+        destination.append(" AND ", 5); /* Always AND condition with a multi-column PK */
+
+      destination.push_back(quoted_identifier);
+      destination.append(field_metadata.name());
+      destination.push_back(quoted_identifier);
+
+      destination.push_back('=');
+
+      should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
 
       if (should_quote_field_value)
-        destination->push_back('\'');
+        destination.push_back('\'');
 
-      if (field_metadata.type() == message::Table::Field::BLOB)
+      if (field_metadata.type() == Table::Field::BLOB)
       {
         /* 
          * We do this here because BLOB data is returned
@@ -629,114 +672,607 @@
          * up to a \0 being output here.
          */
         string raw_data(data.record(x).key_value(y));
-        destination->append(raw_data.c_str(), raw_data.size());
+        destination.append(raw_data.c_str(), raw_data.size());
       }
       else
       {
-        destination->append(data.record(x).key_value(y));
+        destination.append(data.record(x).key_value(y));
       }
 
       if (should_quote_field_value)
-        destination->push_back('\'');
+        destination.push_back('\'');
     }
     if (num_key_fields > 1)
-      destination->push_back(')');
+      destination.push_back(')');
   }
   return error;
 }
 
-enum message::TransformSqlError
-message::transformTruncateTableStatementToSql(const message::TruncateTableStatement &statement,
-                                              std::string *destination,
-                                              enum message::TransformSqlVariant sql_variant)
-{
-  char quoted_identifier= '`';
-  if (sql_variant == ANSI)
-    quoted_identifier= '"';
-
-  const message::TableMetadata &table_metadata= statement.table_metadata();
-
-  destination->append("TRUNCATE TABLE ", 15);
-  destination->push_back(quoted_identifier);
-  destination->append(table_metadata.schema_name());
-  destination->push_back(quoted_identifier);
-  destination->push_back('.');
-  destination->push_back(quoted_identifier);
-  destination->append(table_metadata.table_name());
-  destination->push_back(quoted_identifier);
-
-  return NONE;
-}
-
-enum message::TransformSqlError
-message::transformSetVariableStatementToSql(const message::SetVariableStatement &statement,
-                                            std::string *destination,
-                                            enum message::TransformSqlVariant sql_variant)
+enum TransformSqlError
+transformDropSchemaStatementToSql(const DropSchemaStatement &statement,
+                                  string &destination,
+                                  enum TransformSqlVariant sql_variant)
+{
+  char quoted_identifier= '`';
+  if (sql_variant == ANSI)
+    quoted_identifier= '"';
+
+  destination.append("DROP SCHEMA ", 12);
+  destination.push_back(quoted_identifier);
+  destination.append(statement.schema_name());
+  destination.push_back(quoted_identifier);
+
+  return NONE;
+}
+
+enum TransformSqlError
+transformCreateSchemaStatementToSql(const CreateSchemaStatement &statement,
+                                    string &destination,
+                                    enum TransformSqlVariant sql_variant)
+{
+  char quoted_identifier= '`';
+  if (sql_variant == ANSI)
+    quoted_identifier= '"';
+
+  const Schema &schema= statement.schema();
+
+  destination.append("CREATE SCHEMA ", 14);
+  destination.push_back(quoted_identifier);
+  destination.append(schema.name());
+  destination.push_back(quoted_identifier);
+
+  if (schema.has_collation())
+  {
+    destination.append(" COLLATE ", 9);
+    destination.append(schema.collation());
+  }
+
+  return NONE;
+}
+
+enum TransformSqlError
+transformDropTableStatementToSql(const DropTableStatement &statement,
+                                 string &destination,
+                                 enum TransformSqlVariant sql_variant)
+{
+  char quoted_identifier= '`';
+  if (sql_variant == ANSI)
+    quoted_identifier= '"';
+
+  const TableMetadata &table_metadata= statement.table_metadata();
+
+  destination.append("DROP TABLE ", 11);
+
+  /* Add the IF EXISTS clause if necessary */
+  if (statement.has_if_exists_clause() &&
+      statement.if_exists_clause() == true)
+  {
+    destination.append("IF EXISTS ", 10);
+  }
+
+  destination.push_back(quoted_identifier);
+  destination.append(table_metadata.schema_name());
+  destination.push_back(quoted_identifier);
+  destination.push_back('.');
+  destination.push_back(quoted_identifier);
+  destination.append(table_metadata.table_name());
+  destination.push_back(quoted_identifier);
+
+  return NONE;
+}
+
+enum TransformSqlError
+transformTruncateTableStatementToSql(const TruncateTableStatement &statement,
+                                     string &destination,
+                                     enum TransformSqlVariant sql_variant)
+{
+  char quoted_identifier= '`';
+  if (sql_variant == ANSI)
+    quoted_identifier= '"';
+
+  const TableMetadata &table_metadata= statement.table_metadata();
+
+  destination.append("TRUNCATE TABLE ", 15);
+  destination.push_back(quoted_identifier);
+  destination.append(table_metadata.schema_name());
+  destination.push_back(quoted_identifier);
+  destination.push_back('.');
+  destination.push_back(quoted_identifier);
+  destination.append(table_metadata.table_name());
+  destination.push_back(quoted_identifier);
+
+  return NONE;
+}
+
+enum TransformSqlError
+transformSetVariableStatementToSql(const SetVariableStatement &statement,
+                                   string &destination,
+                                   enum TransformSqlVariant sql_variant)
 {
   (void) sql_variant;
-  const message::FieldMetadata &variable_metadata= statement.variable_metadata();
-  bool should_quote_field_value= message::shouldQuoteFieldValue(variable_metadata.type());
-
-  destination->append("SET GLOBAL ", 11); /* Only global variables are replicated */
-  destination->append(variable_metadata.name());
-  destination->push_back('=');
-
-  if (should_quote_field_value)
-    destination->push_back('\'');
-  
-  destination->append(statement.variable_value());
-
-  if (should_quote_field_value)
-    destination->push_back('\'');
-
-  return NONE;
-}
-
-bool message::shouldQuoteFieldValue(message::Table::Field::FieldType in_type)
+  const FieldMetadata &variable_metadata= statement.variable_metadata();
+  bool should_quote_field_value= shouldQuoteFieldValue(variable_metadata.type());
+
+  destination.append("SET GLOBAL ", 11); /* Only global variables are replicated */
+  destination.append(variable_metadata.name());
+  destination.push_back('=');
+
+  if (should_quote_field_value)
+    destination.push_back('\'');
+  
+  destination.append(statement.variable_value());
+
+  if (should_quote_field_value)
+    destination.push_back('\'');
+
+  return NONE;
+}
+
+enum TransformSqlError
+transformCreateTableStatementToSql(const CreateTableStatement &statement,
+                                   string &destination,
+                                   enum TransformSqlVariant sql_variant)
+{
+  return transformTableDefinitionToSql(statement.table(), destination, sql_variant);
+}
+
+enum TransformSqlError
+transformTableDefinitionToSql(const Table &table,
+                              string &destination,
+                              enum TransformSqlVariant sql_variant)
+{
+  char quoted_identifier= '`';
+  if (sql_variant == ANSI)
+    quoted_identifier= '"';
+
+  destination.append("CREATE ", 7);
+
+  if (table.type() == Table::TEMPORARY)
+    destination.append("TEMPORARY ", 10);
+  
+  destination.append("TABLE ", 6);
+  destination.push_back(quoted_identifier);
+  destination.append(table.name());
+  destination.push_back(quoted_identifier);
+  destination.append(" (\n", 3);
+
+  enum TransformSqlError result= NONE;
+  size_t num_fields= table.field_size();
+  for (size_t x= 0; x < num_fields; ++x)
+  {
+    const Table::Field &field= table.field(x);
+
+    if (x != 0)
+      destination.append(",\n", 2);
+
+    result= transformFieldDefinitionToSql(field, destination, sql_variant);
+    
+    if (result != NONE)
+      return result;
+  }
+
+  size_t num_indexes= table.indexes_size();
+  
+  if (num_indexes > 0)
+    destination.append(",\n", 2);
+
+  for (size_t x= 0; x < num_indexes; ++x)
+  {
+    const message::Table::Index &index= table.indexes(x);
+
+    if (x != 0)
+      destination.append(",\n", 2);
+
+    result= transformIndexDefinitionToSql(index, table, destination, sql_variant);
+    
+    if (result != NONE)
+      return result;
+  }
+  destination.append("\n)", 2);
+
+  /* Add ENGINE = " clause */
+  if (table.has_engine())
+  {
+    const Table::StorageEngine &engine= table.engine();
+    destination.append("\nENGINE = ", 10);
+    destination.append(engine.name());
+
+    size_t num_engine_options= engine.option_size();
+    for (size_t x= 0; x < num_engine_options; ++x)
+    {
+      const Table::StorageEngine::EngineOption &option= engine.option(x);
+      destination.push_back('\n');
+      destination.append(option.option_name());
+      destination.append(" = ", 3);
+      destination.append(option.option_value());
+      destination.push_back('\n');
+    }
+  }
+
+  if (table.has_options())
+    (void) transformTableOptionsToSql(table.options(), destination, sql_variant);
+
+  return NONE;
+}
+
+enum TransformSqlError
+transformTableOptionsToSql(const Table::TableOptions &options,
+                           string &destination,
+                           enum TransformSqlVariant sql_variant)
+{
+  if (sql_variant == ANSI)
+    return NONE; /* ANSI does not support table options... */
+
+  stringstream ss;
+
+  if (options.has_comment())
+  {
+    destination.append("\nCOMMENT = '", 12);
+    destination.append(options.comment());
+    destination.push_back('\'');
+  }
+
+  if (options.has_collation())
+  {
+    destination.append("\nCOLLATE = ", 11);
+    destination.append(options.collation());
+  }
+
+  if (options.has_auto_increment())
+  {
+    ss << options.auto_increment();
+    destination.append("\nAUTOINCREMENT_OFFSET = ", 24);
+    destination.append(ss.str());
+    ss.clear();
+  }
+  
+  if (options.has_row_type())
+  {
+    ss << options.row_type();
+    destination.append("\nROW_TYPE = ", 12);
+    destination.append(ss.str());
+    ss.clear();
+  }
+
+  if (options.has_data_file_name())
+  {
+    destination.append("\nDATA_FILE_NAME = '", 19);
+    destination.append(options.data_file_name());
+    destination.push_back('\'');
+  }
+
+  if (options.has_index_file_name())
+  {
+    destination.append("\nINDEX_FILE_NAME = '", 20);
+    destination.append(options.index_file_name());
+    destination.push_back('\'');
+  }
+
+  if (options.has_max_rows())
+  {
+    ss << options.max_rows();
+    destination.append("\nMAX_ROWS = ", 12);
+    destination.append(ss.str());
+    ss.clear();
+  }
+
+  if (options.has_min_rows())
+  {
+    ss << options.min_rows();
+    destination.append("\nMIN_ROWS = ", 12);
+    destination.append(ss.str());
+    ss.clear();
+  }
+
+  if (options.has_auto_increment_value())
+  {
+    ss << options.auto_increment_value();
+    destination.append("\nAUTO_INCREMENT = ", 18);
+    destination.append(ss.str());
+    ss.clear();
+  }
+
+  if (options.has_avg_row_length())
+  {
+    ss << options.avg_row_length();
+    destination.append("\nAVG_ROW_LENGTH = ", 18);
+    destination.append(ss.str());
+    ss.clear();
+  }
+
+  if (options.has_key_block_size())
+  {
+    ss << options.key_block_size();
+    destination.append("\nKEY_BLOCK_SIZE = ", 18);
+    destination.append(ss.str());
+    ss.clear();
+  }
+
+  if (options.has_block_size())
+  {
+    ss << options.block_size();
+    destination.append("\nBLOCK_SIZE = ", 14);
+    destination.append(ss.str());
+    ss.clear();
+  }
+
+  if (options.has_pack_keys() &&
+      options.pack_keys())
+    destination.append("\nPACK_KEYS = TRUE", 17);
+  if (options.has_pack_record() &&
+      options.pack_record())
+    destination.append("\nPACK_RECORD = TRUE", 19);
+  if (options.has_checksum() &&
+      options.checksum())
+    destination.append("\nCHECKSUM = TRUE", 16);
+  if (options.has_page_checksum() &&
+      options.page_checksum())
+    destination.append("\nPAGE_CHECKSUM = TRUE", 21);
+
+  return NONE;
+}
+
+enum TransformSqlError
+transformIndexDefinitionToSql(const Table::Index &index,
+                              const Table &table,
+                              string &destination,
+                              enum TransformSqlVariant sql_variant)
+{
+  char quoted_identifier= '`';
+  if (sql_variant == ANSI)
+    quoted_identifier= '"';
+
+  if (index.is_primary())
+    destination.append("PRIMARY ", 8);
+  else if (index.is_unique())
+    destination.append("UNIQUE ", 7);
+
+  destination.append("KEY ", 4);
+  destination.push_back(quoted_identifier);
+  destination.append(index.name());
+  destination.push_back(quoted_identifier);
+  destination.append(" (", 2);
+  
+  size_t num_parts= index.index_part_size();
+  for (size_t x= 0; x < num_parts; ++x)
+  {
+    const Table::Index::IndexPart &part= index.index_part(x);
+    const Table::Field &field= table.field(part.fieldnr());
+
+    if (x != 0)
+      destination.push_back(',');
+    
+    destination.push_back(quoted_identifier);
+    destination.append(field.name());
+    destination.push_back(quoted_identifier);
+
+    /* 
+     * If the index part's field type is VARCHAR or TEXT
+     * then check for a prefix length then is different
+     * from the field's full length...
+     */
+    if (field.type() == Table::Field::VARCHAR ||
+        field.type() == Table::Field::BLOB)
+    {
+      if (part.has_compare_length())
+      {
+        size_t compare_length_in_chars= part.compare_length();
+        
+        /* hack: compare_length() is bytes, not chars, but
+         * only for VARCHAR. Ass. */
+        if (field.type() == Table::Field::VARCHAR)
+          compare_length_in_chars/= 4;
+
+        if (compare_length_in_chars != field.string_options().length())
+        {
+          stringstream ss;
+          destination.push_back('(');
+          ss << compare_length_in_chars;
+          destination.append(ss.str());
+          destination.push_back(')');
+        }
+      }
+    }
+  }
+  destination.push_back(')');
+
+  return NONE;
+}
+
+enum TransformSqlError
+transformFieldDefinitionToSql(const Table::Field &field,
+                              string &destination,
+                              enum TransformSqlVariant sql_variant)
+{
+  char quoted_identifier= '`';
+  if (sql_variant == ANSI)
+    quoted_identifier= '"';
+
+  destination.push_back(quoted_identifier);
+  destination.append(field.name());
+  destination.push_back(quoted_identifier);
+
+  Table::Field::FieldType field_type= field.type();
+
+  switch (field_type)
+  {
+    case Table::Field::DOUBLE:
+    destination.append(" DOUBLE", 7);
+    break;
+  case Table::Field::VARCHAR:
+    {
+      destination.append(" VARCHAR(", 9);
+      stringstream ss;
+      ss << field.string_options().length() << ")";
+      destination.append(ss.str());
+    }
+    break;
+  case Table::Field::BLOB:
+    destination.append(" BLOB", 5);
+    break;
+  case Table::Field::ENUM:
+    {
+      size_t num_field_values= field.set_options().field_value_size();
+      destination.append(" ENUM(", 6);
+      for (size_t x= 0; x < num_field_values; ++x)
+      {
+        const string &type= field.set_options().field_value(x);
+
+        if (x != 0)
+          destination.push_back(',');
+
+        destination.push_back('\'');
+        destination.append(type);
+        destination.push_back('\'');
+      }
+      destination.push_back(')');
+      break;
+    }
+  case Table::Field::INTEGER:
+    destination.append(" INT", 4);
+    break;
+  case Table::Field::BIGINT:
+    destination.append(" BIGINT", 7);
+    break;
+  case Table::Field::DECIMAL:
+    {
+      destination.append(" DECIMAL(", 9);
+      stringstream ss;
+      ss << field.numeric_options().precision() << ",";
+      ss << field.numeric_options().scale() << ")";
+      destination.append(ss.str());
+    }
+    break;
+  case Table::Field::DATE:
+    destination.append(" DATE", 5);
+    break;
+  case Table::Field::TIMESTAMP:
+    destination.append(" TIMESTAMP",  10);
+    break;
+  case Table::Field::DATETIME:
+    destination.append(" DATETIME",  9);
+    break;
+  }
+
+  if (field.type() == Table::Field::INTEGER || 
+      field.type() == Table::Field::BIGINT)
+  {
+    if (field.has_constraints() &&
+        field.constraints().has_is_unsigned() &&
+        field.constraints().is_unsigned())
+    {
+      destination.append(" UNSIGNED", 9);
+    }
+  }
+
+
+  if (! (field.has_constraints() &&
+         field.constraints().is_nullable()))
+  {
+    destination.append(" NOT", 4);
+  }
+  destination.append(" NULL", 5);
+
+  if (field.type() == Table::Field::INTEGER || 
+      field.type() == Table::Field::BIGINT)
+  {
+    /* AUTO_INCREMENT must be after NOT NULL */
+    if (field.has_numeric_options() &&
+        field.numeric_options().is_autoincrement())
+    {
+      destination.append(" AUTO_INCREMENT", 15);
+    }
+  }
+
+  if (field.type() == Table::Field::BLOB ||
+      field.type() == Table::Field::VARCHAR)
+  {
+    if (field.string_options().has_collation())
+    {
+      destination.append(" COLLATE ", 9);
+      destination.append(field.string_options().collation());
+    }
+  }
+
+  if (field.options().has_default_value())
+  {
+    destination.append(" DEFAULT ", 9);
+    destination.push_back(quoted_identifier);
+    destination.append(field.options().default_value());
+    destination.push_back(quoted_identifier);
+  }
+
+  if (field.options().has_default_bin_value())
+  {
+    const string &v= field.options().default_bin_value();
+    destination.append(" DEFAULT 0x", 11);
+    for (size_t x= 0; x < v.length(); x++)
+    {
+      printf("%.2x", *(v.c_str() + x));
+    }
+  }
+
+  if (field.type() == Table::Field::TIMESTAMP)
+    if (field.timestamp_options().has_auto_updates() &&
+        field.timestamp_options().auto_updates())
+      destination.append(" ON UPDATE CURRENT_TIMESTAMP", 28);
+
+  if (field.has_comment())
+  {
+    destination.append(" COMMENT ", 9);
+    destination.push_back(quoted_identifier);
+    destination.append(field.comment());
+    destination.push_back(quoted_identifier);
+  }
+  return NONE;
+}
+
+bool shouldQuoteFieldValue(Table::Field::FieldType in_type)
 {
   switch (in_type)
   {
-  case message::Table::Field::DOUBLE:
-  case message::Table::Field::DECIMAL:
-  case message::Table::Field::INTEGER:
-  case message::Table::Field::BIGINT:
-  case message::Table::Field::ENUM:
+  case Table::Field::DOUBLE:
+  case Table::Field::DECIMAL:
+  case Table::Field::INTEGER:
+  case Table::Field::BIGINT:
+  case Table::Field::ENUM:
     return false;
   default:
     return true;
   } 
 }
 
-drizzled::message::Table::Field::FieldType message::internalFieldTypeToFieldProtoType(enum enum_field_types type)
+Table::Field::FieldType internalFieldTypeToFieldProtoType(enum enum_field_types type)
 {
   switch (type) {
   case DRIZZLE_TYPE_LONG:
-    return message::Table::Field::INTEGER;
+    return Table::Field::INTEGER;
   case DRIZZLE_TYPE_DOUBLE:
-    return message::Table::Field::DOUBLE;
+    return Table::Field::DOUBLE;
   case DRIZZLE_TYPE_NULL:
     assert(false); /* Not a user definable type */
-    return message::Table::Field::INTEGER; /* unreachable */
+    return Table::Field::INTEGER; /* unreachable */
   case DRIZZLE_TYPE_TIMESTAMP:
-    return message::Table::Field::TIMESTAMP;
+    return Table::Field::TIMESTAMP;
   case DRIZZLE_TYPE_LONGLONG:
-    return message::Table::Field::BIGINT;
+    return Table::Field::BIGINT;
   case DRIZZLE_TYPE_DATETIME:
-    return message::Table::Field::DATETIME;
+    return Table::Field::DATETIME;
   case DRIZZLE_TYPE_DATE:
-    return message::Table::Field::DATE;
+    return Table::Field::DATE;
   case DRIZZLE_TYPE_VARCHAR:
-    return message::Table::Field::VARCHAR;
+    return Table::Field::VARCHAR;
   case DRIZZLE_TYPE_DECIMAL:
-    return message::Table::Field::DECIMAL;
+    return Table::Field::DECIMAL;
   case DRIZZLE_TYPE_ENUM:
-    return message::Table::Field::ENUM;
+    return Table::Field::ENUM;
   case DRIZZLE_TYPE_BLOB:
-    return message::Table::Field::BLOB;
+    return Table::Field::BLOB;
   }
 
   assert(false);
-  return message::Table::Field::INTEGER; /* unreachable */
+  return Table::Field::INTEGER; /* unreachable */
 }
 
+} /* namespace message */
 } /* namespace drizzled */

=== modified file 'drizzled/message/statement_transform.h'
--- drizzled/message/statement_transform.h	2010-02-08 01:10:03 +0000
+++ drizzled/message/statement_transform.h	2010-03-02 21:04:16 +0000
@@ -2,10 +2,11 @@
  *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
  *
  *  Copyright (C) 2009 Sun Microsystems
+ *  Copyright (c) 2010 Jay Pipes <[e-mail]>
  *
  *  Authors:
  *
- *    Jay Pipes <[e-mail]>
+ *    Jay Pipes <[e-mail]>
  *
  *  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
@@ -52,7 +53,11 @@
 class DeleteHeader;
 class DeleteData;
 class DeleteRecord;
+class DropTableStatement;
+class CreateTableStatement;
 class TruncateTableStatement;
+class CreateSchemaStatement;
+class DropSchemaStatement;
 class SetVariableStatement;
 
 /** A Variation of SQL to be output during transformation */
@@ -117,7 +122,7 @@
 enum TransformSqlError
 transformInsertStatementToSql(const InsertHeader &header,
                               const InsertData &data,
-                              std::string *destination,
+                              std::string &destination,
                               enum TransformSqlVariant sql_variant= DRIZZLE);
 
 /**
@@ -138,7 +143,7 @@
 enum TransformSqlError
 transformInsertRecordToSql(const InsertHeader &header,
                            const InsertRecord &record,
-                           std::string *destination,
+                           std::string &destination,
                            enum TransformSqlVariant sql_variant= DRIZZLE);
 
 /**
@@ -156,7 +161,7 @@
  */
 enum TransformSqlError
 transformInsertHeaderToSql(const InsertHeader &header,
-                           std::string *destination,
+                           std::string &destination,
                            enum TransformSqlVariant sql_variant= DRIZZLE);
 
 /**
@@ -174,7 +179,7 @@
  */
 enum TransformSqlError
 transformUpdateHeaderToSql(const UpdateHeader &header,
-                           std::string *destination,
+                           std::string &destination,
                            enum TransformSqlVariant sql_variant= DRIZZLE);
 
 /**
@@ -195,7 +200,7 @@
 enum TransformSqlError
 transformUpdateRecordToSql(const UpdateHeader &header,
                            const UpdateRecord &record,
-                           std::string *destination,
+                           std::string &destination,
                            enum TransformSqlVariant sql_variant= DRIZZLE);
 
 /**
@@ -221,7 +226,7 @@
 enum TransformSqlError
 transformDeleteStatementToSql(const DeleteHeader &header,
                               const DeleteData &data,
-                              std::string *destination,
+                              std::string &destination,
                               enum TransformSqlVariant sql_variant= DRIZZLE);
 
 /**
@@ -242,7 +247,7 @@
 enum TransformSqlError
 transformDeleteRecordToSql(const DeleteHeader &header,
                            const DeleteRecord &record,
-                           std::string *destination,
+                           std::string &destination,
                            enum TransformSqlVariant sql_variant= DRIZZLE);
 
 /**
@@ -260,10 +265,29 @@
  */
 enum TransformSqlError
 transformDeleteHeaderToSql(const DeleteHeader &header,
-                           std::string *destination,
+                           std::string &destination,
                            enum TransformSqlVariant sql_variant= DRIZZLE);
 
 /**
+ * This function looks at a supplied DropTableStatement
+ * and constructs a correctly-formatted SQL
+ * statement to the supplied destination string.
+ *
+ * @param DropTableStatement message to transform
+ * @param Destination string to append SQL to
+ * @param Variation of SQL to generate
+ *
+ * @retval
+ *  NONE if successful transformation
+ * @retval
+ *  Error code (see enum TransformSqlError definition) if failure
+ */
+enum TransformSqlError
+transformDropTableStatementToSql(const DropTableStatement &statement,
+                                  std::string &destination,
+                                  enum TransformSqlVariant sql_variant= DRIZZLE);
+
+/**
  * This function looks at a supplied TruncateTableStatement
  * and constructs a correctly-formatted SQL
  * statement to the supplied destination string.
@@ -279,10 +303,48 @@
  */
 enum TransformSqlError
 transformTruncateTableStatementToSql(const TruncateTableStatement &statement,
-                                     std::string *destination,
+                                     std::string &destination,
                                      enum TransformSqlVariant sql_variant= DRIZZLE);
 
 /**
+ * This function looks at a supplied CreateSchemaStatement
+ * and constructs a correctly-formatted SQL
+ * statement to the supplied destination string.
+ *
+ * @param CreateSchemaStatement message to transform
+ * @param Destination string to append SQL to
+ * @param Variation of SQL to generate
+ *
+ * @retval
+ *  NONE if successful transformation
+ * @retval
+ *  Error code (see enum TransformSqlError definition) if failure
+ */
+enum TransformSqlError
+transformCreateSchemaStatementToSql(const CreateSchemaStatement &statement,
+                                    std::string &destination,
+                                    enum TransformSqlVariant sql_variant= DRIZZLE);
+
+/**
+ * This function looks at a supplied DropSchemaStatement
+ * and constructs a correctly-formatted SQL
+ * statement to the supplied destination string.
+ *
+ * @param DropSchemaStatement message to transform
+ * @param Destination string to append SQL to
+ * @param Variation of SQL to generate
+ *
+ * @retval
+ *  NONE if successful transformation
+ * @retval
+ *  Error code (see enum TransformSqlError definition) if failure
+ */
+enum TransformSqlError
+transformDropSchemaStatementToSql(const DropSchemaStatement &statement,
+                                  std::string &destination,
+                                  enum TransformSqlVariant sql_variant= DRIZZLE);
+
+/**
  * This function looks at a supplied SetVariableStatement
  * and constructs a correctly-formatted SQL
  * statement to the supplied destination string.
@@ -298,9 +360,95 @@
  */
 enum TransformSqlError
 transformSetVariableStatementToSql(const SetVariableStatement &statement,
-                                   std::string *destination,
-                                   enum TransformSqlVariant sql_variant= DRIZZLE);
-
+                                   std::string &destination,
+                                   enum TransformSqlVariant sql_variant= DRIZZLE);
+
+/**
+ * Appends to supplied string an SQL expression
+ * containing the supplied CreateTableStatement's
+ * appropriate CREATE TABLE SQL statement.
+ */
+enum TransformSqlError
+transformCreateTableStatementToSql(const CreateTableStatement &statement,
+                                   std::string &destination,
+                                   enum TransformSqlVariant sql_variant= DRIZZLE);
+
+/**
+ * Appends to the supplied string an SQL expression
+ * representing the table for a CREATE TABLE expression.
+ *
+ * @param[in]   Table message
+ * @param[out]  String to append to
+ *
+ * @retval
+ *  NONE if successful transformation
+ * @retval
+ *  Error code (see enum TransformSqlError definition) if failure
+ */
+enum TransformSqlError
+transformTableDefinitionToSql(const Table &table,
+                              std::string &destination,
+                              enum TransformSqlVariant sql_variant= DRIZZLE);
+
+/**
+ * Appends to the supplied string an SQL expression
+ * representing the table's optional attributes.
+ *
+ * @note
+ *
+ * This function will eventually be a much simpler
+ * listing of key/value pairs.
+ *
+ * @param[in]   TableOptions message
+ * @param[out]  String to append to
+ *
+ * @retval
+ *  NONE if successful transformation
+ * @retval
+ *  Error code (see enum TransformSqlError definition) if failure
+ */
+enum TransformSqlError
+transformTableOptionsToSql(const Table::TableOptions &table_options,
+                           std::string &destination,
+                           enum TransformSqlVariant sql_variant= DRIZZLE);
+
+/**
+ * Appends to the supplied string an SQL expression
+ * representing the index's attributes.  The built string
+ * corresponds to the SQL in a CREATE INDEX statement.
+ *
+ * @param[in]   Index message
+ * @param[in]   Table containing this index (used to get field names...)
+ * @param[out]  String to append to
+ *
+ * @retval
+ *  NONE if successful transformation
+ * @retval
+ *  Error code (see enum TransformSqlError definition) if failure
+ */
+enum TransformSqlError
+transformIndexDefinitionToSql(const Table::Index &index,
+                              const Table &table,
+                              std::string &destination,
+                              enum TransformSqlVariant sql_variant= DRIZZLE);
+
+/**
+ * Appends to the supplied string an SQL expression
+ * representing the field's attributes.  The built string
+ * corresponds to the SQL in a CREATE TABLE statement.
+ *
+ * @param[in]   Field message
+ * @param[out]  String to append to
+ *
+ * @retval
+ *  NONE if successful transformation
+ * @retval
+ *  Error code (see enum TransformSqlError definition) if failure
+ */
+enum TransformSqlError
+transformFieldDefinitionToSql(const Table::Field &field,
+                              std::string &destination,
+                              enum TransformSqlVariant sql_variant= DRIZZLE);
 
 /**
  * Returns true if the supplied message::Table::Field::FieldType

=== modified file 'drizzled/message/table.proto'
--- drizzled/message/table.proto	2010-02-16 01:28:56 +0000
+++ drizzled/message/table.proto	2010-03-02 21:04:16 +0000
@@ -157,7 +157,7 @@
 
     message IndexPart {
       required uint32 fieldnr = 1;
-      optional int32 compare_length = 2;
+      optional uint32 compare_length = 2;
       optional bool in_reverse_order = 3 [default = false];
 
       optional uint32 key_type = 101; /* THIS MUST DIE. Along with pack_flag*/

=== modified file 'drizzled/message/table_reader.cc'
--- drizzled/message/table_reader.cc	2010-02-16 01:28:56 +0000
+++ drizzled/message/table_reader.cc	2010-03-02 21:04:16 +0000
@@ -30,7 +30,7 @@
 
 #include <iostream>
 #include <string>
-#include <drizzled/message/table.pb.h>
+#include <drizzled/message/statement_transform.h>
 #include <google/protobuf/io/zero_copy_stream.h>
 #include <google/protobuf/io/zero_copy_stream_impl.h>
 
@@ -42,246 +42,6 @@
   Written from Google proto example
 */
 
-static void print_field(const message::Table::Field &field)
-{
-  cout << "\t`" << field.name() << "`";
-
-  message::Table::Field::FieldType field_type= field.type();
-
-  switch (field_type)
-  {
-    case message::Table::Field::DOUBLE:
-    cout << " DOUBLE ";
-    break;
-  case message::Table::Field::VARCHAR:
-    cout << " VARCHAR(" << field.string_options().length() << ")";
-    break;
-  case message::Table::Field::BLOB:
-    cout << " BLOB "; /* FIXME: or text, depends on collation */
-    if(field.string_options().has_collation_id())
-      cout << "COLLATION=" << field.string_options().collation_id() << " ";
-    break;
-  case message::Table::Field::ENUM:
-    {
-      int x;
-
-      cout << " ENUM(";
-      for (x= 0; x < field.set_options().field_value_size() ; x++)
-      {
-        const string type= field.set_options().field_value(x);
-
-        if (x != 0)
-          cout << ",";
-        cout << "'" << type << "'";
-      }
-      cout << ") ";
-      break;
-    }
-  case message::Table::Field::INTEGER:
-    cout << " INT" ;
-    break;
-  case message::Table::Field::BIGINT:
-    cout << " BIGINT ";
-    break;
-  case message::Table::Field::DECIMAL:
-    cout << " DECIMAL(" << field.numeric_options().precision() << "," << field.numeric_options().scale() << ") ";
-    break;
-  case message::Table::Field::DATE:
-    cout << " DATE ";
-    break;
-  case message::Table::Field::TIMESTAMP:
-    cout << " TIMESTAMP ";
-    break;
-  case message::Table::Field::DATETIME:
-    cout << " DATETIME ";
-    break;
-  }
-
-  if (field.type() == message::Table::Field::INTEGER
-      || field.type() == message::Table::Field::BIGINT)
-  {
-    if (field.has_constraints()
-        && field.constraints().has_is_unsigned())
-      if (field.constraints().is_unsigned())
-        cout << " UNSIGNED";
-
-    if (field.has_numeric_options() &&
-      field.numeric_options().is_autoincrement())
-      cout << " AUTOINCREMENT ";
-  }
-
-  if (!( field.has_constraints()
-	 && field.constraints().is_nullable()))
-    cout << " NOT NULL ";
-
-  if (field.type() == message::Table::Field::BLOB
-      || field.type() == message::Table::Field::VARCHAR)
-  {
-    if (field.string_options().has_collation())
-      cout << " COLLATE " << field.string_options().collation();
-  }
-
-  if (field.options().has_default_value())
-    cout << " DEFAULT `" << field.options().default_value() << "` " ;
-
-  if (field.options().has_default_bin_value())
-  {
-    string v= field.options().default_bin_value();
-    cout << " DEFAULT 0x";
-    for(unsigned int i=0; i< v.length(); i++)
-    {
-      printf("%.2x", *(v.c_str()+i));
-    }
-  }
-
-  if (field.type() == message::Table::Field::TIMESTAMP)
-    if (field.timestamp_options().has_auto_updates()
-      && field.timestamp_options().auto_updates())
-      cout << " ON UPDATE CURRENT_TIMESTAMP";
-
-  if (field.has_comment())
-    cout << " COMMENT `" << field.comment() << "` ";
-}
-
-static void print_engine(const message::Table::StorageEngine &engine)
-{
-  int32_t x;
-
-  cout << " ENGINE = " << engine.name()  << endl;
-
-  for (x= 0; x < engine.option_size(); ++x) {
-    const message::Table::StorageEngine::EngineOption option= engine.option(x);
-    cout << "\t" << option.option_name() << " = "
-	 << option.option_value() << endl;
-  }
-}
-
-static void print_index(const message::Table::Index &index)
-{
-
-  if (index.is_primary())
-    cout << " PRIMARY";
-  else if (index.is_unique())
-    cout << " UNIQUE";
-  cout << " KEY `" << index.name() << "` (";
-  {
-    int32_t x;
-
-    for (x= 0; x < index.index_part_size() ; x++)
-    {
-      const message::Table::Index::IndexPart part= index.index_part(x);
-
-      if (x != 0)
-        cout << ",";
-      cout << "`" << part.fieldnr() << "`"; /* FIXME */
-      if (part.has_compare_length())
-        cout << "(" << part.compare_length() << ")";
-    }
-    cout << ")";
-  }
-  cout << "\t";
-}
-
-static void print_table_options(const message::Table::TableOptions &options)
-{
-  if (options.has_comment())
-    cout << " COMMENT = '" << options.comment() << "' " << endl;
-
-  if (options.has_collation())
-    cout << " COLLATE = '" << options.collation() << "' " << endl;
-
-  if (options.has_auto_increment())
-    cout << " AUTOINCREMENT_OFFSET = " << options.auto_increment() << endl;
-
-  if (options.has_collation_id())
-    cout << "-- collation_id = " << options.collation_id() << endl;
-  
-  if (options.has_row_type())
-    cout << " ROW_TYPE = " << options.row_type() << endl;
-
-  if (options.has_data_file_name())
-    cout << " DATA_FILE_NAME = '" << options.data_file_name() << "'" << endl;
-
-  if (options.has_index_file_name())
-    cout << " INDEX_FILE_NAME = '" << options.index_file_name() << "'" << endl;
-
-  if (options.has_max_rows())
-    cout << " MAX_ROWS = " << options.max_rows() << endl;
-
-  if (options.has_min_rows())
-    cout << " MIN_ROWS = " << options.min_rows() << endl;
-
-  if (options.has_auto_increment_value())
-    cout << " AUTO_INCREMENT = " << options.auto_increment_value() << endl;
-
-  if (options.has_avg_row_length())
-    cout << " AVG_ROW_LENGTH = " << options.avg_row_length() << endl;
-
-  if (options.has_key_block_size())
-    cout << " KEY_BLOCK_SIZE = "  << options.key_block_size() << endl;
-
-  if (options.has_block_size())
-    cout << " BLOCK_SIZE = " << options.block_size() << endl;
-
-  if (options.has_comment())
-    cout << " COMMENT = '" << options.comment() << "'" << endl;
-
-  if (options.has_pack_keys())
-    cout << " PACK_KEYS = " << options.pack_keys() << endl;
-  if (options.has_pack_record())
-    cout << " PACK_RECORD = " << options.pack_record() << endl;
-  if (options.has_checksum())
-    cout << " CHECKSUM = " << options.checksum() << endl;
-  if (options.has_page_checksum())
-    cout << " PAGE_CHECKSUM = " << options.page_checksum() << endl;
-}
-
-
-static void print_table(const message::Table &table)
-{
-  int32_t x;
-
-  cout << "CREATE ";
-
-  if (table.type() == message::Table::TEMPORARY)
-    cout << "TEMPORARY ";
-
-  cout << "TABLE `" << table.name() << "` (" << endl;
-
-  for (x= 0; x < table.field_size() ; x++)
-  {
-    const message::Table::Field field = table.field(x);
-
-    if (x != 0)
-      cout << "," << endl;
-
-    print_field(field);
-  }
-
-  for (x= 0; x < table.indexes_size() ; x++)
-  {
-    const message::Table::Index index= table.indexes(x);
-
-    if (x != 0)
-      cout << "," << endl;;
-
-    print_index(index);
-
-  }
-  cout << endl;
-
-  cout << ") " << endl;
-
-  print_engine(table.engine());
-
-  if (table.has_options())
-    print_table_options(table.options());
-  /*
-  if (table->has_stats())
-    print_table_stats(&table->stats());
-  */
-}
-
 int main(int argc, char* argv[])
 {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
@@ -315,7 +75,10 @@
     close(fd);
   }
 
-  print_table(table);
+  string output;
+  (void) message::transformTableDefinitionToSql(table, output);
+
+  cout << output << endl;
 
   return 0;
 }

=== modified file 'drizzled/message/transaction.proto'
--- drizzled/message/transaction.proto	2009-11-03 18:49:13 +0000
+++ drizzled/message/transaction.proto	2010-03-02 21:04:16 +0000
@@ -499,6 +499,7 @@
 message DropTableStatement
 {
   required TableMetadata table_metadata = 1; /* Minimal metadata about the table to be dropped */
+  optional bool if_exists_clause = 2; /* Did the user specify an IF EXISTS clause? */
 }
 
 /*

=== modified file 'drizzled/replication_services.cc'
--- drizzled/replication_services.cc	2010-02-11 03:49:10 +0000
+++ drizzled/replication_services.cc	2010-03-02 21:04:16 +0000
@@ -508,7 +508,7 @@
      * We add the "key field metadata" -- i.e. the fields which is
      * the primary key for the table.
      */
-    if (in_table->s->primary_key == current_field->field_index)
+    if (in_table->s->fieldInPrimaryKey(current_field))
     {
       field_metadata= header->add_key_field_metadata();
       field_metadata->set_name(current_field->field_name);
@@ -602,7 +602,7 @@
      * primary key field value.  Replication only supports tables
      * with a primary key.
      */
-    if (in_table->s->primary_key == current_field->field_index)
+    if (in_table->s->fieldInPrimaryKey(current_field))
     {
       /**
        * To say the below is ugly is an understatement. But it works.
@@ -682,7 +682,7 @@
      * primary key field value.  Replication only supports tables
      * with a primary key.
      */
-    if (in_table->s->primary_key == current_field->field_index)
+    if (in_table->s->fieldInPrimaryKey(current_field))
     {
       field_metadata= header->add_key_field_metadata();
       field_metadata->set_name(current_field->field_name);
@@ -715,7 +715,7 @@
      * primary key field value.  Replication only supports tables
      * with a primary key.
      */
-    if (in_table->s->primary_key == current_field->field_index)
+    if (in_table->s->fieldInPrimaryKey(current_field))
     {
       string_value= current_field->val_str(string_value);
       record->add_key_value(string_value->c_ptr(), string_value->length());
@@ -727,6 +727,126 @@
   }
 }
 
+void ReplicationServices::createTable(Session *in_session,
+                                      const message::Table &table)
+{
+  if (! is_active)
+    return;
+  
+  message::Transaction *transaction= getActiveTransaction(in_session);
+  message::Statement *statement= transaction->add_statement();
+
+  initStatement(*statement, message::Statement::CREATE_TABLE, in_session);
+
+  /* 
+   * Construct the specialized CreateTableStatement message and attach
+   * it to the generic Statement message
+   */
+  message::CreateTableStatement *create_table_statement= statement->mutable_create_table_statement();
+  message::Table *new_table_message= create_table_statement->mutable_table();
+  *new_table_message= table;
+
+  finalizeStatement(*statement, in_session);
+
+  finalizeTransaction(*transaction, in_session);
+  
+  push(*transaction);
+
+  cleanupTransaction(transaction, in_session);
+
+}
+
+void ReplicationServices::createSchema(Session *in_session,
+                                       const message::Schema &schema)
+{
+  if (! is_active)
+    return;
+  
+  message::Transaction *transaction= getActiveTransaction(in_session);
+  message::Statement *statement= transaction->add_statement();
+
+  initStatement(*statement, message::Statement::CREATE_SCHEMA, in_session);
+
+  /* 
+   * Construct the specialized CreateSchemaStatement message and attach
+   * it to the generic Statement message
+   */
+  message::CreateSchemaStatement *create_schema_statement= statement->mutable_create_schema_statement();
+  message::Schema *new_schema_message= create_schema_statement->mutable_schema();
+  *new_schema_message= schema;
+
+  finalizeStatement(*statement, in_session);
+
+  finalizeTransaction(*transaction, in_session);
+  
+  push(*transaction);
+
+  cleanupTransaction(transaction, in_session);
+
+}
+
+void ReplicationServices::dropSchema(Session *in_session, const string &schema_name)
+{
+  if (! is_active)
+    return;
+  
+  message::Transaction *transaction= getActiveTransaction(in_session);
+  message::Statement *statement= transaction->add_statement();
+
+  initStatement(*statement, message::Statement::DROP_SCHEMA, in_session);
+
+  /* 
+   * Construct the specialized DropSchemaStatement message and attach
+   * it to the generic Statement message
+   */
+  message::DropSchemaStatement *drop_schema_statement= statement->mutable_drop_schema_statement();
+
+  drop_schema_statement->set_schema_name(schema_name);
+
+  finalizeStatement(*statement, in_session);
+
+  finalizeTransaction(*transaction, in_session);
+  
+  push(*transaction);
+
+  cleanupTransaction(transaction, in_session);
+}
+
+void ReplicationServices::dropTable(Session *in_session,
+                                    const string &schema_name,
+                                    const string &table_name,
+                                    bool if_exists)
+{
+  if (! is_active)
+    return;
+  
+  message::Transaction *transaction= getActiveTransaction(in_session);
+  message::Statement *statement= transaction->add_statement();
+
+  initStatement(*statement, message::Statement::DROP_TABLE, in_session);
+
+  /* 
+   * Construct the specialized DropTableStatement message and attach
+   * it to the generic Statement message
+   */
+  message::DropTableStatement *drop_table_statement= statement->mutable_drop_table_statement();
+
+  drop_table_statement->set_if_exists_clause(if_exists);
+
+  message::TableMetadata *table_metadata= drop_table_statement->mutable_table_metadata();
+
+  table_metadata->set_schema_name(schema_name);
+  table_metadata->set_table_name(table_name);
+
+  finalizeStatement(*statement, in_session);
+
+  finalizeTransaction(*transaction, in_session);
+  
+  push(*transaction);
+
+  cleanupTransaction(transaction, in_session);
+}
+
 void ReplicationServices::truncateTable(Session *in_session, Table *in_table)
 {
   if (! is_active)

=== modified file 'drizzled/replication_services.h'
--- drizzled/replication_services.h	2010-02-11 03:29:52 +0000
+++ drizzled/replication_services.h	2010-03-02 21:04:16 +0000
@@ -2,10 +2,11 @@
  *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
  *
  *  Copyright (C) 2008-2009 Sun Microsystems
+ *  Copyright (c) 2009-2010 Jay Pipes <[e-mail]>
  *
  *  Authors:
  *
- *    Jay Pipes <[e-mail]>
+ *    Jay Pipes <[e-mail]>
  *
  *  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
@@ -30,7 +31,6 @@
 
 #include <vector>
 
-
 namespace drizzled
 {
 
@@ -323,7 +323,48 @@
    */
   void deleteRecord(Session *in_session, Table *in_table);
   /**
-   * Creates a TruncateTable Statement GPB message and add it
+   * Creates a CreateSchema Statement GPB message and adds it
+   * to the Session's active Transaction GPB message for pushing
+   * out to the replicator streams.
+   *
+   * @param[in] Pointer to the Session which issued the statement
+   * @param[in] message::Schema message describing new schema
+   */
+  void createSchema(Session *in_session, const message::Schema &schema);
+  /**
+   * Creates a DropSchema Statement GPB message and adds it
+   * to the Session's active Transaction GPB message for pushing
+   * out to the replicator streams.
+   *
+   * @param[in] Pointer to the Session which issued the statement
+   * @param[in] message::Schema message describing new schema
+   */
+  void dropSchema(Session *in_session, const std::string &schema_name);
+  /**
+   * Creates a CreateTable Statement GPB message and adds it
+   * to the Session's active Transaction GPB message for pushing
+   * out to the replicator streams.
+   *
+   * @param[in] Pointer to the Session which issued the statement
+   * @param[in] message::Table message describing new schema
+   */
+  void createTable(Session *in_session, const message::Table &table);
+  /**
+   * Creates a DropTable Statement GPB message and adds it
+   * to the Session's active Transaction GPB message for pushing
+   * out to the replicator streams.
+   *
+   * @param[in] Pointer to the Session which issued the statement
+   * @param[in] The schema of the table being dropped
+   * @param[in] The table name of the table being dropped
+   * @param[in] Did the user specify an IF EXISTS clause?
+   */
+  void dropTable(Session *in_session,
+                     const std::string &schema_name,
+                     const std::string &table_name,
+                     bool if_exists);
+  /**
+   * Creates a TruncateTable Statement GPB message and adds it
    * to the Session's active Transaction GPB message for pushing
    * out to the replicator streams.
    *

=== modified file 'drizzled/sql_insert.cc'
--- drizzled/sql_insert.cc	2010-02-14 20:26:43 +0000
+++ drizzled/sql_insert.cc	2010-03-02 21:04:16 +0000
@@ -1615,32 +1615,17 @@
 
   DRIZZLE_LOCK *extra_lock= NULL;
   /*
-    For row-based replication, the CREATE-SELECT statement is written
-    in two pieces: the first one contain the CREATE TABLE statement
-    necessary to create the table and the second part contain the rows
-    that should go into the table.
-
-    For non-temporary tables, the start of the CREATE-SELECT
-    implicitly commits the previous transaction, and all events
-    forming the statement will be stored the transaction cache. At end
-    of the statement, the entire statement is committed as a
-    transaction, and all events are written to the binary log.
-
-    On the master, the table is locked for the duration of the
-    statement, but since the CREATE part is replicated as a simple
-    statement, there is no way to lock the table for accesses on the
-    slave.  Hence, we have to hold on to the CREATE part of the
-    statement until the statement has finished.
+    For replication, the CREATE-SELECT statement is written
+    in two pieces: the first transaction messsage contains 
+    the CREATE TABLE statement as a CreateTableStatement message
+    necessary to create the table.
+    
+    The second transaction message contains all the InsertStatement
+    and associated InsertRecords that should go into the table.
    */
 
   unit= u;
 
-  /*
-    Start a statement transaction before the create if we are using
-    row-based replication for the statement.  If we are creating a
-    temporary table, we need to start a statement transaction.
-  */
-
   if (!(table= create_table_from_items(session, create_info, create_table,
 				       table_proto,
                                        alter_info, &values,

=== modified file 'drizzled/sql_table.cc'
--- drizzled/sql_table.cc	2010-03-02 02:17:49 +0000
+++ drizzled/sql_table.cc	2010-03-02 21:04:16 +0000
@@ -54,6 +54,7 @@
 namespace drizzled
 {
 
+extern plugin::StorageEngine *myisam_engine;
 extern pid_t current_pid;
 
 bool is_primary_key(KEY *key_info)
@@ -249,7 +250,7 @@
 
       if ((error == ENOENT || error == HA_ERR_NO_SUCH_TABLE) && if_exists)
       {
-	error= 0;
+        error= 0;
         session->clear_error();
       }
 
@@ -261,7 +262,10 @@
     }
 
     if (error == 0 || (if_exists && foreign_key_error == false))
-        write_bin_log_drop_table(session, if_exists, db, table->table_name);
+    {
+      ReplicationServices &replication_services= ReplicationServices::singleton();
+      replication_services.dropTable(session, string(db), string(table->table_name), if_exists);
+    }
 
     if (error)
     {
@@ -757,9 +761,11 @@
 	}
       }
     }
-    /* Don't pack rows in old tables if the user has requested this */
-    if ((sql_field->flags & BLOB_FLAG) ||
-	(sql_field->sql_type == DRIZZLE_TYPE_VARCHAR && create_info->row_type != ROW_TYPE_FIXED))
+
+    /** @todo Get rid of this MyISAM-specific crap. */
+    if (create_info->db_type == myisam_engine &&
+        ((sql_field->flags & BLOB_FLAG) ||
+         (sql_field->sql_type == DRIZZLE_TYPE_VARCHAR && create_info->row_type != ROW_TYPE_FIXED)))
       (*db_options)|= HA_OPTION_PACK_RECORD;
     it2.rewind();
   }
@@ -1451,15 +1457,11 @@
     }
   }
 
-  /*
-    Don't write statement if:
-    - It is an internal temporary table,
-    - Row-based logging is used and it we are creating a temporary table, or
-    - The binary log is not open.
-    Otherwise, the statement shall be binlogged.
-   */
   if (not internal_tmp_table && not lex_identified_temp_table)
-    write_bin_log(session, session->query.c_str());
+  {
+    ReplicationServices &replication_services= ReplicationServices::singleton();
+    replication_services.createTable(session, *table_proto);
+  }
   error= false;
 unlock_and_end:
   pthread_mutex_unlock(&LOCK_open);

=== modified file 'drizzled/table_proto_write.cc'
--- drizzled/table_proto_write.cc	2010-02-24 00:18:38 +0000
+++ drizzled/table_proto_write.cc	2010-03-02 21:04:16 +0000
@@ -309,7 +309,7 @@
   switch(create_info->row_type)
   {
   case ROW_TYPE_DEFAULT:
-    table_options->set_row_type(message::Table::TableOptions::ROW_TYPE_DEFAULT);
+    /* No use setting a default row type... just adds redundant info to message */
     break;
   case ROW_TYPE_FIXED:
     table_options->set_row_type(message::Table::TableOptions::ROW_TYPE_FIXED);
@@ -333,8 +333,8 @@
     abort();
   }
 
-  table_options->set_pack_record(create_info->table_options
-				 & HA_OPTION_PACK_RECORD);
+  if (create_info->table_options & HA_OPTION_PACK_RECORD)
+    table_options->set_pack_record(true);
 
   if (table_options->has_comment())
   {
@@ -447,7 +447,10 @@
 
       idx->set_comment(key_info[i].comment.str);
     }
-    if(key_info[i].flags & ~(HA_NOSAME | HA_PACK_KEY | HA_USES_BLOCK_SIZE | HA_BINARY_PACK_KEY | HA_VAR_LENGTH_PART | HA_NULL_PART_KEY | HA_KEY_HAS_PART_KEY_SEG | HA_GENERATED_KEY | HA_USES_COMMENT))
+    if (key_info[i].flags & 
+        ~(HA_NOSAME | HA_PACK_KEY | HA_USES_BLOCK_SIZE | 
+          HA_BINARY_PACK_KEY | HA_VAR_LENGTH_PART | HA_NULL_PART_KEY | 
+          HA_KEY_HAS_PART_KEY_SEG | HA_GENERATED_KEY | HA_USES_COMMENT))
       abort(); // Invalid (unknown) index flag.
 
     for(unsigned int j=0; j< key_info[i].key_parts; j++)

=== modified file 'drizzled/table_share.cc'
--- drizzled/table_share.cc	2010-02-04 08:14:46 +0000
+++ drizzled/table_share.cc	2010-03-02 21:04:16 +0000
@@ -273,4 +273,31 @@
   }
 }
 
+/**
+ * @todo
+ *
+ * Precache this stuff....
+ */
+bool TableShare::fieldInPrimaryKey(Field *in_field) const
+{
+  assert(table_proto != NULL);
+  
+  size_t num_indexes= table_proto->indexes_size();
+
+  for (size_t x= 0; x < num_indexes; ++x)
+  {
+    const message::Table::Index &index= table_proto->indexes(x);
+    if (index.is_primary())
+    {
+      size_t num_parts= index.index_part_size();
+      for (size_t y= 0; y < num_parts; ++y)
+      {
+        if (index.index_part(y).fieldnr() == in_field->field_index)
+          return true;
+      }
+    }
+  }
+  return false;
+}
+
 } /* namespace drizzled */

=== modified file 'drizzled/table_share.h'
--- drizzled/table_share.h	2010-02-23 01:14:53 +0000
+++ drizzled/table_share.h	2010-03-02 21:04:16 +0000
@@ -260,6 +260,12 @@
     max_rows= arg;
   }
 
+  /**
+   * Returns true if the supplied Field object
+   * is part of the table's primary key.
+   */
+  bool fieldInPrimaryKey(Field *field) const;
+
   plugin::StorageEngine *storage_engine;			/* storage engine plugin */
   inline plugin::StorageEngine *db_type() const	/* table_type for handler */
   {

=== modified file 'plugin/transaction_log/tests/r/alter.result'
--- plugin/transaction_log/tests/r/alter.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/alter.result	2010-03-02 21:04:16 +0000
@@ -10,10 +10,10 @@
 ALTER TABLE t1 ADD INDEX ix_padding (padding(20));
 DROP TABLE t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -28,6 +28,6 @@
 ALTER TABLE t1 ADD INDEX ix_padding (padding(20));
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/auto_commit.result'
--- plugin/transaction_log/tests/r/auto_commit.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/auto_commit.result	2010-03-02 21:04:16 +0000
@@ -16,28 +16,28 @@
 INSERT INTO t1 VALUES (2, "I hate testing.");
 DROP TABLE t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
-COMMIT;
-START TRANSACTION;
-INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
-INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I hate testing.');
-COMMIT;
-START TRANSACTION;
-DROP TABLE `t1`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
-COMMIT;
-START TRANSACTION;
-INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
-COMMIT;
-START TRANSACTION;
-INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I hate testing.');
-COMMIT;
-START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
+INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I hate testing.');
+COMMIT;
+START TRANSACTION;
+DROP TABLE `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I hate testing.');
+COMMIT;
+START TRANSACTION;
+DROP TABLE `test`.`t1`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/blob.result'
--- plugin/transaction_log/tests/r/blob.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/blob.result	2010-03-02 21:04:16 +0000
@@ -10,10 +10,10 @@
 DELETE FROM t1 WHERE padding = 'test\0you';
 DROP TABLE t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding BLOB NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` BLOB NOT NULL COLLATE binary, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'test\0me');
@@ -29,6 +29,6 @@
 DELETE FROM `test`.`t1` WHERE `id`=2;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== added file 'plugin/transaction_log/tests/r/create_schema.result'
--- plugin/transaction_log/tests/r/create_schema.result	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/r/create_schema.result	2010-03-02 21:04:16 +0000
@@ -0,0 +1,13 @@
+DROP SCHEMA IF EXISTS my_new_schema;
+CREATE SCHEMA my_new_warnings;
+DROP SCHEMA my_new_warnings;
+START TRANSACTION;
+DROP SCHEMA IF EXISTS my_new_schema;
+COMMIT;
+START TRANSACTION;
+CREATE SCHEMA `my_new_warnings` COLLATE utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+DROP SCHEMA my_new_warnings;
+COMMIT;
+SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/create_select.result'
--- plugin/transaction_log/tests/r/create_select.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/create_select.result	2010-03-02 21:04:16 +0000
@@ -12,13 +12,13 @@
 ) SELECT * FROM t1;
 DROP TABLE t1, t2;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-DROP TABLE IF EXISTS `t2`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+DROP TABLE IF EXISTS `test`.`t2`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -27,12 +27,16 @@
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I hate testing.');
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t2 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL ) SELECT * FROM t1;
-COMMIT;
-START TRANSACTION;
-DROP TABLE `t1`;
-COMMIT;
-START TRANSACTION;
-DROP TABLE `t2`;
+CREATE TABLE `t2` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t2` (`id`,`padding`) VALUES (1,'I love testing.');
+INSERT INTO `test`.`t2` (`id`,`padding`) VALUES (2,'I hate testing.');
+COMMIT;
+START TRANSACTION;
+DROP TABLE `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+DROP TABLE `test`.`t2`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== added file 'plugin/transaction_log/tests/r/create_table.result'
--- plugin/transaction_log/tests/r/create_table.result	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/r/create_table.result	2010-03-02 21:04:16 +0000
@@ -0,0 +1,54 @@
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 (
+autoinc_int_field INT NOT NULL AUTO_INCREMENT
+, null_int_field INT NULL
+, not_null_bigint_field BIGINT NOT NULL
+, null_bigint_field BIGINT NULL
+, not_null_int_field INT NOT NULL
+, null_varchar_field VARCHAR(100) NULL
+, not_null_varchar_field VARCHAR(100) NOT NULL
+, null_enum_field ENUM ('val1', 'val2') NULL
+, not_null_enum_field ENUM ('val1', 'val2') NOT NULL
+, null_date_field DATE NULL
+, not_null_date_field DATE NOT NULL
+, null_datetime_field DATETIME NULL
+, not_null_datetime_field DATETIME NOT NULL
+, null_blob_field BLOB NULL
+, not_null_blob_field BLOB NOT NULL
+, null_text_field TEXT NULL
+, not_null_text_field TEXT NOT NULL
+, null_timestamp_field TIMESTAMP NULL
+, not_null_timestamp_field TIMESTAMP NOT NULL
+, null_double_field DOUBLE NULL
+, not_null_double_field DOUBLE NOT NULL
+, null_decimal_field DECIMAL(10,2) NULL
+, not_null_decimal_field DECIMAL(10,2) NOT NULL
+, PRIMARY KEY (autoinc_int_field)
+);
+DROP TABLE t1;
+CREATE TABLE t1 (
+id INT NOT NULL AUTO_INCREMENT PRIMARY KEY
+, key1 VARCHAR(10) NOT NULL
+, key2 DOUBLE NOT NULL
+, key3 BLOB NOT NULL
+, UNIQUE KEY (key1)
+, KEY named_key (key2)
+, KEY partial_key (key3(30))
+);
+DROP TABLE t1;
+START TRANSACTION;
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `autoinc_int_field` INT NOT NULL AUTO_INCREMENT, `null_int_field` INT NULL, `not_null_bigint_field` BIGINT NOT NULL, `null_bigint_field` BIGINT NULL, `not_null_int_field` INT NOT NULL, `null_varchar_field` VARCHAR(100) NULL COLLATE utf8_general_ci, `not_null_varchar_field` VARCHAR(100) NOT NULL COLLATE utf8_general_ci, `null_enum_field` ENUM('val1','val2') NULL, `not_null_enum_field` ENUM('val1','val2') NOT NULL, `null_date_field` DATE NULL, `not_null_date_field` DATE NOT NULL, `null_datetime_field` DATETIME NULL, `not_null_datetime_field` DATETIME NOT NULL, `null_blob_field` BLOB NULL COLLATE binary, `not_null_blob_field` BLOB NOT NULL COLLATE binary, `null_text_field` BLOB NULL COLLATE utf8_general_ci, `not_null_text_field` BLOB NOT NULL COLLATE utf8_general_ci, `null_timestamp_field` TIMESTAMP NULL, `not_null_timestamp_field` TIMESTAMP NOT NULL, `null_double_field` DOUBLE NULL, `not_null_double_field` DOUBLE NOT NULL, `null_decimal_field` DECIMAL(10,2) NULL, `not_null_decimal_field` DECIMAL(10,2) NOT NULL, PRIMARY KEY `PRIMARY` (`autoinc_int_field`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+DROP TABLE `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL AUTO_INCREMENT, `key1` VARCHAR(10) NOT NULL COLLATE utf8_general_ci, `key2` DOUBLE NOT NULL, `key3` BLOB NOT NULL COLLATE binary, PRIMARY KEY `PRIMARY` (`id`), UNIQUE KEY `key1` (`key1`), KEY `named_key` (`key2`), KEY `partial_key` (`key3`(30)) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+DROP TABLE `test`.`t1`;
+COMMIT;
+SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/database.result'
--- plugin/transaction_log/tests/r/database.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/database.result	2010-03-02 21:04:16 +0000
@@ -1,7 +1,7 @@
 CREATE DATABASE test1;
 DROP DATABASE test1;
 START TRANSACTION;
-CREATE DATABASE test1;
+CREATE SCHEMA `test1` COLLATE utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 DROP DATABASE test1;

=== modified file 'plugin/transaction_log/tests/r/delete.result'
--- plugin/transaction_log/tests/r/delete.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/delete.result	2010-03-02 21:04:16 +0000
@@ -37,10 +37,10 @@
 DROP TABLE t1;
 End Test of LP Bug #496101
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -52,10 +52,10 @@
 DELETE FROM `test`.`t1` WHERE `id`=1;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , other INT NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `other` INT NOT NULL, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`other`) VALUES (1,1);
@@ -92,10 +92,10 @@
 DELETE FROM `test`.`t1` WHERE `id`=8;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -103,6 +103,6 @@
 DELETE FROM `test`.`t1` WHERE `id`=1;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/filtered_replicator.result'
--- plugin/transaction_log/tests/r/filtered_replicator.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/filtered_replicator.result	2010-03-02 21:04:16 +0000
@@ -36,8 +36,9 @@
 ALTER TABLE t1 ADD dummy INT;
 ALTER TABLE t1 ADD INDEX ix_padding (padding(20));
 DROP TABLE t1;
-CREATE DATABASE test1;
-DROP DATABASE test1;
+DROP SCHEMA IF EXISTS my_new_schema;
+CREATE SCHEMA my_new_warnings;
+DROP SCHEMA my_new_warnings;
 DROP TABLE IF EXISTS t1, t2;
 CREATE TABLE t1 (
 id INT NOT NULL
@@ -121,47 +122,44 @@
 UPDATE t1 SET id = 4 WHERE id = 2;
 DROP TABLE t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
-COMMIT;
-START TRANSACTION;
-INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
-COMMIT;
-START TRANSACTION;
-INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I hate testing.');
-COMMIT;
-START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
-COMMIT;
-START TRANSACTION;
-INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
-INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I hate testing.');
-COMMIT;
-START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-DROP TABLE IF EXISTS `t2`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
-COMMIT;
-START TRANSACTION;
-INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
-COMMIT;
-START TRANSACTION;
-INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I hate testing.');
-COMMIT;
-START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I hate testing.');
+COMMIT;
+START TRANSACTION;
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
+INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I hate testing.');
+COMMIT;
+START TRANSACTION;
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I hate testing.');
+COMMIT;
+START TRANSACTION;
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -176,31 +174,31 @@
 ALTER TABLE t1 ADD INDEX ix_padding (padding(20));
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
-COMMIT;
-START TRANSACTION;
-CREATE DATABASE test1;
-COMMIT;
-START TRANSACTION;
-DROP DATABASE test1;
-COMMIT;
-START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-DROP TABLE IF EXISTS `t2`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+DROP TABLE `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+DROP SCHEMA `my_new_schema`;
+COMMIT;
+START TRANSACTION;
+CREATE SCHEMA `my_new_warnings` COLLATE utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+DROP SCHEMA `my_new_warnings`;
+COMMIT;
+START TRANSACTION;
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 RENAME TABLE t1 TO t2;
 COMMIT;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -212,10 +210,10 @@
 DELETE FROM `test`.`t1` WHERE `id`=1;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , other INT NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `other` INT NOT NULL, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`other`) VALUES (1,1);
@@ -252,10 +250,10 @@
 DELETE FROM `test`.`t1` WHERE `id`=8;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -263,13 +261,13 @@
 DELETE FROM `test`.`t1` WHERE `id`=1;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
-COMMIT;
-START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+DROP TABLE `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -285,10 +283,10 @@
 UPDATE `test`.`t1` SET `padding`='AAA' WHERE `id`=2;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id int AUTO_INCREMENT NOT NULL PRIMARY KEY , name varchar(1024) , alias varchar(1024) );
+CREATE TABLE `t1` ( `id` INT NOT NULL AUTO_INCREMENT, `name` VARCHAR(1024) NOT NULL COLLATE utf8_general_ci, `alias` VARCHAR(1024) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`name`,`alias`) VALUES (1,'jeff lebowski','dude');
@@ -297,10 +295,10 @@
 UPDATE `test`.`t1` SET `alias`='the dude' WHERE `id`=1;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , counter INT NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `counter` INT NOT NULL, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`counter`) VALUES (1,1);
@@ -315,10 +313,10 @@
 UPDATE `test`.`t1` SET `counter`=4 WHERE `id`=3;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -330,6 +328,6 @@
 UPDATE `test`.`t1` SET `id`=4 WHERE `id`=2;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/insert.result'
--- plugin/transaction_log/tests/r/insert.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/insert.result	2010-03-02 21:04:16 +0000
@@ -6,10 +6,10 @@
 INSERT INTO t1 VALUES (1, "I love testing.");
 INSERT INTO t1 VALUES (2, "I hate testing.");
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');

=== modified file 'plugin/transaction_log/tests/r/insert_multi.result'
--- plugin/transaction_log/tests/r/insert_multi.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/insert_multi.result	2010-03-02 21:04:16 +0000
@@ -5,10 +5,10 @@
 );
 INSERT INTO t1 VALUES (1, "I love testing."), (2, "I hate testing.");
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');

=== modified file 'plugin/transaction_log/tests/r/insert_on_duplicate_update.result'
--- plugin/transaction_log/tests/r/insert_on_duplicate_update.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/insert_on_duplicate_update.result	2010-03-02 21:04:16 +0000
@@ -9,10 +9,10 @@
 ON DUPLICATE KEY UPDATE padding="I love testing";
 DROP TABLE t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL AUTO_INCREMENT PRIMARY KEY , padding VARCHAR(200) NOT NULL );
+CREATE TABLE `t1` ( `id` INT NOT NULL AUTO_INCREMENT, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -24,6 +24,6 @@
 UPDATE `test`.`t1` SET `padding`='I love testing' WHERE `id`=2;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/insert_select.result'
--- plugin/transaction_log/tests/r/insert_select.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/insert_select.result	2010-03-02 21:04:16 +0000
@@ -12,13 +12,13 @@
 );
 INSERT INTO t2 SELECT * FROM t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-DROP TABLE IF EXISTS `t2`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+DROP TABLE IF EXISTS `test`.`t2`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -27,7 +27,7 @@
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I hate testing.');
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t2 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
+CREATE TABLE `t2` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t2` (`id`,`padding`) VALUES (1,'I love testing.');

=== added file 'plugin/transaction_log/tests/r/multi_column_primary_key.result'
--- plugin/transaction_log/tests/r/multi_column_primary_key.result	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/r/multi_column_primary_key.result	2010-03-02 21:04:16 +0000
@@ -0,0 +1,55 @@
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 (
+k1 INT NOT NULL
+, k2 INT NOT NULL
+, padding VARCHAR(200) NOT NULL
+, PRIMARY KEY (k1, k2)
+);
+INSERT INTO t1 VALUES (1, 1, "I love testing.");
+INSERT INTO t1 VALUES (2, 2, "I hate testing.");
+INSERT INTO t1 VALUES (2, 3, "I hate and love testing.");
+INSERT INTO t1 VALUES (3, 3, "I adore testing.");
+UPDATE t1 SET padding= "XXX" WHERE k1= 1 AND k2= 1;
+UPDATE t1 SET padding= "YYY" WHERE k1= 2;
+UPDATE t1 SET padding= "ZZZ" WHERE k2= 3;
+UPDATE t1 SET padding= "AAA";
+DROP TABLE t1;
+START TRANSACTION;
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `k1` INT NOT NULL, `k2` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`k1`,`k2`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t1` (`k1`,`k2`,`padding`) VALUES (1,1,'I love testing.');
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t1` (`k1`,`k2`,`padding`) VALUES (2,2,'I hate testing.');
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t1` (`k1`,`k2`,`padding`) VALUES (2,3,'I hate and love testing.');
+COMMIT;
+START TRANSACTION;
+INSERT INTO `test`.`t1` (`k1`,`k2`,`padding`) VALUES (3,3,'I adore testing.');
+COMMIT;
+START TRANSACTION;
+UPDATE `test`.`t1` SET `padding`='XXX' WHERE `k1`=1 AND `k2`=1;
+COMMIT;
+START TRANSACTION;
+UPDATE `test`.`t1` SET `padding`='YYY' WHERE `k1`=2 AND `k2`=2;
+UPDATE `test`.`t1` SET `padding`='YYY' WHERE `k1`=2 AND `k2`=3;
+COMMIT;
+START TRANSACTION;
+UPDATE `test`.`t1` SET `padding`='ZZZ' WHERE `k1`=2 AND `k2`=3;
+UPDATE `test`.`t1` SET `padding`='ZZZ' WHERE `k1`=3 AND `k2`=3;
+COMMIT;
+START TRANSACTION;
+UPDATE `test`.`t1` SET `padding`='AAA' WHERE `k1`=1 AND `k2`=1;
+UPDATE `test`.`t1` SET `padding`='AAA' WHERE `k1`=2 AND `k2`=2;
+UPDATE `test`.`t1` SET `padding`='AAA' WHERE `k1`=2 AND `k2`=3;
+UPDATE `test`.`t1` SET `padding`='AAA' WHERE `k1`=3 AND `k2`=3;
+COMMIT;
+START TRANSACTION;
+DROP TABLE `test`.`t1`;
+COMMIT;
+SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/no_modification.result'
--- plugin/transaction_log/tests/r/no_modification.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/no_modification.result	2010-03-02 21:04:16 +0000
@@ -15,10 +15,10 @@
 2	I hate testing.
 COMMIT;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');

=== modified file 'plugin/transaction_log/tests/r/no_primary_key.result'
--- plugin/transaction_log/tests/r/no_primary_key.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/no_primary_key.result	2010-03-02 21:04:16 +0000
@@ -7,12 +7,12 @@
 ERROR HY000: Tables which are replicated require a primary key.
 DROP TABLE t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL );
-COMMIT;
-START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci ) ENGINE = InnoDB COLLATE = utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+DROP TABLE `test`.`t1`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/rand.result'
--- plugin/transaction_log/tests/r/rand.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/rand.result	2010-03-02 21:04:16 +0000
@@ -7,10 +7,10 @@
 INSERT INTO t1 SELECT RAND(100)*100 FROM t1;
 DROP TABLE t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`) VALUES (1);
@@ -19,6 +19,6 @@
 INSERT INTO `test`.`t1` (`id`) VALUES (17);
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/rename.result'
--- plugin/transaction_log/tests/r/rename.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/rename.result	2010-03-02 21:04:16 +0000
@@ -6,13 +6,13 @@
 );
 RENAME TABLE t1 TO t2;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-DROP TABLE IF EXISTS `t2`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+DROP TABLE IF EXISTS `test`.`t2`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 RENAME TABLE t1 TO t2;

=== modified file 'plugin/transaction_log/tests/r/replace.result'
--- plugin/transaction_log/tests/r/replace.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/replace.result	2010-03-02 21:04:16 +0000
@@ -21,13 +21,13 @@
 REPLACE INTO t1 VALUE (2, "I love testing.");
 DROP TABLE t2, t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-DROP TABLE IF EXISTS `t2`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL AUTO_INCREMENT PRIMARY KEY , padding VARCHAR(200) NOT NULL ) ENGINE=InnoDB;
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+DROP TABLE IF EXISTS `test`.`t2`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL AUTO_INCREMENT, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -39,13 +39,13 @@
 UPDATE `test`.`t1` SET `padding`='I love testing.' WHERE `id`=2;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL AUTO_INCREMENT PRIMARY KEY , padding VARCHAR(200) NOT NULL ) ENGINE=InnoDB;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t2 ( id INT NOT NULL AUTO_INCREMENT PRIMARY KEY , fk_id INT NOT NULL , CONSTRAINT fk_t1 FOREIGN KEY (fk_id) REFERENCES t1 (id) ON DELETE CASCADE ) ENGINE=InnoDB;
+DROP TABLE `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL AUTO_INCREMENT, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t2` ( `id` INT NOT NULL AUTO_INCREMENT, `fk_id` INT NOT NULL, PRIMARY KEY `PRIMARY` (`id`), KEY `fk_t1` (`fk_id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -58,9 +58,9 @@
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (2,'I love testing.');
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t2`;
+DROP TABLE `test`.`t2`;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/rollback.result'
--- plugin/transaction_log/tests/r/rollback.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/rollback.result	2010-03-02 21:04:16 +0000
@@ -13,12 +13,12 @@
 ROLLBACK;
 DROP TABLE t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
-COMMIT;
-START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
-COMMIT;
-START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
+COMMIT;
+START TRANSACTION;
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+DROP TABLE `test`.`t1`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== added file 'plugin/transaction_log/tests/r/schema.result'
--- plugin/transaction_log/tests/r/schema.result	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/r/schema.result	2010-03-02 21:04:16 +0000
@@ -0,0 +1,13 @@
+DROP SCHEMA IF EXISTS my_new_schema;
+CREATE SCHEMA my_new_warnings;
+DROP SCHEMA my_new_warnings;
+START TRANSACTION;
+DROP SCHEMA `my_new_schema`;
+COMMIT;
+START TRANSACTION;
+CREATE SCHEMA `my_new_warnings` COLLATE utf8_general_ci;
+COMMIT;
+START TRANSACTION;
+DROP SCHEMA `my_new_warnings`;
+COMMIT;
+SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/select_for_update.result'
--- plugin/transaction_log/tests/r/select_for_update.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/select_for_update.result	2010-03-02 21:04:16 +0000
@@ -19,10 +19,10 @@
 COMMIT;
 DROP TABLE t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -39,6 +39,6 @@
 UPDATE `test`.`t1` SET `id`=6 WHERE `id`=5;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/temp_tables.result'
--- plugin/transaction_log/tests/r/temp_tables.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/temp_tables.result	2010-03-02 21:04:16 +0000
@@ -10,10 +10,10 @@
 DROP TABLE t1;
 DROP TABLE t2;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t2`;
+DROP TABLE IF EXISTS `test`.`t2`;
 COMMIT;
 START TRANSACTION;
 CREATE TABLE `t2` (   `id` int NOT NULL,   `padding` varchar(200) NOT NULL,   PRIMARY KEY (`id`) ) ENGINE=InnoDB;
@@ -23,6 +23,6 @@
 INSERT INTO `test`.`t2` (`id`,`padding`) VALUES (2,'I hate testing.');
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t2`;
+DROP TABLE `test`.`t2`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== modified file 'plugin/transaction_log/tests/r/truncate.result'
--- plugin/transaction_log/tests/r/truncate.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/truncate.result	2010-03-02 21:04:16 +0000
@@ -7,10 +7,10 @@
 INSERT INTO t1 VALUES (2, "I hate testing.");
 TRUNCATE TABLE t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL PRIMARY KEY , padding VARCHAR(200) NOT NULL );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');

=== modified file 'plugin/transaction_log/tests/r/truncate_log.result'
--- plugin/transaction_log/tests/r/truncate_log.result	2009-12-11 19:08:29 +0000
+++ plugin/transaction_log/tests/r/truncate_log.result	2010-03-02 21:04:16 +0000
@@ -5,6 +5,6 @@
 );
 INSERT INTO t1 VALUES (1, "I love testing.");
 INSERT INTO t1 VALUES (2, "I hate testing.");
-17var/master-data/transaction.log
+24var/master-data/transaction.log
 SET GLOBAL transaction_log_truncate_debug= true;
 0var/master-data/transaction.log

=== modified file 'plugin/transaction_log/tests/r/update.result'
--- plugin/transaction_log/tests/r/update.result	2009-12-23 14:24:22 +0000
+++ plugin/transaction_log/tests/r/update.result	2010-03-02 21:04:16 +0000
@@ -36,10 +36,10 @@
 UPDATE t1 SET id = 4 WHERE id = 2;
 DROP TABLE t1;
 START TRANSACTION;
-DROP TABLE IF EXISTS `t1`;
+DROP TABLE IF EXISTS `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -55,10 +55,10 @@
 UPDATE `test`.`t1` SET `padding`='AAA' WHERE `id`=2;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id int AUTO_INCREMENT NOT NULL PRIMARY KEY , name varchar(1024) , alias varchar(1024) );
+CREATE TABLE `t1` ( `id` INT NOT NULL AUTO_INCREMENT, `name` VARCHAR(1024) NOT NULL COLLATE utf8_general_ci, `alias` VARCHAR(1024) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`name`,`alias`) VALUES (1,'jeff lebowski','dude');
@@ -67,10 +67,10 @@
 UPDATE `test`.`t1` SET `alias`='the dude' WHERE `id`=1;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , counter INT NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `counter` INT NOT NULL, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`counter`) VALUES (1,1);
@@ -85,10 +85,10 @@
 UPDATE `test`.`t1` SET `counter`=4 WHERE `id`=3;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 START TRANSACTION;
-CREATE TABLE t1 ( id INT NOT NULL , padding VARCHAR(200) NOT NULL , PRIMARY KEY (id) );
+CREATE TABLE `t1` ( `id` INT NOT NULL, `padding` VARCHAR(200) NOT NULL COLLATE utf8_general_ci, PRIMARY KEY `PRIMARY` (`id`) ) ENGINE = InnoDB COLLATE = utf8_general_ci;
 COMMIT;
 START TRANSACTION;
 INSERT INTO `test`.`t1` (`id`,`padding`) VALUES (1,'I love testing.');
@@ -100,6 +100,6 @@
 UPDATE `test`.`t1` SET `id`=4 WHERE `id`=2;
 COMMIT;
 START TRANSACTION;
-DROP TABLE `t1`;
+DROP TABLE `test`.`t1`;
 COMMIT;
 SET GLOBAL transaction_log_truncate_debug= true;

=== added file 'plugin/transaction_log/tests/t/create_table-master.opt'
--- plugin/transaction_log/tests/t/create_table-master.opt	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/t/create_table-master.opt	2010-03-02 21:04:16 +0000
@@ -0,0 +1,1 @@
+--default-replicator-enable --transaction-log-enable --scheduler=multi_thread

=== added file 'plugin/transaction_log/tests/t/create_table.inc'
--- plugin/transaction_log/tests/t/create_table.inc	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/t/create_table.inc	2010-03-02 21:04:16 +0000
@@ -0,0 +1,53 @@
+#
+# Tests tons of different CREATE TABLE
+# variations and the replication stream
+#
+
+--disable_warnings
+DROP TABLE IF EXISTS t1;
+--enable_warnings
+
+# Test the field generation
+
+CREATE TABLE t1 (
+  autoinc_int_field INT NOT NULL AUTO_INCREMENT
+, null_int_field INT NULL
+, not_null_bigint_field BIGINT NOT NULL
+, null_bigint_field BIGINT NULL
+, not_null_int_field INT NOT NULL
+, null_varchar_field VARCHAR(100) NULL
+, not_null_varchar_field VARCHAR(100) NOT NULL
+, null_enum_field ENUM ('val1', 'val2') NULL
+, not_null_enum_field ENUM ('val1', 'val2') NOT NULL
+, null_date_field DATE NULL
+, not_null_date_field DATE NOT NULL
+, null_datetime_field DATETIME NULL
+, not_null_datetime_field DATETIME NOT NULL
+, null_blob_field BLOB NULL
+, not_null_blob_field BLOB NOT NULL
+, null_text_field TEXT NULL
+, not_null_text_field TEXT NOT NULL
+, null_timestamp_field TIMESTAMP NULL
+, not_null_timestamp_field TIMESTAMP NOT NULL
+, null_double_field DOUBLE NULL
+, not_null_double_field DOUBLE NOT NULL
+, null_decimal_field DECIMAL(10,2) NULL
+, not_null_decimal_field DECIMAL(10,2) NOT NULL
+, PRIMARY KEY (autoinc_int_field)
+);
+
+DROP TABLE t1;
+
+# Test the index generation
+
+CREATE TABLE t1 (
+  id INT NOT NULL AUTO_INCREMENT PRIMARY KEY
+, key1 VARCHAR(10) NOT NULL
+, key2 DOUBLE NOT NULL
+, key3 BLOB NOT NULL
+, UNIQUE KEY (key1)
+, KEY named_key (key2)
+, KEY partial_key (key3(30))
+);
+
+DROP TABLE t1;

=== added file 'plugin/transaction_log/tests/t/create_table.test'
--- plugin/transaction_log/tests/t/create_table.test	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/t/create_table.test	2010-03-02 21:04:16 +0000
@@ -0,0 +1,9 @@
+# Populate log with some records...
+--source ../plugin/transaction_log/tests/t/create_table.inc
+
+# Read in the transaction.log.
+
+--exec ../drizzled/message/transaction_reader var/master-data/transaction.log
+
+# Truncate the log file to reset for the next test
+--source ../plugin/transaction_log/tests/t/truncate_log.inc

=== removed file 'plugin/transaction_log/tests/t/database.inc'
--- plugin/transaction_log/tests/t/database.inc	2009-07-02 05:08:33 +0000
+++ plugin/transaction_log/tests/t/database.inc	1970-01-01 00:00:00 +0000
@@ -1,12 +0,0 @@
-# 
-# Simple test of the serial event log for CREATE DATABASE and
-# DROP DATABASE  
-# 
-# Create a database then drop a database 
-# 
-# We then use the transaction_reader in drizzled/message/ to read the events.
-#
-
-# CREATE DATABASE 
-CREATE DATABASE test1;
-DROP DATABASE test1;

=== removed file 'plugin/transaction_log/tests/t/database.test'
--- plugin/transaction_log/tests/t/database.test	2009-12-04 18:50:04 +0000
+++ plugin/transaction_log/tests/t/database.test	1970-01-01 00:00:00 +0000
@@ -1,13 +0,0 @@
-#
-# Tests simple CREATE DATABASE and DROP DATABASE statements and the transaction log
-#
-
-# Populate log with some records...
---source ../plugin/transaction_log/tests/t/database.inc
-
-# Read in the transaction.log.
-
---exec ../drizzled/message/transaction_reader var/master-data/transaction.log
-
-# Truncate the log file to reset for the next test
---source ../plugin/transaction_log/tests/t/truncate_log.inc

=== modified file 'plugin/transaction_log/tests/t/filtered_replicator.test'
--- plugin/transaction_log/tests/t/filtered_replicator.test	2009-12-04 18:50:04 +0000
+++ plugin/transaction_log/tests/t/filtered_replicator.test	2010-03-02 21:04:16 +0000
@@ -16,7 +16,7 @@
 --source ../plugin/transaction_log/tests/t/insert_multi.inc
 --source ../plugin/transaction_log/tests/t/insert_select.inc
 --source ../plugin/transaction_log/tests/t/alter.inc
---source ../plugin/transaction_log/tests/t/database.inc
+--source ../plugin/transaction_log/tests/t/schema.inc
 --source ../plugin/transaction_log/tests/t/rename.inc
 --source ../plugin/transaction_log/tests/t/delete.inc
 --source ../plugin/transaction_log/tests/t/update.inc

=== added file 'plugin/transaction_log/tests/t/multi_column_primary_key-master.opt'
--- plugin/transaction_log/tests/t/multi_column_primary_key-master.opt	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/t/multi_column_primary_key-master.opt	2010-03-02 21:04:16 +0000
@@ -0,0 +1,1 @@
+--default-replicator-enable --transaction-log-enable --scheduler=multi_thread

=== added file 'plugin/transaction_log/tests/t/multi_column_primary_key.inc'
--- plugin/transaction_log/tests/t/multi_column_primary_key.inc	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/t/multi_column_primary_key.inc	2010-03-02 21:04:16 +0000
@@ -0,0 +1,36 @@
+# 
+# Test that tables with multi-column primary keys
+# are handled properly in replication
+#
+
+--disable_warnings
+DROP TABLE IF EXISTS t1;
+--enable_warnings
+
+CREATE TABLE t1 (
+  k1 INT NOT NULL
+, k2 INT NOT NULL
+, padding VARCHAR(200) NOT NULL
+, PRIMARY KEY (k1, k2)
+);
+
+INSERT INTO t1 VALUES (1, 1, "I love testing.");
+INSERT INTO t1 VALUES (2, 2, "I hate testing.");
+INSERT INTO t1 VALUES (2, 3, "I hate and love testing.");
+INSERT INTO t1 VALUES (3, 3, "I adore testing.");
+
+# Simple PK update on both columns
+UPDATE t1 SET padding= "XXX" WHERE k1= 1 AND k2= 1;
+
+# UPDATE all records in table matching first column
+# in primary key
+UPDATE t1 SET padding= "YYY" WHERE k1= 2;
+
+# UPDATE all records in table matching second column
+# in primary key
+UPDATE t1 SET padding= "ZZZ" WHERE k2= 3;
+
+# UPDATE all records in table
+UPDATE t1 SET padding= "AAA";
+
+DROP TABLE t1;

=== added file 'plugin/transaction_log/tests/t/multi_column_primary_key.test'
--- plugin/transaction_log/tests/t/multi_column_primary_key.test	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/t/multi_column_primary_key.test	2010-03-02 21:04:16 +0000
@@ -0,0 +1,9 @@
+# Populate log with some records...
+--source ../plugin/transaction_log/tests/t/multi_column_primary_key.inc
+
+# Read in the transaction.log.
+
+--exec ../drizzled/message/transaction_reader var/master-data/transaction.log
+
+# Truncate the log file to reset for the next test
+--source ../plugin/transaction_log/tests/t/truncate_log.inc

=== added file 'plugin/transaction_log/tests/t/schema-master.opt'
--- plugin/transaction_log/tests/t/schema-master.opt	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/t/schema-master.opt	2010-03-02 21:04:16 +0000
@@ -0,0 +1,1 @@
+--default-replicator-enable --transaction-log-enable --scheduler=multi_thread

=== added file 'plugin/transaction_log/tests/t/schema.inc'
--- plugin/transaction_log/tests/t/schema.inc	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/t/schema.inc	2010-03-02 21:04:16 +0000
@@ -0,0 +1,12 @@
+# 
+# Test CREATE SCHEMA, DROP SCHEMA, ALTER SCHEMA
+# and the replication stream
+#
+
+--disable_warnings
+DROP SCHEMA IF EXISTS my_new_schema;
+--enable_warnings
+
+CREATE SCHEMA my_new_warnings;
+
+DROP SCHEMA my_new_warnings;

=== added file 'plugin/transaction_log/tests/t/schema.test'
--- plugin/transaction_log/tests/t/schema.test	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/t/schema.test	2010-03-02 21:04:16 +0000
@@ -0,0 +1,9 @@
+# Populate log with some records...
+--source ../plugin/transaction_log/tests/t/schema.inc
+
+# Read in the transaction.log.
+
+--exec ../drizzled/message/transaction_reader var/master-data/transaction.log
+
+# Truncate the log file to reset for the next test
+--source ../plugin/transaction_log/tests/t/truncate_log.inc

=== modified file 'tests/r/innodb.result'
--- tests/r/innodb.result	2010-03-01 22:24:10 +0000
+++ tests/r/innodb.result	2010-03-02 21:04:16 +0000
@@ -1130,24 +1130,24 @@
 checksum table t1, t2, t3, t4;
 Table	Checksum
 test.t1	2948697075
-test.t2	2948697075
-test.t3	2948697075
-test.t4	NULL
-Warnings:
-Error	1146	Table 'test.t4' doesn't exist
-checksum table t1, t2, t3, t4;
-Table	Checksum
-test.t1	2948697075
-test.t2	2948697075
-test.t3	2948697075
-test.t4	NULL
-Warnings:
-Error	1146	Table 'test.t4' doesn't exist
-checksum table t1, t2, t3, t4;
-Table	Checksum
-test.t1	2948697075
-test.t2	2948697075
-test.t3	2948697075
+test.t2	3505595080
+test.t3	3505595080
+test.t4	NULL
+Warnings:
+Error	1146	Table 'test.t4' doesn't exist
+checksum table t1, t2, t3, t4;
+Table	Checksum
+test.t1	2948697075
+test.t2	3505595080
+test.t3	3505595080
+test.t4	NULL
+Warnings:
+Error	1146	Table 'test.t4' doesn't exist
+checksum table t1, t2, t3, t4;
+Table	Checksum
+test.t1	2948697075
+test.t2	3505595080
+test.t3	3505595080
 test.t4	NULL
 Warnings:
 Error	1146	Table 'test.t4' doesn't exist

=== modified file 'tests/r/mix2_myisam.result'
--- tests/r/mix2_myisam.result	2010-02-19 19:04:24 +0000
+++ tests/r/mix2_myisam.result	2010-03-02 21:04:16 +0000
@@ -898,30 +898,30 @@
 Table	Checksum
 test.t1	2948697075
 test.t2	2948697075
-test.t3	2948697075
-test.t4	2948697075
-test.t5	2948697075
-test.t6	2948697075
-test.t7	NULL
-Warnings:
-Error	1146	Table 'test.t7' doesn't exist
-checksum table t1, t2, t3, t4, t5, t6, t7;
-Table	Checksum
-test.t1	2948697075
-test.t2	2948697075
-test.t3	2948697075
-test.t4	2948697075
-test.t5	2948697075
-test.t6	2948697075
-test.t7	NULL
-Warnings:
-Error	1146	Table 'test.t7' doesn't exist
-checksum table t1, t2, t3, t4, t5, t6, t7;
-Table	Checksum
-test.t1	2948697075
-test.t2	2948697075
-test.t3	2948697075
-test.t4	2948697075
+test.t3	3505595080
+test.t4	3505595080
+test.t5	2948697075
+test.t6	2948697075
+test.t7	NULL
+Warnings:
+Error	1146	Table 'test.t7' doesn't exist
+checksum table t1, t2, t3, t4, t5, t6, t7;
+Table	Checksum
+test.t1	2948697075
+test.t2	2948697075
+test.t3	3505595080
+test.t4	3505595080
+test.t5	2948697075
+test.t6	2948697075
+test.t7	NULL
+Warnings:
+Error	1146	Table 'test.t7' doesn't exist
+checksum table t1, t2, t3, t4, t5, t6, t7;
+Table	Checksum
+test.t1	2948697075
+test.t2	2948697075
+test.t3	3505595080
+test.t4	3505595080
 test.t5	2948697075
 test.t6	2948697075
 test.t7	NULL

=== modified file 'tests/r/myisam.result'
--- tests/r/myisam.result	2010-03-01 22:24:10 +0000
+++ tests/r/myisam.result	2010-03-02 21:04:16 +0000
@@ -490,22 +490,22 @@
 insert t2 select * from t1;
 checksum table t1, t2, t3;
 Table	Checksum
-test.t1	2948697075
-test.t2	2948697075
-test.t3	NULL
-Warnings:
-Error	1146	Table 'test.t3' doesn't exist
-checksum table t1, t2, t3;
-Table	Checksum
-test.t1	2948697075
-test.t2	2948697075
-test.t3	NULL
-Warnings:
-Error	1146	Table 'test.t3' doesn't exist
-checksum table t1, t2, t3;
-Table	Checksum
-test.t1	2948697075
-test.t2	2948697075
+test.t1	3505595080
+test.t2	3505595080
+test.t3	NULL
+Warnings:
+Error	1146	Table 'test.t3' doesn't exist
+checksum table t1, t2, t3;
+Table	Checksum
+test.t1	3505595080
+test.t2	3505595080
+test.t3	NULL
+Warnings:
+Error	1146	Table 'test.t3' doesn't exist
+checksum table t1, t2, t3;
+Table	Checksum
+test.t1	3505595080
+test.t2	3505595080
 test.t3	NULL
 Warnings:
 Error	1146	Table 'test.t3' doesn't exist