Merge lp:~paul-mccullagh/drizzle/re-merge-1.1 into lp:~drizzle-trunk/drizzle/development

[Paul McCullagh]

This patch fixes bug #572029: Can't load pbxt plugin

It also cleans up some changes to PBXT, and merges bug fixes from the 1.1 trunk.

Param build passes, on average 85% of the tests pass when run with PBXT as the default engine.

=== modified file 'plugin/pbxt/src/cache_xt.cc'
--- plugin/pbxt/src/cache_xt.cc	2010-04-20 23:05:58 +0000
+++ plugin/pbxt/src/cache_xt.cc	2010-05-03 14:18:27 +0000
@@ -377,7 +377,7 @@
 	DcSegmentPtr	seg = NULL;
 	XTIndBlockPtr	xblock;
 
-        (void)thread;
+	(void) thread; /*DRIZZLED*/
 
 	/* The lock order is:
 	 * 1. Cache segment (cs_lock) - This is only by ind_free_block()!
@@ -835,7 +835,8 @@
 	u_int			file_id;
 	xtIndexNodeID	address;
 	DcSegmentPtr	seg;
-        (void)ot;
+
+	(void) ot; /*DRIZZLED*/
 
 #ifdef DEBUG_CHECK_IND_CACHE
 	xt_ind_check_cache(NULL);

