Merge lp:~dshrews/drizzle/bug660779 into lp:~drizzle-trunk/drizzle/development

[David Shrewsbury]

Provides methods in TransactionServices to undo adding records to the current Statement message when a multi-row affecting statement fails mid-execution. Call this method for UPDATEs and INSERT..SELECTs that fail.

Also cleans up some #includes in session.* and adds some comments for the st_transactions struct in session.h.

[Lee Bieber (kalebral-deactivatedaccount)]

Doesn't build on Solaris - http://hudson.drizzle.org/view/Drizzle-build/job/drizzle-build-sparc-solaris10/1344/console

[David Shrewsbury (dshrews)]

Grr... working on it...

[David Shrewsbury (dshrews)]

Solaris succeeded in param-build.

=== modified file 'drizzled/session.cc'
--- drizzled/session.cc	2010-10-22 22:08:54 +0000
+++ drizzled/session.cc	2010-10-26 14:47:53 +0000
@@ -22,21 +22,21 @@
  */
 
 #include "config.h"
-#include <drizzled/session.h>
+#include "drizzled/session.h"
 #include "drizzled/session_list.h"
 #include <sys/stat.h>
-#include <drizzled/error.h>
-#include <drizzled/gettext.h>
-#include <drizzled/query_id.h>
-#include <drizzled/data_home.h>
-#include <drizzled/sql_base.h>
-#include <drizzled/lock.h>
-#include <drizzled/item/cache.h>
-#include <drizzled/item/float.h>
-#include <drizzled/item/return_int.h>
-#include <drizzled/item/empty_string.h>
-#include <drizzled/show.h>
-#include <drizzled/plugin/client.h>
+#include "drizzled/error.h"
+#include "drizzled/gettext.h"
+#include "drizzled/query_id.h"
+#include "drizzled/data_home.h"
+#include "drizzled/sql_base.h"
+#include "drizzled/lock.h"
+#include "drizzled/item/cache.h"
+#include "drizzled/item/float.h"
+#include "drizzled/item/return_int.h"
+#include "drizzled/item/empty_string.h"
+#include "drizzled/show.h"
+#include "drizzled/plugin/client.h"
 #include "drizzled/plugin/scheduler.h"
 #include "drizzled/plugin/authentication.h"
 #include "drizzled/plugin/logging.h"
@@ -60,7 +60,7 @@
 #include <fcntl.h>
 #include <algorithm>
 #include <climits>
-#include "boost/filesystem.hpp" 
+#include <boost/filesystem.hpp>
 
 using namespace std;
 
 
=== modified file 'drizzled/session.h'
--- drizzled/session.h	2010-10-23 22:18:01 +0000
+++ drizzled/session.h	2010-10-26 14:47:53 +0000
@@ -21,23 +21,20 @@
 #ifndef DRIZZLED_SESSION_H
 #define DRIZZLED_SESSION_H
 
-/* Classes in mysql */
-
 #include "drizzled/plugin.h"
-#include <drizzled/sql_locale.h>
+#include "drizzled/sql_locale.h"
 #include "drizzled/resource_context.h"
-#include <drizzled/cursor.h>
-#include <drizzled/current_session.h>
-#include <drizzled/sql_error.h>
-#include <drizzled/file_exchange.h>
-#include <drizzled/select_result_interceptor.h>
-#include <drizzled/statistics_variables.h>
-#include <drizzled/xid.h>
+#include "drizzled/cursor.h"
+#include "drizzled/current_session.h"
+#include "drizzled/sql_error.h"
+#include "drizzled/file_exchange.h"
+#include "drizzled/select_result_interceptor.h"
+#include "drizzled/statistics_variables.h"
+#include "drizzled/xid.h"
 #include "drizzled/query_id.h"
 #include "drizzled/named_savepoint.h"
 #include "drizzled/transaction_context.h"
 #include "drizzled/util/storable.h"
-
 #include "drizzled/my_hash.h"
 
 #include <netdb.h>
@@ -47,14 +44,11 @@
 #include <deque>
 
 #include "drizzled/internal/getrusage.h"