=== modified file 'plugin/pbxt/src/database_xt.cc'
--- plugin/pbxt/src/database_xt.cc	2010-04-08 16:11:29 +0000
+++ plugin/pbxt/src/database_xt.cc	2010-05-03 14:18:27 +0000
@@ -1545,7 +1545,7 @@
 {
 	DBThreadDataPtr	td = (DBThreadDataPtr) self->t_data;
 	XTDatabaseHPtr	db = td->td_db;
-	volatile int				i = 0;
+	volatile int	i = 0;
 
 	/* Note, the MySQL thread will be free when the this
 	 * thread quits.
@@ -1916,7 +1916,7 @@
 	virtual void	tk_release();
 };
 
-xtBool XTTestTask::tk_task(XTThreadPtr)
+xtBool XTTestTask::tk_task(XTThreadPtr XT_UNUSED(thread))
 {
 	sleep(tt_sleep_time);
 	return OK;

=== modified file 'plugin/pbxt/src/datadic_xt.cc'
--- plugin/pbxt/src/datadic_xt.cc	2010-04-08 16:11:29 +0000
+++ plugin/pbxt/src/datadic_xt.cc	2010-05-03 14:18:27 +0000
@@ -396,7 +396,7 @@
 struct charset_info_st;
 
 class XTTokenizer {
-	MX_CHARSET_INFO				*tkn_charset;
+	MX_CHARSET_INFO			*tkn_charset;
 	char					*tkn_cstring;
 	char					*tkn_curr_pos;
 	XTToken					*tkn_current;
@@ -1324,7 +1324,7 @@
 class XTCreateTable : public XTParseTable {
 	public:
 	bool					ct_convert;
-	MX_CHARSET_INFO	*ct_charset;
+	MX_CHARSET_INFO			*ct_charset;
 	XTPathStrPtr			ct_tab_path;
 	u_int					ct_contraint_no;
 	XTDDTable				*ct_curr_table;

=== modified file 'plugin/pbxt/src/datalog_xt.cc'
--- plugin/pbxt/src/datalog_xt.cc	2010-04-14 16:29:40 +0000
+++ plugin/pbxt/src/datalog_xt.cc	2010-05-03 14:18:27 +0000
@@ -1149,6 +1149,11 @@
 xtBool XTDataLogBuffer::dlb_close_log(XTThreadPtr thread)
 {
 	if (dlb_data_log) {
+		if (dlb_data_log->dlf_log_file) {
+			if (!dl_write_log_header(dlb_data_log, dlb_data_log->dlf_log_file, 0, thread))
+				return FAILED;
+		}
+
 		/* Flush and commit the data in the old log: */
 		if (!dlb_flush_log(TRUE, thread))
 			return FAILED;
@@ -1204,7 +1209,7 @@
 		if (!xt_pwrite_file(dlb_data_log->dlf_log_file, dlb_buffer_offset, dlb_buffer_len, dlb_log_buffer, &thread->st_statistics.st_data, thread))
 			return FAILED;
 #ifdef DEBUG
-		if (dlb_buffer_offset + dlb_buffer_len > dlb_max_write_offset)
+		if (dlb_buffer_offset + (xtLogOffset) dlb_buffer_len > dlb_max_write_offset)
 			dlb_max_write_offset = dlb_buffer_offset + (xtLogOffset) dlb_buffer_len;
 #endif
 		dlb_buffer_len = 0;
@@ -1745,8 +1750,8 @@
 	xtLogOffset			src_log_offset;
 	xtLogID				curr_log_id;
 	xtLogOffset			curr_log_offset;
-	xtLogID				dest_log_id;
-	xtLogOffset			dest_log_offset;
+	xtLogID				dest_log_id = 0;
+	xtLogOffset			dest_log_offset = 0;
 	off_t				garbage_count = 0;
 
 	memset(&cs, 0, sizeof(XTCompactorStateRec));

=== modified file 'plugin/pbxt/src/discover_xt.cc'
--- plugin/pbxt/src/discover_xt.cc	2010-04-11 17:04:06 +0000
+++ plugin/pbxt/src/discover_xt.cc	2010-05-03 14:18:27 +0000
@@ -23,313 +23,26 @@
 
 #include "xt_config.h"
 
-#ifdef PBXT_SYS_TAB
-
 #ifndef DRIZZLED
+
 #include "mysql_priv.h"
 #include "item_create.h"
 #include <m_ctype.h>
-#else
-#include <drizzled/session.h>
-#include <drizzled/sql_base.h>
-#include <drizzled/statement/alter_table.h>
-#include <drizzled/sql_table.h>
-#include <algorithm>
-#include <sstream>
-namespace drizzled { 
-extern pid_t current_pid;
-namespace internal {
-size_t unpack_filename(char * to, const char *from);
-}
-}
-using namespace drizzled;
-using namespace drizzled::internal;
-#endif
 
 #include "strutil_xt.h"
 #include "ha_pbxt.h"
 #include "discover_xt.h"
 #include "ha_xtsys.h"
 
-#ifndef DRIZZLED
 #if MYSQL_VERSION_ID >= 50404
 #define DOT_STR(x)			x.str
 #else
 #define DOT_STR(x)			x
 #endif
-#endif
 
-//#ifndef DRIZZLED
 #define LOCK_OPEN_HACK_REQUIRED
-//#endif // DRIZZLED
 
 #ifdef LOCK_OPEN_HACK_REQUIRED
-#ifdef DRIZZLED
-
-using namespace drizzled;
-using namespace std;
-
-#define mysql_create_table_no_lock hacked_mysql_create_table_no_lock
-
-namespace drizzled {
-
-int rea_create_table(Session *session,
-                     TableIdentifier &identifier,
-                     message::Table &table_proto,
-                     HA_CREATE_INFO *create_info,
-                     List<CreateField> &create_field,
-                     uint32_t key_count,KEY *key_info);
-
-int mysql_prepare_create_table(Session *session,
-                                      HA_CREATE_INFO *create_info,
-                                      message::Table &create_proto,
-                                      AlterInfo *alter_info,
-                                      bool tmp_table,
-                                      uint32_t *db_options,
-                                      KEY **key_info_buffer,
-                                      uint32_t *key_count,
-                                      int select_field_count);
-
-}
-
-static uint32_t build_tmptable_filename(Session* session,
-                                        char *buff, size_t bufflen)
-{
-  uint32_t length;
-  ostringstream path_str, post_tmpdir_str;
-  string tmp;
-
-  path_str << drizzle_tmpdir;
-  post_tmpdir_str << "/" << TMP_FILE_PREFIX << current_pid;
-  post_tmpdir_str << session->thread_id << session->tmp_table++;
-  tmp= post_tmpdir_str.str();
-
-  transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower);
-
-  path_str << tmp;
-
-  if (bufflen < path_str.str().length())
-    length= 0;
-  else
-    length= unpack_filename(buff, path_str.str().c_str());
-
-  return length;
-}
-
-static bool mysql_create_table_no_lock(Session *session,
-                                const char *db, const char *table_name,
-                                HA_CREATE_INFO *create_info,
-                                message::Table *table_proto,
-                                AlterInfo *alter_info,
-                                bool internal_tmp_table,
-                                uint32_t select_field_count,
-				bool skip_existing)
-{
-  char          path[FN_REFLEN];
-  uint32_t          path_length;
-  uint          db_options, key_count;
-  KEY           *key_info_buffer;
-  Cursor        *file;
-  bool          error= true;
-  /* Check for duplicate fields and check type of table to create */
-  if (!alter_info->create_list.elements)
-  {
-    my_message(ER_TABLE_MUST_HAVE_COLUMNS, ER(ER_TABLE_MUST_HAVE_COLUMNS),
-               MYF(0));
-    return true;
-  }
-  assert(strcmp(table_name,table_proto->name().c_str())==0);
-  //if (check_engine(session, table_name, table_proto, create_info))
-  //  return true;
-  db_options= create_info->table_options;
-  if (create_info->row_type == ROW_TYPE_DYNAMIC)
-    db_options|=HA_OPTION_PACK_RECORD;
-  
-  /*if (!(file= create_info->db_type->getCursor((TableShare*) 0, session->mem_root)))
-  {
-    my_error(ER_OUTOFMEMORY, MYF(0), sizeof(Cursor));
-    return true;
-  }*/
-
-  TableIdentifier ident(db, table_name, table_proto->type());
-
-  /* PMC - Done to avoid getting the partition handler by mistake! */
-  if (!(file= new (session->mem_root) ha_xtsys(pbxt_hton, *TableShare::getShare(ident))))
-  {
-    my_error(ER_OUTOFMEMORY, MYF(0), sizeof(Cursor));
-    return true;
-  }
-
-  set_table_default_charset(create_info, (char*) db);
-
-  if (mysql_prepare_create_table(session, 
-                                 create_info,
-                                 *table_proto,
-                                 alter_info,
-                                 internal_tmp_table,
-                                 &db_options,
-				 &key_info_buffer, &key_count,
-                                 select_field_count))
-    goto err;
-
-      /* Check if table exists */
-  if (table_proto->type() == message::Table::TEMPORARY)
-  {
-    path_length= build_tmptable_filename(session, path, sizeof(path));
-  }
-  else
-  {
- #ifdef FN_DEVCHAR
-    /* check if the table name contains FN_DEVCHAR when defined */
-    if (strchr(table_name, FN_DEVCHAR))
-    {
-      my_error(ER_WRONG_TABLE_NAME, MYF(0), table_name);
-      return true;
-    }
-#endif
-    std::string path_str;
-    path_length= build_table_filename(path_str, db, table_name, internal_tmp_table);
-  }
-
-  /* Check if table already exists */
-  if ((table_proto->type() == message::Table::TEMPORARY) &&
-      session->find_temporary_table(db, table_name))
-  {
-    if (skip_existing)
-    {
-      create_info->table_existed= 1;            // Mark that table existed
-      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
-                          ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
-                          table_name);
-      error= 0;
-      goto err;
-    }
-    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
-    goto err;
-  }
-
-  //pthread_mutex_lock(&LOCK_open); /* CREATE TABLE (some confussion on naming, double check) */
-  if (!internal_tmp_table && table_proto->type() != message::Table::TEMPORARY)
-  {
-    if (plugin::StorageEngine::getTableDefinition(*session,
-                                                  ident, 
-                                                  *table_proto,
-                                                  false) == EEXIST)
-    {
-      if (skip_existing)
-      {
-        error= false;
-        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
-                            ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
-                            table_name);
-        create_info->table_existed= 1;          // Mark that table existed
-      }
-      else
-        my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
-
-      goto unlock_and_end;
-    }
-    /*
- *       We don't assert here, but check the result, because the table could be
- *             in the table definition cache and in the same time the .frm could be
- *                   missing from the disk, in case of manual intervention which deletes
- *                         the .frm file. The user has to use FLUSH TABLES; to clear the cache.
- *                               Then she could create the table. This case is pretty obscure and
- *                                     therefore we don't introduce a new error message only for it.
- *                                         */
-    if (TableShare::getShare(ident))
-    {
-      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
-      goto unlock_and_end;
-    }
-  }
-  /*
- *     Check that table with given name does not already
- *         exist in any storage engine. In such a case it should
- *             be discovered and the error ER_TABLE_EXISTS_ERROR be returned
- *                 unless user specified CREATE TABLE IF EXISTS
- *                     The LOCK_open mutex has been locked to make sure no
- *                         one else is attempting to discover the table. Since
- *                             it's not on disk as a frm file, no one could be using it!
- *                               */
-  if (table_proto->type() != message::Table::TEMPORARY)
-  {
-    bool create_if_not_exists = skip_existing;
-
-    std::string path_str;
-    uint32_t          table_path_length;
-
-    table_path_length= build_table_filename(path_str, db, table_name, false);
-
-    int retcode= plugin::StorageEngine::getTableDefinition(*session,
-                                                           ident, 
-                                                           *table_proto,
-                                                           false);
-    switch (retcode)
-    {
-      case ENOENT:
-        /* Normal case, no table exists. we can go and create it */
-        break;
-      case EEXIST:
-        if (create_if_not_exists)
-        {
-          error= false;
-          push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
-                              ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
-                              table_name);
-          create_info->table_existed= 1;                // Mark that table existed
-          goto unlock_and_end;
-        }
-        my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
-        goto unlock_and_end;
-      default:
-        my_error(retcode, MYF(0),table_name);
-        goto unlock_and_end;
-    }
-  }
-
-  session->set_proc_info("creating table");
-  create_info->table_existed= 0;                // Mark that table is created
-
-  create_info->table_options=db_options;
-
-  if (rea_create_table(session, ident,
-                       *table_proto,
-                       create_info, alter_info->create_list,
-                       key_count, key_info_buffer))
-    goto unlock_and_end;
-
-  if (table_proto->type() == message::Table::TEMPORARY)
-  {
-    /* Open table and put in temporary table list */
-    if (!(session->open_temporary_table(ident)))
-    {
-      (void) session->rm_temporary_table(ident);
-      goto unlock_and_end;
-    }
-  }
-
-  /*
- *     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 (!internal_tmp_table &&
-      ((table_proto->type() != message::Table::TEMPORARY)))
-    write_bin_log(session, session->getQueryString().c_str());
-  error= false;
-unlock_and_end:
-  //pthread_mutex_unlock(&LOCK_open);
-
-err:
-  session->set_proc_info("After create");
-  delete file;
-  return(error);
-}
-
-#else // MySQL case
 ///////////////////////////////
 /*
  * Unfortunately I cannot use the standard mysql_create_table_no_lock() because it will lock "LOCK_open"
@@ -1568,51 +1281,27 @@
 ////// END OF CUT AND PASTES FROM  sql_table.cc ////////
 ////////////////////////////////////////////////////////
 
-#endif // DRIZZLED
 #endif // LOCK_OPEN_HACK_REQUIRED
 
 //------------------------------
 int xt_create_table_frm(handlerton *hton, THD* thd, const char *db, const char *name, DT_FIELD_INFO *info, DT_KEY_INFO *XT_UNUSED(keys), xtBool skip_existing)
 {
-#ifdef DRIZZLED
-#define MYLEX_CREATE_INFO create_info
-#else
-#define MYLEX_CREATE_INFO mylex.create_info 
-#endif
-
-#ifdef DRIZZLED
-	drizzled::statement::AlterTable *stmt = new drizzled::statement::AlterTable(thd);
-	HA_CREATE_INFO create_info;
-	//AlterInfo alter_info;
-	drizzled::message::Table table_proto;
-
-	static const char *ext = ".dfe";
-	static const int ext_len = 4;
-
-	table_proto.mutable_engine()->mutable_name()->assign("PBXT");
-#else
 	static const char *ext = ".frm";
 	static const int ext_len = 4;
-#endif
 	int err = 1;
 	char field_length_buffer[12], *field_length_ptr;
 	LEX  *save_lex= thd->lex, mylex;
 
-	memset(&MYLEX_CREATE_INFO, 0, sizeof(HA_CREATE_INFO));
+	memset(&mylex.create_info, 0, sizeof(HA_CREATE_INFO));
 
 	thd->lex = &mylex;
 	lex_start(thd);
-#ifdef DRIZZLED
-        mylex.statement = stmt;
-#endif
 	
 	/* setup the create info */
-	MYLEX_CREATE_INFO.db_type = hton;
+	mylex.create_info.db_type = hton;
 
-#ifndef DRIZZLED 
 	mylex.create_info.frm_only = 1;
-#endif
- 	MYLEX_CREATE_INFO.default_table_charset = system_charset_info;
+ 	mylex.create_info.default_table_charset = system_charset_info;
 	
 	/* setup the column info. */
 	while (info->field_name) {		
@@ -1629,13 +1318,6 @@
 		 } else 
 			field_length_ptr = NULL;
 
-#ifdef DRIZZLED
-		if (add_field_to_list(thd, &field_name, info->field_type, field_length_ptr, info->field_decimal_length,
-			info->field_flags,
-            COLUMN_FORMAT_TYPE_FIXED,
-		    NULL /*default_value*/, NULL /*on_update_value*/, &comment, NULL /*change*/,
-            NULL /*interval_list*/, info->field_charset))
-#else
 		if (add_field_to_list(thd, &field_name, info->field_type, field_length_ptr, info->field_decimal_length,
 			info->field_flags,
 #if MYSQL_VERSION_ID >= 50404
@@ -1644,7 +1326,6 @@
 #endif
 		       NULL /*default_value*/, NULL /*on_update_value*/, &comment, NULL /*change*/, 
 		       NULL /*interval_list*/, info->field_charset, 0 /*uint_geom_type*/)) 
-#endif
 			goto error;
 
 
@@ -1668,18 +1349,8 @@
 	}
 	
 	/* Create an internal temp table */
-#ifdef DRIZZLED
-    table_proto.set_name(name);
-    table_proto.set_type(drizzled::message::Table::STANDARD);
-    table_proto.set_schema(db);
-    table_proto.set_creation_timestamp(time(NULL));
-    table_proto.set_update_timestamp(time(NULL));
-	if (mysql_create_table_no_lock(thd, db, name, &create_info, &table_proto, &stmt->alter_info, 1, 0, skip_existing)) 
-		goto error;
-#else
 	if (mysql_create_table_no_lock(thd, db, name, &mylex.create_info, &mylex.alter_info, 1, 0)) 
 		goto error;
-#endif
 
 	noerror:
 	err = 0;

=== modified file 'plugin/pbxt/src/filesys_xt.cc'
--- plugin/pbxt/src/filesys_xt.cc	2010-04-26 11:13:26 +0000
+++ plugin/pbxt/src/filesys_xt.cc	2010-05-03 14:18:27 +0000
@@ -1281,7 +1281,7 @@
 	return OK;
 }
 
-static xtBool fs_rewrite_file(XTOpenFilePtr of, off_t offset, size_t size, void *data, XTIOStatsPtr stat, XTThreadPtr)
+static xtBool fs_rewrite_file(XTOpenFilePtr of, off_t offset, size_t size, void *data, XTIOStatsPtr stat, XTThreadPtr XT_UNUSED(thread))
 {
 #ifdef XT_TIME_DISK_WRITES
 	xtWord8		s;
@@ -1977,6 +1977,7 @@
 		}
 		case XT_FT_HEAP: {
 			XTFileHeapPtr	fh = of->x.of_heap;
+
 			thd_id = thread->t_id;
 
 #ifdef XT_TIME_DISK_READS

=== modified file 'plugin/pbxt/src/ha_pbxt.cc'
--- plugin/pbxt/src/ha_pbxt.cc	2010-04-20 19:05:03 +0000
+++ plugin/pbxt/src/ha_pbxt.cc	2010-05-03 14:18:27 +0000
@@ -494,6 +494,7 @@
 	self->st_abort_trans = FALSE;
 	self->st_stat_ended = FALSE;
 	self->st_stat_trans = FALSE;
+	self->st_non_temp_updated = FALSE;
 	XT_PRINT0(self, "xt_xn_begin\n");
 	xt_xres_wait_for_recovery(self, XT_RECOVER_SWEPT);
 }
@@ -4628,12 +4629,6 @@
 				self->st_statistics.st_stat_read++;
 			self->st_stat_modify = FALSE;
 			self->st_import_stat = XT_IMP_NO_IMPORT;
-
-			/* Only reset this if there is no transactions running, and
-			 * no tables are open!
-			 */
-			if (!self->st_xact_data)
-				self->st_non_temp_opened = FALSE;
 		}
 
 		if (pb_table_locked) {
@@ -4846,10 +4841,6 @@
 #endif
 		}
 
-		/* Any open table can cause this to be FALSE: */
-		if (!XT_IS_TEMP_TABLE(pb_open_tab->ot_table->tab_dic.dic_tab_flags))
-			self->st_non_temp_opened = TRUE;
-
 		/* Start a statment transaction: */
 		/* {START-STAT-HACK} The problem that ha_commit_trans() is not
 		 * called by MySQL seems to be fixed (tests confirm this).

=== modified file 'plugin/pbxt/src/ha_pbxt.h'
--- plugin/pbxt/src/ha_pbxt.h	2010-04-21 02:28:11 +0000
+++ plugin/pbxt/src/ha_pbxt.h	2010-05-03 14:18:27 +0000
@@ -353,7 +353,6 @@
 #define thd_query(t)						&(t)->query
 #define thd_slave_thread(t)					(t)->slave_thread
 #define thd_binlog_format(t)				(t)->variables.binlog_format
-#define thd_mark_transaction_to_rollback(t)	mark_transaction_to_rollback(t, all)
 #endif // INNODB_COMPATIBILITY_HOOKS */
 #endif /* !DRIZZLED */
 

=== modified file 'plugin/pbxt/src/ha_xtsys.cc'
--- plugin/pbxt/src/ha_xtsys.cc	2010-04-08 16:11:29 +0000
+++ plugin/pbxt/src/ha_xtsys.cc	2010-05-03 14:18:27 +0000
@@ -58,18 +58,20 @@
  * HANDLER INTERFACE
  */
 
+#ifdef DRIZZLED
 ha_xtsys::ha_xtsys(handlerton *hton, TableShare& table_arg):