-
-#include <drizzled/security_context.h>
-#include <drizzled/open_tables_state.h>
-
-#include <drizzled/internal_error_handler.h>
-#include <drizzled/diagnostics_area.h>
-
-#include <drizzled/plugin/authorization.h>
+#include "drizzled/security_context.h"
+#include "drizzled/open_tables_state.h"
+#include "drizzled/internal_error_handler.h"
+#include "drizzled/diagnostics_area.h"
+#include "drizzled/plugin/authorization.h"
 
 #include <boost/unordered_map.hpp>
 #include <boost/thread/mutex.hpp>
@@ -550,10 +544,38 @@
   ResourceContext *getResourceContext(const plugin::MonitoredInTransaction *monitored,
                                       size_t index= 0);
 
+  /**
+   * Structure used to manage "statement transactions" and
+   * "normal transactions". In autocommit mode, the normal transaction is
+   * equivalent to the statement transaction.
+   *
+   * Storage engines will be registered here when they participate in
+   * a transaction. No engine is registered more than once.
+   */
   struct st_transactions {
     std::deque<NamedSavepoint> savepoints;
-    TransactionContext all; ///< Trans since BEGIN WORK
-    TransactionContext stmt; ///< Trans for current statement
+
+    /**
+     * The normal transaction (since BEGIN WORK).
+     *
+     * Contains a list of all engines that have participated in any of the
+     * statement transactions started within the context of the normal
+     * transaction.
+     *
+     * @note In autocommit mode, this is empty.
+     */
+    TransactionContext all;
+
+    /**
+     * The statment transaction.
+     *
+     * Contains a list of all engines participating in the given statement.
+     *
+     * @note In autocommit mode, this will be used to commit/rollback the
+     * normal transaction.
+     */
+    TransactionContext stmt;
+
     XID_STATE xid_state;
 
     void cleanup()
@@ -1197,9 +1219,8 @@
    * Current implementation does not depend on that, but future changes
    * should be done with this in mind; 
    *
-   * @param  Scrambled password received from client
-   * @param  Length of scrambled password
-   * @param  Database name to connect to, may be NULL
+   * @param passwd Scrambled password received from client
+   * @param db Database name to connect to, may be NULL
    */
   bool checkUser(const std::string &passwd, const std::string &db);
   
 
=== modified file 'drizzled/sql_insert.cc'
--- drizzled/sql_insert.cc	2010-10-24 19:36:55 +0000
+++ drizzled/sql_insert.cc	2010-10-26 14:47:53 +0000
@@ -1276,7 +1276,16 @@
   store_values(values);
   session->count_cuted_fields= CHECK_FIELD_IGNORE;
   if (session->is_error())
+  {
+    /*
+     * If we fail mid-way through INSERT..SELECT, we need to remove any
+     * records that we added to the current Statement message. We can
+     * use session->row_count to know how many records we have already added.
+     */
+    TransactionServices &ts= TransactionServices::singleton();
+    ts.removeStatementRecords(session, (session->row_count - 1));
     return(1);
+  }
 
   // Release latches in case bulk insert takes a long time
   plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
 
=== modified file 'drizzled/sql_update.cc'
--- drizzled/sql_update.cc	2010-10-24 01:34:39 +0000
+++ drizzled/sql_update.cc	2010-10-26 14:47:53 +0000
@@ -29,6 +29,7 @@
 #include "drizzled/records.h"
 #include "drizzled/internal/my_sys.h"
 #include "drizzled/internal/iocache.h"
+#include "drizzled/transaction_services.h"
 
 #include <boost/dynamic_bitset.hpp>
 #include <list>
@@ -473,7 +474,20 @@
 
       table->storeRecord();
       if (fill_record(session, fields, values))
+      {
+        /*
+         * If we updated some rows before this one failed (updated > 0),
+         * then we will need to undo adding those records to the
+         * replication Statement message.
+         */
+        if (updated > 0)
+        {
+          TransactionServices &ts= TransactionServices::singleton();
+          ts.removeStatementRecords(session, updated);
+        }
+
         break;
+      }
 
       found++;
 
@@ -486,15 +500,15 @@
         table->auto_increment_field_not_null= false;
 
         if (!error || error == HA_ERR_RECORD_IS_THE_SAME)
-	{
+        {
           if (error != HA_ERR_RECORD_IS_THE_SAME)
             updated++;
           else
             error= 0;
-	}
-	else if (! ignore ||
+        }
+        else if (! ignore ||
                  table->cursor->is_fatal_error(error, HA_CHECK_DUP_KEY))
-	{
+        {
           /*
             If (ignore && error is ignorable) we don't have to
             do anything; otherwise...
@@ -505,10 +519,10 @@
             flags|= ME_FATALERROR; /* Other handler errors are fatal */
 
           prepare_record_for_error_message(error, table);
-	  table->print_error(error,MYF(flags));
-	  error= 1;
-	  break;
-	}
+          table->print_error(error,MYF(flags));
+          error= 1;
+          break;
+        }
       }
 
       if (!--limit && using_limit)
 
=== modified file 'drizzled/transaction_services.cc'
--- drizzled/transaction_services.cc	2010-10-11 17:20:14 +0000
+++ drizzled/transaction_services.cc	2010-10-26 14:47:53 +0000
@@ -71,11 +71,13 @@
 #include "drizzled/plugin/xa_resource_manager.h"
 #include "drizzled/internal/my_sys.h"
 
-using namespace std;
-
 #include <vector>
 #include <algorithm>
 #include <functional>
+#include <google/protobuf/repeated_field.h>
+
+using namespace std;
+using namespace google;
 
 namespace drizzled
 {
@@ -1826,6 +1828,123 @@
   }
 }
 