-#ifdef DRIZZLED
 handler(*hton, table_arg),
+ha_open_tab(NULL)
+{
+}
 #else
+ha_xtsys::ha_xtsys(handlerton *hton, TABLE_SHARE *table_arg):
 handler(hton, table_arg),
-#endif
 ha_open_tab(NULL)
 {
-#ifndef DRIZZLED
 	init();
+}
 #endif
-}
 
 static const char *ha_pbms_exts[] = {
 	"",

=== modified file 'plugin/pbxt/src/index_xt.h'
--- plugin/pbxt/src/index_xt.h	2010-04-26 11:13:26 +0000
+++ plugin/pbxt/src/index_xt.h	2010-05-03 14:18:27 +0000
@@ -106,6 +106,8 @@
 struct XTIndex;
 struct XTIndBlock;
 struct XTTable;
+struct XTThread;
+class Field;
 
 /*
  * INDEX ROLLBACK

=== modified file 'plugin/pbxt/src/myxt_xt.cc'
--- plugin/pbxt/src/myxt_xt.cc	2010-04-16 05:36:53 +0000
+++ plugin/pbxt/src/myxt_xt.cc	2010-05-03 14:18:27 +0000
@@ -312,6 +312,11 @@
                memset((byte*) key, 0,(size_t) (ind->mi_key_size) );
 #endif
 
+#ifdef HAVE_valgrind
+       if (ind->mi_fix_key)
+               memset((byte*) key, 0,(size_t) (ind->mi_key_size) );
+#endif
+
 	start = key;
  	for (u_int i=0; i<ind->mi_seg_count; i++, keyseg++)
 	{
@@ -2005,12 +2010,8 @@
 {
 	THD			*thd = current_thd;
 	char		path_buffer[PATH_MAX];
-	char		*table_file_name;
-#ifdef DRIZZLED
-	char		tab_name[XT_IDENTIFIER_NAME_SIZE];
-#endif
+	char		*table_name;
 	char		database_name[XT_IDENTIFIER_NAME_SIZE];
-	char		*ptr;
 	size_t		size;
 	char		*buffer, *path, *db_name, *name;
 	TABLE_SHARE	*share;
@@ -2032,16 +2033,19 @@
 	 * have .frm files!!
 	 */
 	xt_strcpy(PATH_MAX, path_buffer, tab_path->ps_path);
-	table_file_name = xt_last_name_of_path(path_buffer);
+	table_name = xt_last_name_of_path(path_buffer);
+#ifndef DRIZZLED
+	char *ptr;
 
-	if ((ptr = strstr(tab_name, "#P#")))
+	if ((ptr = strstr(table_name, "#P#")))
 		*ptr = 0;
+#endif
 
 	xt_2nd_last_name_of_path(XT_IDENTIFIER_NAME_SIZE, database_name, path_buffer);
 
 	size = sizeof(TABLE) + sizeof(TABLE_SHARE) + 
 		strlen(path_buffer) + 1 +
-		strlen(database_name) + 1 + strlen(table_file_name) + 1;
+		strlen(database_name) + 1 + strlen(table_name) + 1;
 	if (!(buffer = (char *) xt_malloc(self, size)))
 		return NULL;
 	table = (TABLE *) buffer;
@@ -2056,7 +2060,7 @@
 	strcpy(db_name, database_name);
 	buffer += strlen(database_name) + 1;
 	name = buffer;
-	strcpy(name, table_file_name);
+	strcpy(name, table_name);
 
 	/* Required to call 'open_table_from_share'! */
 	LEX *old_lex, new_lex;
@@ -2067,13 +2071,15 @@
 	lex_start(thd);
 
 #ifdef DRIZZLED
+	char		tab_name[XT_IDENTIFIER_NAME_SIZE];
+
 	uint32_t tab_name_len = filename_to_tablename(name, tab_name, XT_IDENTIFIER_NAME_SIZE);	
 	
 	TableIdentifier *ident = NULL;
 	if (table_type == XT_TABLE_TYPE_TEMPORARY) {
 		std::string tmp_path(drizzle_tmpdir);
 		tmp_path.append("/");
-		tmp_path.append(table_file_name);
+		tmp_path.append(table_name);
 		ident = new TableIdentifier(db_name, tab_name, tmp_path);
 	} else if (table_type == XT_TABLE_TYPE_STANDARD) {
         	ident = new TableIdentifier(
@@ -2086,7 +2092,7 @@
 		n.append("/");
 		n.append(db_name);
 		n.append("/");
-		n.append(table_file_name);
+		n.append(table_name);
 		//ident = new TableIdentifier(
 		//	std::string(db_name), 
 		//	std::string(tab_name, tab_name_len), 
@@ -2720,6 +2726,20 @@
 		}
 	}
 
+	/* Ensure that handle data record size is big enough to
+	 * include the extended record reference, in the case of
+	 * variable length rows
+	 */
+	if (!dic_rec_fixed) {
+		if (dic_rec_size < offsetof(XTTabRecExtDRec, re_data))
+			dic_rec_size = offsetof(XTTabRecExtDRec, re_data);
+	}
+#ifdef DEBUG
+	else {
+		ASSERT_NS(dic_rec_size > offsetof(XTTabRecFix, rf_data));
+	}
+#endif
+
 	if (!dic->dic_rec_size) {
 		dic->dic_rec_size = dic_rec_size;
 		dic->dic_rec_fixed = dic_rec_fixed;
@@ -3309,7 +3329,7 @@
  *
  */
 
-#ifdef DRI_IS
+#ifndef DRIZZLED
 static int mx_put_record(THD *thd, TABLE *table)
 {
 	return schema_table_store_record(thd, table);
@@ -3369,7 +3389,7 @@
 
 	return err;
 }
-#endif // DRI_IS
+#endif // !DRIZZLED
 
 xtPublic void myxt_get_status(XTThreadPtr self, XTStringBufferPtr strbuf)
 {

=== modified file 'plugin/pbxt/src/pbms_enabled.cc'
--- plugin/pbxt/src/pbms_enabled.cc	2010-04-19 21:42:39 +0000
+++ plugin/pbxt/src/pbms_enabled.cc	2010-05-03 14:18:27 +0000
@@ -124,9 +124,8 @@
 			}
 			
 			if (length > org_length) {
-                                Session *tmp_session= current_session;
 				// This can only happen if the BLOB URL is actually larger than the BLOB itself.
-				blob = (char *) session->session_alloc(length);
+				blob = (char *) session_alloc(current_session, length);
 				memcpy(blob_rec+packlength, &blob, sizeof(char*));
 			}			
 			memcpy(blob, blob_url_buffer, length);

=== modified file 'plugin/pbxt/src/restart_xt.cc'
--- plugin/pbxt/src/restart_xt.cc	2010-04-08 16:11:29 +0000
+++ plugin/pbxt/src/restart_xt.cc	2010-05-03 14:18:27 +0000
@@ -2578,7 +2578,7 @@
 
 xtBool XTXactRestart::xres_is_checkpoint_pending(xtLogID curr_log_id, xtLogOffset curr_log_offset)
 {
-	return xt_bytes_since_last_checkpoint(xres_db, curr_log_id, curr_log_offset) >= xt_db_checkpoint_frequency / 2;
+	return xt_bytes_since_last_checkpoint(xres_db, curr_log_id, curr_log_offset) >= xt_db_checkpoint_frequency;
 }
 
 /*
@@ -2888,6 +2888,7 @@
 	u_int				curr_writer_total;
 	time_t				now, last_index_flush;
 	xtBool				async = TRUE;
+	xtXactID			sweep_count;
 
 	xt_set_low_priority(self);
 
@@ -2916,8 +2917,14 @@
 		 * And if the sweeper is not idle, then there is also activity!
 		 * And if the writer is active, then we should wait for it as well!
 		 */
+#ifdef XT_SWEEPER_SORT_XACTS
+		sweep_count = db->db_xn_curr_id + 1 - db->db_sw_to_add + db->db_sw_list_size;
+#else
+		sweep_count = db->db_xn_curr_id + 1 - db->db_xn_to_clean_id;
+#endif
 		if (!db->db_xn_long_running_count && 
 			curr_writer_total == db->db_xn_total_writer_count && 
+			!sweep_count &&
 			db->db_sw_idle == XT_THREAD_IDLE && 
 			db->db_wr_idle == XT_THREAD_IDLE) {
 			/* No activity in 2 seconds: */

=== modified file 'plugin/pbxt/src/systab_xt.cc'
--- plugin/pbxt/src/systab_xt.cc	2010-04-11 17:04:06 +0000
+++ plugin/pbxt/src/systab_xt.cc	2010-05-03 14:18:27 +0000
@@ -590,15 +590,10 @@
 
 void XTSystemTableShare::createSystemTables(XTThreadPtr XT_UNUSED(self), XTDatabaseHPtr XT_UNUSED(db))
 {
-#ifdef PBXT_SYS_TAB
+#ifndef DRIZZLED
 	int		i = 0;
 
 	while (xt_internal_tables[i].sts_path) {
-#ifdef DRIZZLED
-                // must ignore errors here
-                drizzled::Session *session = current_thd;
-		//session->main_da.disable_status();
-#endif
 		if (!xt_create_table_frm(pbxt_hton,
 			current_thd, "pbxt",
 			strchr(xt_internal_tables[i].sts_path, '.') + 1,
@@ -607,9 +602,6 @@
 			TRUE /*do not recreate*/))
 			xt_internal_tables[i].sts_exists = TRUE;
 		i++;
-#ifdef DRIZZLED
-		session->main_da.reset_diagnostics_area();	
-#endif
 	}
 #endif
 }

=== modified file 'plugin/pbxt/src/tabcache_xt.cc'
--- plugin/pbxt/src/tabcache_xt.cc	2010-04-08 16:11:29 +0000
+++ plugin/pbxt/src/tabcache_xt.cc	2010-05-03 14:18:27 +0000
@@ -923,7 +923,7 @@
 /*
  * Used by the writer to wake the freeer.
  */
-xtPublic void xt_wr_wake_freeer(XTThreadPtr, XTDatabaseHPtr db)
+xtPublic void xt_wr_wake_freeer(XTThreadPtr XT_UNUSED(self), XTDatabaseHPtr db)
 {
 	/* BUG FIX: Was using tcm_freeer_cond.
 	 * This is incorrect. When the freeer waits for the

=== modified file 'plugin/pbxt/src/table_xt.cc'
--- plugin/pbxt/src/table_xt.cc	2010-04-26 10:27:49 +0000
+++ plugin/pbxt/src/table_xt.cc	2010-05-03 14:18:27 +0000
@@ -537,8 +537,8 @@
 				else if (strcmp(name, "type") == 0) {
 					u_long lvalue = 0;
 
-                                        sscanf(value, "%lu", &lvalue);
-                                        td->td_tab_type = (xtWord1) lvalue;
+					sscanf(value, "%lu", &lvalue);
+					td->td_tab_type = (xtWord1) lvalue;
 				} 
 				else if (strcmp(name, "[table]") == 0)
 					break;
@@ -1292,7 +1292,7 @@
 	XTOpenFilePtr	of_rec, of_ind;
 	XTTableEntryPtr	te_ptr;
 	size_t			tab_format_offset;
-	size_t			tab_head_size= 0;
+	size_t			tab_head_size = 0;
 
 	enter_();
 
@@ -1579,7 +1579,7 @@
 	}
 }
 
-static void tab_init_row_file(XTThreadPtr self, XTOpenFilePtr of_row, XTTableHPtr tab, XTDictionaryPtr)
+static void tab_init_row_file(XTThreadPtr self, XTOpenFilePtr of_row, XTTableHPtr tab, XTDictionaryPtr XT_UNUSED(dic))
 {
 	XTTabRowHeadDRec	row_head;
 
@@ -4442,6 +4442,24 @@
 u_int		next_off_page = 0;
 #endif
 
+static xtBool tab_write_ext_record(XTOpenTablePtr XT_UNUSED(ot), XTTableHPtr tab, XTTabRecInfoPtr rec_info, xtRecordID rec_id, xtLogID log_id, xtLogOffset log_offset, XTThreadPtr thread)
+{
+	xtWord1 tmp_buffer[offsetof(XTactExtRecEntryDRec, er_data)];
+	xtBool	ok;
+
+	memcpy(tmp_buffer, rec_info->ri_log_buf, sizeof(tmp_buffer));
+	rec_info->ri_log_buf->er_status_1 = XT_LOG_ENT_EXT_REC_OK;
+	XT_SET_DISK_4(rec_info->ri_log_buf->er_data_size_4, rec_info->ri_log_data_size);
+	XT_SET_DISK_4(rec_info->ri_log_buf->er_tab_id_4, tab->tab_id);
+	XT_SET_DISK_4(rec_info->ri_log_buf->er_rec_id_4, rec_id);
+	if (tab->tab_dic.dic_tab_flags & XT_TF_MEMORY_TABLE)
+		ok = xt_tab_save_ext_record(tab, log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info->ri_log_data_size, (xtWord1 *) rec_info->ri_log_buf);
+	else
+		ok = thread->st_dlog_buf.dlb_append_log(log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info->ri_log_data_size, (xtWord1 *) rec_info->ri_log_buf, thread);
+	memcpy(rec_info->ri_log_buf, tmp_buffer, sizeof(tmp_buffer));
+	return ok;
+}
+
 static xtBool tab_add_record(XTOpenTablePtr ot, XTTabRecInfoPtr rec_info, u_int status)
 {
 	register XTTableHPtr	tab = ot->ot_table;
@@ -4548,32 +4566,20 @@
 		 */
 		read = ((rec_id - 1) % tab->tab_recs.tci_rows_per_page) != 0;
 
-		if (!tab->tab_recs.xt_tc_write(ot->ot_rec_file, rec_id, 0, rec_info->ri_rec_buf_size, (xtWord1 *) rec_info->ri_fix_rec_buf, &op_seq, read, ot->ot_thread)) {
+		if (!tab->tab_recs.xt_tc_write(ot->ot_rec_file, rec_id, 0, rec_info->ri_rec_buf_size, (xtWord1 *) rec_info->ri_fix_rec_buf, &op_seq, read, thread)) {
 			xt_unlock_mutex_ns(&tab->tab_rec_lock);
 			return FAILED;
 		}
 	}
 	xt_unlock_mutex_ns(&tab->tab_rec_lock);
 
-	if (!xt_xlog_modify_table(tab->tab_id, status, op_seq, 0, next_rec_id, rec_id,  rec_info->ri_rec_buf_size, (xtWord1 *) rec_info->ri_fix_rec_buf, ot->ot_thread))
+	if (!xt_xlog_modify_table(tab->tab_id, status, op_seq, 0, next_rec_id, rec_id,  rec_info->ri_rec_buf_size, (xtWord1 *) rec_info->ri_fix_rec_buf, thread))
 		return FAILED;
 
 	if (rec_info->ri_ext_rec) {
 		/* Write the log buffer overflow: */		
-		rec_info->ri_log_buf->er_status_1 = XT_LOG_ENT_EXT_REC_OK;
-		XT_SET_DISK_4(rec_info->ri_log_buf->er_data_size_4, rec_info->ri_log_data_size);
-		XT_SET_DISK_4(rec_info->ri_log_buf->er_tab_id_4, tab->tab_id);
-		XT_SET_DISK_4(rec_info->ri_log_buf->er_rec_id_4, rec_id);
-		if (tab->tab_dic.dic_tab_flags & XT_TF_MEMORY_TABLE) {
-			if (!xt_tab_save_ext_record(tab, log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info->ri_log_data_size, (xtWord1 *) rec_info->ri_log_buf))
-				return FAILED;
-		}
-		else {
-			if (!thread->st_dlog_buf.dlb_append_log(log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info->ri_log_data_size, (xtWord1 *) rec_info->ri_log_buf, ot->ot_thread)) {
-				/* Failed to write the overflow, free the record allocated above: */
-				return FAILED;
-			}
-		}
+		if (!tab_write_ext_record(ot, tab, rec_info, rec_id, log_id, log_offset, thread))
+			return FAILED;
 	}
 
 	XT_DISABLED_TRACE(("new rec tx=%d val=%d\n", (int) thread->st_xact_data->xd_start_xn_id, (int) rec_id));
@@ -4581,7 +4587,7 @@
 	return OK;
 }
 
-static void tab_delete_record_on_fail(XTOpenTablePtr ot, xtRowID row_id, xtRecordID rec_id, XTTabRecHeadDPtr row_ptr, xtWord1 *rec_data, u_int key_count)
+static void tab_delete_record_on_fail(XTOpenTablePtr ot, xtRowID row_id, xtRecordID rec_id, XTTabRecHeadDPtr XT_UNUSED(row_ptr), xtWord1 *rec_data, u_int key_count)
 {
 	XTExceptionRec	e;
 	xtBool			log_err = TRUE;
@@ -4609,8 +4615,11 @@
 		}
 	}
 
+	/* This is not required because the extended record will be free
+	 * later when the record is freed!
 	if (row_ptr->tr_rec_type_1 == XT_TAB_STATUS_EXT_DLOG || row_ptr->tr_rec_type_1 == XT_TAB_STATUS_EXT_CLEAN)
 		tab_free_ext_record_on_fail(ot, rec_id, (XTTabRecExtDPtr) row_ptr, log_err);
+	 */
 
 	rec_info.ri_fix_rec_buf = (XTTabRecFixDPtr) ot->ot_row_wbuffer;
 	rec_info.ri_rec_buf_size = offsetof(XTTabRecFixDRec, rf_data);
@@ -4909,6 +4918,10 @@
 	u_int					idx_cnt = 0;
 	XTIndexPtr				*ind;
 
+	/* A non-temporary table has been updated: */
+	if (!XT_IS_TEMP_TABLE(tab->tab_dic.dic_tab_flags))
+		self->st_non_temp_updated = TRUE;
+
 	if (!myxt_store_row(ot, &rec_info, (char *) rec_buf))
 		goto failed_0;
 
@@ -5005,7 +5018,7 @@
 		 * order to do this we'd need to read the before-image of the 
 		 * record before modifying it.
 		 */
-		if (!ot->ot_thread->t_exception.e_xt_err)
+		if (!thread->t_exception.e_xt_err)
 			xt_register_xterr(XT_REG_CONTEXT, XT_ERR_NO_BEFORE_IMAGE);
 		return FAILED;
 	}
@@ -5023,7 +5036,7 @@
 				return FAILED;
 		}
 		else {
-			if (!thread->st_dlog_buf.dlb_get_log_offset(&log_id, &log_offset, rec_info->ri_log_data_size + offsetof(XTactExtRecEntryDRec, er_data), ot->ot_thread))
+			if (!thread->st_dlog_buf.dlb_get_log_offset(&log_id, &log_offset, rec_info->ri_log_data_size + offsetof(XTactExtRecEntryDRec, er_data), thread))
 				return FAILED;
 		}
 		XT_SET_LOG_REF(rec_info->ri_ext_rec, log_id, log_offset);
@@ -5034,19 +5047,8 @@
 
 	if (rec_info->ri_ext_rec) {
 		/* Write the log buffer overflow: */		
-		rec_info->ri_log_buf->er_status_1 = XT_LOG_ENT_EXT_REC_OK;
-		XT_SET_DISK_4(rec_info->ri_log_buf->er_data_size_4, rec_info->ri_log_data_size);
-		XT_SET_DISK_4(rec_info->ri_log_buf->er_tab_id_4, tab->tab_id);
-		XT_SET_DISK_4(rec_info->ri_log_buf->er_rec_id_4, rec_id);
-
-		if (tab->tab_dic.dic_tab_flags & XT_TF_MEMORY_TABLE) {
-			if (!xt_tab_save_ext_record(tab, log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info->ri_log_data_size, (xtWord1 *) rec_info->ri_log_buf))
-				return FAILED;
-		}
-		else {
-			if (!thread->st_dlog_buf.dlb_append_log(log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info->ri_log_data_size, (xtWord1 *) rec_info->ri_log_buf, ot->ot_thread))
-				return FAILED;
-		}
+		if (!tab_write_ext_record(ot, tab, rec_info, rec_id, log_id, log_offset, thread))
+			return FAILED;
 	}
 
 	/* Put the index entries back: */