+
+/**
+ * Template for removing Statement records of different types.
+ *
+ * The code for removing records from different Statement message types
+ * is identical except for the class types that are embedded within the
+ * Statement.
+ *
+ * There are 3 scenarios we need to look for:
+ *   - We've been asked to remove more records than exist in the Statement
+ *   - We've been asked to remove less records than exist in the Statement
+ *   - We've been asked to remove ALL records that exist in the Statement
+ *
+ * If we are removing ALL records, then effectively we would be left with
+ * an empty Statement message, so we should just remove it and clean up
+ * message pointers in the Session object.
+ */
+template <class DataType, class RecordType>
+static bool removeStatementRecordsWithType(Session *session,
+                                           DataType *data,
+                                           uint32_t count)
+{
+  uint32_t num_avail_recs= static_cast<uint32_t>(data->record_size());
+
+  /* If there aren't enough records to remove 'count' of them, error. */
+  if (num_avail_recs < count)
+    return false;
+
+  /*
+   * If we are removing all of the data records, we'll just remove this
+   * entire Statement message.
+   */
+  if (num_avail_recs == count)
+  {
+    message::Transaction *transaction= session->getTransactionMessage();
+    protobuf::RepeatedPtrField<message::Statement> *statements= transaction->mutable_statement();
+    statements->RemoveLast();
+
+    /*
+     * Now need to set the Session Statement pointer to either the previous
+     * Statement, or NULL if there isn't one.
+     */
+    if (statements->size() == 0)
+    {
+      session->setStatementMessage(NULL);
+    }
+    else
+    {
+      /*
+       * There isn't a great way to get a pointer to the previous Statement
+       * message using the RepeatedPtrField object, so we'll just get to it
+       * using the Transaction message.
+       */
+      int last_stmt_idx= transaction->statement_size() - 1;
+      session->setStatementMessage(transaction->mutable_statement(last_stmt_idx));
+    }
+  }
+  /* We only need to remove 'count' records */
+  else if (num_avail_recs > count)
+  {
+    protobuf::RepeatedPtrField<RecordType> *records= data->mutable_record();
+    while (count--)
+      records->RemoveLast();
+  }
+
+  return true;
+}
+
+
+bool TransactionServices::removeStatementRecords(Session *session,
+                                                 uint32_t count)
+{
+  ReplicationServices &replication_services= ReplicationServices::singleton();
+  if (! replication_services.isActive())
+    return false;
+
+  /* Get the most current Statement */
+  message::Statement *statement= session->getStatementMessage();
+
+  /* Make sure we have work to do */
+  if (statement == NULL)
+    return false;
+
+  bool retval= false;
+
+  switch (statement->type())
+  {
+    case message::Statement::INSERT:
+    {
+      message::InsertData *data= statement->mutable_insert_data();
+      retval= removeStatementRecordsWithType<message::InsertData, message::InsertRecord>(session, data, count);
+      break;
+    }
+
+    case message::Statement::UPDATE:
+    {
+      message::UpdateData *data= statement->mutable_update_data();
+      retval= removeStatementRecordsWithType<message::UpdateData, message::UpdateRecord>(session, data, count);
+      break;
+    }
+
+    case message::Statement::DELETE:  /* not sure if this one is possible... */
+    {
+      message::DeleteData *data= statement->mutable_delete_data();
+      retval= removeStatementRecordsWithType<message::DeleteData, message::DeleteRecord>(session, data, count);
+      break;
+    }
+
+    default:
+      retval= false;
+      break;
+  }
+
+  return retval;
+}
+
+
 void TransactionServices::createTable(Session *in_session,
                                       const message::Table &table)
 {
 
=== modified file 'drizzled/transaction_services.h'
--- drizzled/transaction_services.h	2010-10-11 17:20:14 +0000
+++ drizzled/transaction_services.h	2010-10-26 14:47:53 +0000
@@ -260,6 +260,28 @@
    * @param use_update_record If true, uses the values from the update row instead
    */
   void deleteRecord(Session *in_session, Table *in_table, bool use_update_record= false);
+
+  /**
+   * Used to undo effects of a failed statement.
+   *
+   * An SQL statement, like an UPDATE, that affects multiple rows could
+   * potentially fail mid-way through processing the rows. In such a case,
+   * the successfully modified rows that preceeded the failing row would
+   * have been added to the Statement message. This method is used for
+   * rolling back that change.
+   *
+   * @note
+   * This particular failure is seen on column constraint violations
+   * during a multi-row UPDATE and a multi-row INSERT..SELECT.
+   *
+   * @param in_session Pointer to the Session containing the Statement
+   * @param count The number of records to remove from Statement.
+   *
+   * @retval true Successfully removed 'count' records
+   * @retval false Failure
+   */
+  bool removeStatementRecords(Session *in_session, uint32_t count);
+
   /**
    * Creates a CreateSchema Statement GPB message and adds it
    * to the Session's active Transaction GPB message for pushing
 
=== added file 'plugin/transaction_log/tests/r/bug660779.result'
--- plugin/transaction_log/tests/r/bug660779.result	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/r/bug660779.result	2010-10-26 14:47:53 +0000
@@ -0,0 +1,220 @@
+CREATE TABLE t1 (
+pk INT NOT NULL AUTO_INCREMENT,
+col_int1 INT,
+col_int2 INT,
+col_int_not_null INT NOT NULL,
+PRIMARY KEY (pk));
+INSERT INTO t1 (col_int1, col_int2, col_int_not_null) VALUES (1,1,1);
+INSERT INTO t1 (col_int1, col_int2, col_int_not_null) VALUES (NULL,1,1);
+INSERT INTO t1 (col_int1, col_int2, col_int_not_null) VALUES (2,1,3);
+SET GLOBAL transaction_log_truncate_debug= true;
+BEGIN;
+UPDATE t1 SET col_int_not_null = col_int1 WHERE col_int2 = 1;
+ERROR 23000: Column 'col_int_not_null' cannot be null
+INSERT INTO t1 (col_int1, col_int2, col_int_not_null) VALUES (5,5,5);
+COMMIT;
+
+We should have a Transaction with a single insert Statement
+SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
+PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS))
+transaction_context {
+  server_id: 1
+  transaction_id: 1
+  START_TIMESTAMP
+  END_TIMESTAMP
+}
+statement {
+  type: INSERT
+  START_TIMESTAMP
+  END_TIMESTAMP
+  insert_header {
+    table_metadata {
+      schema_name: "test"
+      table_name: "t1"
+    }
+    field_metadata {
+      type: INTEGER
+      name: "pk"
+    }
+    field_metadata {
+      type: INTEGER
+      name: "col_int1"
+    }
+    field_metadata {
+      type: INTEGER
+      name: "col_int2"
+    }
+    field_metadata {
+      type: INTEGER
+      name: "col_int_not_null"
+    }
+  }
+  insert_data {
+    segment_id: 1
+    end_segment: true
+    record {
+      insert_value: "4"
+      insert_value: "5"
+      insert_value: "5"
+      insert_value: "5"
+      is_null: false
+      is_null: false
+      is_null: false
+      is_null: false
+    }
+  }
+}
+
+BEGIN;
+UPDATE t1 SET col_int1 = (col_int1 + 1) WHERE col_int2 = 1;
+UPDATE t1 SET col_int_not_null = col_int1 WHERE col_int2 = 1;
+ERROR 23000: Column 'col_int_not_null' cannot be null
+INSERT INTO t1 (col_int1, col_int2, col_int_not_null) VALUES (6,6,6);
+COMMIT;
+
+We should have a Transaction with 1 update and 1 insert Statement
+SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
+PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS))
+transaction_context {
+  server_id: 1
+  transaction_id: 2
+  START_TIMESTAMP
+  END_TIMESTAMP
+}
+statement {
+  type: UPDATE
+  START_TIMESTAMP
+  END_TIMESTAMP
+  update_header {
+    table_metadata {
+      schema_name: "test"
+      table_name: "t1"
+    }
+    key_field_metadata {
+      type: INTEGER
+      name: "pk"
+    }
+    set_field_metadata {
+      type: INTEGER
+      name: "col_int1"
+    }
+  }
+  update_data {
+    segment_id: 1
+    end_segment: true
+    record {
+      key_value: "1"
+      after_value: "2"
+      is_null: false
+    }
+    record {
+      key_value: "3"
+      after_value: "3"
+      is_null: false
+    }
+  }
+}
+statement {
+  type: INSERT
+  START_TIMESTAMP
+  END_TIMESTAMP
+  insert_header {
+    table_metadata {
+      schema_name: "test"
+      table_name: "t1"
+    }
+    field_metadata {
+      type: INTEGER
+      name: "pk"
+    }
+    field_metadata {
+      type: INTEGER
+      name: "col_int1"
+    }
+    field_metadata {
+      type: INTEGER
+      name: "col_int2"
+    }
+    field_metadata {
+      type: INTEGER
+      name: "col_int_not_null"
+    }
+  }
+  insert_data {
+    segment_id: 1
+    end_segment: true
+    record {
+      insert_value: "5"
+      insert_value: "6"
+      insert_value: "6"
+      insert_value: "6"
+      is_null: false
+      is_null: false
+      is_null: false
+      is_null: false
+    }
+  }
+}
+
+CREATE TABLE t2 (pk INT NOT NULL AUTO_INCREMENT PRIMARY KEY, a INT);
+INSERT INTO t2 (a) VALUES (1),(2), (NULL);
+BEGIN;
+INSERT INTO t1 (col_int_not_null) SELECT a FROM t2;
+ERROR 23000: Column 'col_int_not_null' cannot be null
+INSERT INTO t1 (col_int1, col_int2, col_int_not_null) VALUES (7,7,7);
+COMMIT;
+
+We should have a Transaction with 1 insert Statement
+SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
+PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS))
+transaction_context {
+  server_id: 1
+  transaction_id: 5
+  START_TIMESTAMP
+  END_TIMESTAMP
+}
+statement {
+  type: INSERT
+  START_TIMESTAMP
+  END_TIMESTAMP
+  insert_header {
+    table_metadata {
+      schema_name: "test"
+      table_name: "t1"
+    }
+    field_metadata {
+      type: INTEGER
+      name: "pk"
+    }
+    field_metadata {
+      type: INTEGER
+      name: "col_int1"
+    }
+    field_metadata {
+      type: INTEGER
+      name: "col_int2"
+    }
+    field_metadata {
+      type: INTEGER
+      name: "col_int_not_null"
+    }
+  }
+  insert_data {
+    segment_id: 1
+    end_segment: true
+    record {
+      insert_value: "8"
+      insert_value: "7"
+      insert_value: "7"
+      insert_value: "7"
+      is_null: false
+      is_null: false
+      is_null: false
+      is_null: false
+    }
+  }
+}
+
+DROP TABLE t1;
+DROP TABLE t2;
+SET GLOBAL transaction_log_truncate_debug= true;
 
=== added file 'plugin/transaction_log/tests/t/bug660779-master.opt'
--- plugin/transaction_log/tests/t/bug660779-master.opt	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/t/bug660779-master.opt	2010-10-26 14:47:53 +0000
@@ -0,0 +1,1 @@
+--transaction-log.enable --scheduler=multi_thread
 
=== added file 'plugin/transaction_log/tests/t/bug660779.test'
--- plugin/transaction_log/tests/t/bug660779.test	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/tests/t/bug660779.test	2010-10-26 14:47:53 +0000
@@ -0,0 +1,58 @@
+CREATE TABLE t1 (
+  pk INT NOT NULL AUTO_INCREMENT,
+  col_int1 INT,
+  col_int2 INT,
+  col_int_not_null INT NOT NULL,
+  PRIMARY KEY (pk));
+
+INSERT INTO t1 (col_int1, col_int2, col_int_not_null) VALUES (1,1,1);
+INSERT INTO t1 (col_int1, col_int2, col_int_not_null) VALUES (NULL,1,1);
+INSERT INTO t1 (col_int1, col_int2, col_int_not_null) VALUES (2,1,3);
+
+SET GLOBAL transaction_log_truncate_debug= true;
+
+--test with no previous Statement message
+BEGIN;
+--ERROR ER_BAD_NULL_ERROR
+UPDATE t1 SET col_int_not_null = col_int1 WHERE col_int2 = 1;
+INSERT INTO t1 (col_int1, col_int2, col_int_not_null) VALUES (5,5,5);
+COMMIT;
+
+--echo
+--echo We should have a Transaction with a single insert Statement
+--replace_regex /start_timestamp: [0-9]+/START_TIMESTAMP/g /end_timestamp: [0-9]+/END_TIMESTAMP/g /creation_timestamp: [0-9]+/CREATE_TIMESTAMP/ /update_timestamp: [0-9]+/UPDATE_TIMESTAMP/
+
+SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
+
+BEGIN;
+UPDATE t1 SET col_int1 = (col_int1 + 1) WHERE col_int2 = 1;
+--ERROR ER_BAD_NULL_ERROR
+UPDATE t1 SET col_int_not_null = col_int1 WHERE col_int2 = 1;
+INSERT INTO t1 (col_int1, col_int2, col_int_not_null) VALUES (6,6,6);
+COMMIT;
+
+--echo
+--echo We should have a Transaction with 1 update and 1 insert Statement
+--replace_regex /start_timestamp: [0-9]+/START_TIMESTAMP/g /end_timestamp: [0-9]+/END_TIMESTAMP/g /creation_timestamp: [0-9]+/CREATE_TIMESTAMP/ /update_timestamp: [0-9]+/UPDATE_TIMESTAMP/
+
+SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
+
+CREATE TABLE t2 (pk INT NOT NULL AUTO_INCREMENT PRIMARY KEY, a INT);
+INSERT INTO t2 (a) VALUES (1),(2), (NULL);
+
+BEGIN;
+--ERROR ER_BAD_NULL_ERROR
+INSERT INTO t1 (col_int_not_null) SELECT a FROM t2;
+INSERT INTO t1 (col_int1, col_int2, col_int_not_null) VALUES (7,7,7);
+COMMIT;
+
+--echo
+--echo We should have a Transaction with 1 insert Statement
+--replace_regex /start_timestamp: [0-9]+/START_TIMESTAMP/g /end_timestamp: [0-9]+/END_TIMESTAMP/g /creation_timestamp: [0-9]+/CREATE_TIMESTAMP/ /update_timestamp: [0-9]+/UPDATE_TIMESTAMP/
+
+SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
+
+
+DROP TABLE t1;
+DROP TABLE t2;
+SET GLOBAL transaction_log_truncate_debug= true;