@@ -5078,6 +5080,10 @@
 	xtLogOffset				log_offset;
 	xtBool					prev_ext_rec;
 
+	/* A non-temporary table has been updated: */
+	if (!XT_IS_TEMP_TABLE(tab->tab_dic.dic_tab_flags))
+		self->st_non_temp_updated = TRUE;
+
 	if (!myxt_store_row(ot, &rec_info, (char *) after_buf))
 		goto failed_0;
 
@@ -5094,7 +5100,7 @@
 				goto failed_0;
 		}
 		else {
-			if (!self->st_dlog_buf.dlb_get_log_offset(&log_id, &log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info.ri_log_data_size, ot->ot_thread))
+			if (!self->st_dlog_buf.dlb_get_log_offset(&log_id, &log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info.ri_log_data_size, self))
 				goto failed_0;
 		}
 		XT_SET_LOG_REF(rec_info.ri_ext_rec, log_id, log_offset);
@@ -5121,18 +5127,8 @@
 
 	if (rec_info.ri_ext_rec) {
 		/* Write the log buffer overflow: */		
-		rec_info.ri_log_buf->er_status_1 = XT_LOG_ENT_EXT_REC_OK;
-		XT_SET_DISK_4(rec_info.ri_log_buf->er_data_size_4, rec_info.ri_log_data_size);
-		XT_SET_DISK_4(rec_info.ri_log_buf->er_tab_id_4, tab->tab_id);
-		XT_SET_DISK_4(rec_info.ri_log_buf->er_rec_id_4, rec_id);
-		if (tab->tab_dic.dic_tab_flags & XT_TF_MEMORY_TABLE) {
-			if (!xt_tab_save_ext_record(tab, log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info.ri_log_data_size, (xtWord1 *) rec_info.ri_log_buf))
-				goto failed_1;
-		}
-		else {
-			if (!self->st_dlog_buf.dlb_append_log(log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info.ri_log_data_size, (xtWord1 *) rec_info.ri_log_buf, ot->ot_thread))
-				goto failed_1;
-		}
+		if (!tab_write_ext_record(ot, tab, &rec_info, rec_id, log_id, log_offset, self))
+			goto failed_1;
 	}
 
 	/* Add the index references that have changed: */
@@ -5247,6 +5243,10 @@
 	row_id = ot->ot_curr_row_id;
 	self = ot->ot_thread;
 
+	/* A non-temporary table has been updated: */
+	if (!XT_IS_TEMP_TABLE(tab->tab_dic.dic_tab_flags))
+		self->st_non_temp_updated = TRUE;
+
 	if (!myxt_store_row(ot, &rec_info, (char *) after_buf))
 		goto failed_0;
 
@@ -5260,7 +5260,7 @@
 		goto failed_0;
 
 	/* Link the new variation into the list: */
-	XT_TAB_ROW_WRITE_LOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], ot->ot_thread);
+	XT_TAB_ROW_WRITE_LOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], self);
 
 	if (!xt_tab_get_row(ot, row_id, &curr_var_rec_id))
 		goto failed_1;
@@ -5286,7 +5286,7 @@
 		goto failed_1;
 	XT_DISABLED_TRACE(("set upd tx=%d row=%d rec=%d\n", (int) self->st_xact_data->xd_start_xn_id, (int) row_id, (int) rec_info.ri_rec_id));
 
-	XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], ot->ot_thread);
+	XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], self);
 
 	/* Add the index references: */
 	for (idx_cnt=0, ind=tab->tab_dic.dic_keys; idx_cnt<tab->tab_dic.dic_key_count; idx_cnt++, ind++) {
@@ -5301,7 +5301,7 @@
 			goto failed_2;
 	}
 
-	ot->ot_thread->st_statistics.st_row_update++;
+	self->st_statistics.st_row_update++;
 	return OK;
 
 	failed_2:
@@ -5309,7 +5309,7 @@
 	goto failed_0;
 
 	failed_1:
-	XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], ot->ot_thread);
+	XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], self);
 
 	failed_0:
 	return FAILED;
@@ -5318,10 +5318,15 @@
 xtPublic xtBool xt_tab_delete_record(XTOpenTablePtr ot, xtWord1 *rec_buf)
 {
 	register XTTableHPtr	tab = ot->ot_table;
+	register XTThreadPtr	thread = ot->ot_thread;
 	xtRowID					row_id = ot->ot_curr_row_id;
 	xtRecordID				curr_var_rec_id;
 	XTTabRecInfoRec			rec_info;
 
+	/* A non-temporary table has been updated: */
+	if (!XT_IS_TEMP_TABLE(tab->tab_dic.dic_tab_flags))
+		thread->st_non_temp_updated = TRUE;
+
 	/* Setup a delete record: */
 	rec_info.ri_fix_rec_buf = (XTTabRecFixDPtr) ot->ot_row_wbuffer;
 	rec_info.ri_rec_buf_size = offsetof(XTTabRecFixDRec, rf_data);
@@ -5330,12 +5335,12 @@
 	rec_info.ri_fix_rec_buf->tr_stat_id_1 = 0;
 	XT_SET_DISK_4(rec_info.ri_fix_rec_buf->tr_row_id_4, row_id);
 	XT_SET_DISK_4(rec_info.ri_fix_rec_buf->tr_prev_rec_id_4, ot->ot_curr_rec_id);
-	XT_SET_DISK_4(rec_info.ri_fix_rec_buf->tr_xact_id_4, ot->ot_thread->st_xact_data->xd_start_xn_id);
+	XT_SET_DISK_4(rec_info.ri_fix_rec_buf->tr_xact_id_4, thread->st_xact_data->xd_start_xn_id);
 
 	if (!tab_add_record(ot, &rec_info, XT_LOG_ENT_DELETE))
 		return FAILED;
 
-	XT_TAB_ROW_WRITE_LOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], ot->ot_thread);
+	XT_TAB_ROW_WRITE_LOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], thread);
 
 	if (!xt_tab_get_row(ot, row_id, &curr_var_rec_id))
 		goto failed_1;
@@ -5346,20 +5351,20 @@
 	}
 
 #ifdef TRACE_VARIATIONS
-	xt_ttracef(ot->ot_thread, "update: row=%d rec=%d T%d\n", (int) row_id, (int) rec_info.ri_rec_id, (int) ot->ot_thread->st_xact_data->xd_start_xn_id);
+	xt_ttracef(thread, "update: row=%d rec=%d T%d\n", (int) row_id, (int) rec_info.ri_rec_id, (int) thread->st_xact_data->xd_start_xn_id);
 #endif
 	if (!xt_tab_set_row(ot, XT_LOG_ENT_ROW_ADD_REC, row_id, rec_info.ri_rec_id))
 		goto failed_1;
-	XT_DISABLED_TRACE(("del row tx=%d row=%d rec=%d\n", (int) ot->ot_thread->st_xact_data->xd_start_xn_id, (int) row_id, (int) rec_info.ri_rec_id));
+	XT_DISABLED_TRACE(("del row tx=%d row=%d rec=%d\n", (int) thread->st_xact_data->xd_start_xn_id, (int) row_id, (int) rec_info.ri_rec_id));
 
-	XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], ot->ot_thread);
+	XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], thread);
 
 	if (ot->ot_table->tab_dic.dic_table->dt_trefs) {
 		if (!ot->ot_table->tab_dic.dic_table->deleteRow(ot, rec_buf))
 			goto failed_2;
 	}
 
-	ot->ot_thread->st_statistics.st_row_delete++;
+	thread->st_statistics.st_row_delete++;
 	return OK;
 
 	failed_2:
@@ -5367,7 +5372,7 @@
 	return FAILED;
 
 	failed_1:
-	XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], ot->ot_thread);
+	XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], thread);
 	return FAILED;
 }
 
@@ -5880,7 +5885,7 @@
  * EXTENDED DATA FOR RAM TABLES
  */
 
-xtPublic xtBool xt_tab_get_ext_slot(XTTableHPtr tab, xtLogID *log_id, xtLogOffset *log_offset, size_t /*req_size*/)
+xtPublic xtBool xt_tab_get_ext_slot(XTTableHPtr tab, xtLogID *log_id, xtLogOffset *log_offset, size_t XT_UNUSED(req_size))
 {
 	size_t new_slot;
 

=== modified file 'plugin/pbxt/src/table_xt.h'
--- plugin/pbxt/src/table_xt.h	2010-04-28 18:23:22 +0000
+++ plugin/pbxt/src/table_xt.h	2010-05-03 14:18:27 +0000
@@ -191,7 +191,7 @@
 	XTDiskValue2			tf_tab_unused_2;						/* Unused, set to zero */
 	XTDiskValue4			tf_rec_size_4;							/* The maximum size of records in the table. */
 	XTDiskValue1			tf_rec_fixed_1;							/* Set to 1 if this table contains fixed length records. */
-	XTDiskValue1			tf_reserved_1;
+	XTDiskValue1			tf_reserved_1;							/* - */
 	XTDiskValue8			tf_min_auto_inc_8;						/* This is the minimum auto-increment value. */
 	xtWord1					tf_reserved[64];						/* Reserved, set to 0. */
 	char					tf_definition[XT_VAR_LENGTH];			/* A cstring, currently it only contains the foreign key information. */

=== modified file 'plugin/pbxt/src/thread_xt.cc'
--- plugin/pbxt/src/thread_xt.cc	2010-04-08 16:11:29 +0000
+++ plugin/pbxt/src/thread_xt.cc	2010-05-03 14:18:27 +0000
@@ -50,7 +50,7 @@
 #include "database_xt.h"
 
 #ifdef DEBUG
-#define DEBUG_NO_ACTIVITY
+//#define DEBUG_NO_ACTIVITY
 #endif
 
 void xt_db_exit_thread(XTThreadPtr self);

=== modified file 'plugin/pbxt/src/thread_xt.h'
--- plugin/pbxt/src/thread_xt.h	2010-04-26 11:13:26 +0000
+++ plugin/pbxt/src/thread_xt.h	2010-05-03 14:18:27 +0000
@@ -264,7 +264,7 @@
 		tk_notify_threads.pl_exit();
 	}
 
-	virtual void	tk_init(struct XTThread *) { }
+	virtual void	tk_init(struct XTThread *XT_UNUSED(self)) { }
 	virtual void	tk_exit() { delete this; }
 	virtual void	tk_lock() { }
 	virtual void	tk_unlock() { }
@@ -395,7 +395,7 @@
 	xtBool1					st_stat_ended;					/* TRUE if the statement was ended. */
 	xtBool1					st_stat_trans;					/* TRUE if a statement transaction is running (started on UPDATE). */
 	xtBool1					st_stat_modify;					/* TRUE if the statement is an INSERT/UPDATE/DELETE */
-	xtBool1					st_non_temp_opened;				/* TRUE if a non-temp tables was opened! */
+	xtBool1					st_non_temp_updated;			/* TRUE if a non-temp tables was updated! */
 	xtWord1					st_import_stat;					/* Non-zero if this is an import statement (ALTER, LOAD, REPAIR, etc). */
 #ifdef XT_IMPLEMENT_NO_ACTION
 	XTBasicListRec			st_restrict_list;				/* These records have been deleted and should have no reference. */

=== modified file 'plugin/pbxt/src/xaction_xt.cc'
--- plugin/pbxt/src/xaction_xt.cc	2010-04-08 16:11:29 +0000
+++ plugin/pbxt/src/xaction_xt.cc	2010-05-03 14:18:27 +0000
@@ -1221,7 +1221,7 @@
 			/* Write and flush the transaction log:
 			 * We only flush if this was not a temp table.
 			 */
-			if (!xt_xlog_log_data(thread, sizeof(XTXactEndEntryDRec), (XTXactLogBufferDPtr) &entry, thread->st_non_temp_opened ? XT_XLOG_NO_WRITE_NO_FLUSH : xt_db_flush_log_at_trx_commit)) {
+			if (!xt_xlog_log_data(thread, sizeof(XTXactEndEntryDRec), (XTXactLogBufferDPtr) &entry, thread->st_non_temp_updated ? xt_db_flush_log_at_trx_commit : XT_XLOG_NO_WRITE_NO_FLUSH)) {
 				ok = FALSE;
 				status = XT_LOG_ENT_ABORT;
 				/* Make sure this is done, if we failed to log
@@ -1337,20 +1337,27 @@
 		/* Don't get too far ahead of the sweeper! */
 		if (writer) {
 #ifdef XT_WAIT_FOR_CLEANUP
-			xtXactID	wait_xn_id;
-			
-			/* This is the transaction that was committed 3 transactions ago: */
-			wait_xn_id = thread->st_prev_xact[thread->st_last_xact];
-			thread->st_prev_xact[thread->st_last_xact] = xn_id;
-			/* This works because XT_MAX_XACT_BEHIND == 2! */
-			ASSERT_NS((thread->st_last_xact + 1) % XT_MAX_XACT_BEHIND == (thread->st_last_xact ^ 1));
-			thread->st_last_xact ^= 1;
-			while (xt_xn_is_before(db->db_xn_to_clean_id, wait_xn_id) && (db->db_sw_faster & XT_SW_TOO_FAR_BEHIND)) {
+			if (db->db_sw_faster & XT_SW_TOO_FAR_BEHIND) {
+				/* Set a maximum wait time (1/100s) */
+				xtWord8		then = xt_trace_clock() + (xtWord8) 100000;
+				xtXactID	wait_xn_id;
+				
+				/* This is the transaction that was committed 3 transactions ago: */
+				wait_xn_id = thread->st_prev_xact[thread->st_last_xact];
+				thread->st_prev_xact[thread->st_last_xact] = xn_id;
+				/* This works because XT_MAX_XACT_BEHIND == 2! */
+				ASSERT_NS((thread->st_last_xact + 1) % XT_MAX_XACT_BEHIND == (thread->st_last_xact ^ 1));
+				thread->st_last_xact ^= 1;
+
+				while (xt_xn_is_before(db->db_xn_to_clean_id, wait_xn_id) && (db->db_sw_faster & XT_SW_TOO_FAR_BEHIND)) {
+					if (xt_trace_clock() >= then)
+						break;
 #ifdef XT_SWEEPER_SORT_XACTS
-				if (!xn_get_xact_start(db, wait_xn_id, thread, NULL, NULL))
-					break;
+					if (!xn_get_xact_start(db, wait_xn_id, thread, NULL, NULL))
+						break;
 #endif
-				xt_critical_wait();
+					xt_critical_wait();
+				}
 			}
 #else
 			if ((db->db_sw_faster & XT_SW_TOO_FAR_BEHIND) != 0) {

=== modified file 'plugin/pbxt/src/xactlog_xt.cc'
--- plugin/pbxt/src/xactlog_xt.cc	2010-04-08 16:11:29 +0000
+++ plugin/pbxt/src/xactlog_xt.cc	2010-05-03 14:18:27 +0000
@@ -118,7 +118,7 @@
 	cont_(a);
 }
 
-xtPublic void xt_xlog_exit(XTThreadPtr)
+xtPublic void xt_xlog_exit(XTThreadPtr XT_UNUSED(self))
 {
 	for (u_int i=0; i<XLC_SEGMENT_COUNT; i++) {
 		if (xt_xlog_cache.xlc_segment[i].lcs_hash_table) {
@@ -2185,7 +2185,11 @@
 	record = (XTXactLogBufferDPtr) (seq->xseq_buffer + rec_offset);
 	switch (record->xh.xh_status_1) {
 		case XT_LOG_ENT_HEADER:
-			len = sizeof(XTXactLogHeaderDRec);
+			len = offsetof(XTXactLogHeaderDRec, xh_version_2) + 2;
+			if (len > max_rec_len)
+				/* The size is not in the buffer: */
+				goto read_more;
+			len = (size_t) XT_GET_DISK_4(record->xh.xh_size_4);
 			break;
 		case XT_LOG_ENT_NEW_LOG:
 		case XT_LOG_ENT_DEL_LOG:

=== modified file 'plugin/pbxt/src/xt_defs.h'
--- plugin/pbxt/src/xt_defs.h	2010-04-19 20:57:43 +0000
+++ plugin/pbxt/src/xt_defs.h	2010-05-03 14:18:27 +0000
@@ -887,7 +887,7 @@
 #define thd_charset							session_charset
 #define thd_slave_thread					session_slave_thread
 #define thd_binlog_format					session_binlog_format
-#define thd_mark_transaction_to_rollback	::drizzled::session_mark_transaction_to_rollback
+#define thd_mark_transaction_to_rollback	::drizzled::mark_transaction_to_rollback
 #define thd_ha_data							session_ha_data
 #define current_thd							current_session
 #define thd_sql_command						session_sql_command
@@ -942,7 +942,7 @@
 #define MX_ULONG_T							ulong
 #define MX_ULONGLONG_T						ulonglong
 #define MX_LONGLONG_T						longlong
-#define MX_CHARSET_INFO						CHARSET_INFO
+#define MX_CHARSET_INFO						struct charset_info_st
 #define MX_CONST_CHARSET_INFO				struct charset_info_st			
 #define MX_CONST							
 #define MX_BITMAP							MY_BITMAP