Merge lp:~paul-mccullagh/maria/pbxt-1.0.11 into lp:~maria-captains/maria/5.1-converting

[Paul McCullagh]

This branch contains PBXT 1.0.11 "Pre-GA". I plan to release this version within the next 2 weeks.

All tests in the PBXT suite run through on Mac and Linux, except for one error under Linux, which is a bit weird (see below).

Nevertheless I would like to get this merged, because it is definitely a good step forward, from the previous version of PBXT in MariaDB.

I have also tested PBXT 1.0.11 with MySQL 4.1.46. All tests run through on Mac.

------------------

pbxt.select_safe [ fail ]
        Test ended at 2010-05-06 17:19:13

CURRENT_TEST: pbxt.select_safe
mysqltest: At line 19: query 'select 1 from t1,t1 as t2,t1 as t3' failed: 1104: The SELECT would examine more than MAX_JOIN_SIZE rows; check your WHERE and use SET SQL_BIG_SELECTS=1 or SET SQL_MAX_JOIN_SIZE=# if the SELECT is okay

The result from queries just before the failure was:
drop table if exists t1;
SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=4, SQL_MAX_JOIN_SIZE=9;
create table t1 (a int auto_increment primary key, b char(20));
insert into t1 values(1,"test");
SELECT SQL_BUFFER_RESULT * from t1;
a b
1 test
update t1 set b="a" whe

[Kristian Nielsen (knielsen)]

Paul McCullagh <email address hidden> writes:

> Paul McCullagh has proposed merging lp:~paul-mccullagh/maria/pbxt-1.0.11 into lp:maria.
>
> Requested reviews:
> Maria-captains (maria-captains)
>
>
> This branch contains PBXT 1.0.11 "Pre-GA". I plan to release this version within the next 2 weeks.

Thanks, Paul! I merged this without any issues.

This is scheduled to be included in upcoming MariaDB 5.1.46 release.

> All tests in the PBXT suite run through on Mac and Linux, except for one error under Linux, which is a bit weird (see below).

> ------------------
>
> pbxt.select_safe [ fail ]
> Test ended at 2010-05-06 17:19:13
>
> CURRENT_TEST: pbxt.select_safe
> mysqltest: At line 19: query 'select 1 from t1,t1 as t2,t1 as t3' failed: 1104: The SELECT would examine more than MAX_JOIN_SIZE rows; check your WHERE and use SET SQL_BIG_SELECTS=1 or SET SQL_MAX_JOIN_SIZE=# if the SELECT is okay
>
> The result from queries just before the failure was:
> drop table if exists t1;
> SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=4, SQL_MAX_JOIN_SIZE=9;
> create table t1 (a int auto_increment primary key, b char(20));
> insert into t1 values(1,"test");
> SELECT SQL_BUFFER_RESULT * from t1;
> a b
> 1 test
> update t1 set b="a" whe

Yes, looks wierd. I did not get this test failure on my Linux build.

We fixed some regressions after merging with MySQL 5.1.46, maybe those also
fixed this case. Or maybe it is a random failure, and Buildbot will have more
to say on the issue.

 - Kristian.

[Kristian Nielsen (knielsen)]

Kristian Nielsen <email address hidden> writes:

> Paul McCullagh <email address hidden> writes:

>> All tests in the PBXT suite run through on Mac and Linux, except for one error under Linux, which is a bit weird (see below).
>
>> ------------------
>>
>> pbxt.select_safe [ fail ]
>> Test ended at 2010-05-06 17:19:13
>>
>> CURRENT_TEST: pbxt.select_safe
>> mysqltest: At line 19: query 'select 1 from t1,t1 as t2,t1 as t3' failed: 1104: The SELECT would examine more than MAX_JOIN_SIZE rows; check your WHERE and use SET SQL_BIG_SELECTS=1 or SET SQL_MAX_JOIN_SIZE=# if the SELECT is okay
>>
>> The result from queries just before the failure was:
>> drop table if exists t1;
>> SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=4, SQL_MAX_JOIN_SIZE=9;
>> create table t1 (a int auto_increment primary key, b char(20));
>> insert into t1 values(1,"test");
>> SELECT SQL_BUFFER_RESULT * from t1;
>> a b
>> 1 test
>> update t1 set b="a" whe
>
> Yes, looks wierd. I did not get this test failure on my Linux build.
>
> We fixed some regressions after merging with MySQL 5.1.46, maybe those also
> fixed this case. Or maybe it is a random failure, and Buildbot will have more
> to say on the issue.

Hm, I can repeat it in a --valgrind run, but not in a normal run (which is
also wierd). I will take a look.

 - Kristian.

=== modified file 'mysql-test/suite/pbxt/r/func_str.result'
--- mysql-test/suite/pbxt/r/func_str.result	2009-08-17 15:57:58 +0000
+++ mysql-test/suite/pbxt/r/func_str.result	2010-05-07 08:52:27 +0000
@@ -1362,7 +1362,7 @@
 WHERE id='a12' AND (LENGTH(code)=5 OR code < 'a00');
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	SIMPLE	t2	const	PRIMARY	PRIMARY	12	const	1	100.00	Using index
-1	SIMPLE	t1	ref	code	code	13	const	1	100.00	Using where; Using index
+1	SIMPLE	t1	ref	code	code	13	const	3	100.00	Using where; Using index
 Warnings:
 Note	1003	select `test`.`t1`.`code` AS `code`,'a12' AS `id` from `test`.`t1` join `test`.`t2` where ((`test`.`t1`.`code` = 'a12') and (length(`test`.`t1`.`code`) = 5))
 DROP TABLE t1,t2;

=== modified file 'mysql-test/suite/pbxt/r/group_min_max.result'
--- mysql-test/suite/pbxt/r/group_min_max.result	2009-11-24 10:19:08 +0000
+++ mysql-test/suite/pbxt/r/group_min_max.result	2010-05-07 08:52:27 +0000
@@ -287,52 +287,52 @@
 b	m422	p422
 explain select a1,a2,b,min(c),max(c) from t1 where a1 < 'd' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	1	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	32	Using where; Using index
 explain select a1,a2,b,min(c),max(c) from t1 where a1 >= 'b' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	1	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	32	Using where; Using index
 explain select a1,a2,b,       max(c) from t1 where a1 >= 'c' or a1 < 'b' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	147	NULL	2	Using where; Using index for group-by
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	64	Using where; Using index
 explain select a1, max(c)            from t1 where a1 >= 'c' or a1 < 'b' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	147	NULL	2	Using where; Using index for group-by
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	64	Using where; Using index
 explain select a1,a2,b,min(c),max(c) from t1 where a1 >= 'c' or a2 < 'b' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	147	NULL	129	Using where; Using index for group-by
 explain select a1,a2,b,       max(c) from t1 where a1 = 'z' or a1 = 'b' or a1 = 'd' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	3	Using where; Using index
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	96	Using where; Using index
 explain select a1,a2,b,min(c),max(c) from t1 where a1 = 'z' or a1 = 'b' or a1 = 'd' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	3	Using where; Using index
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	96	Using where; Using index
 explain select a1,a2,b,       max(c) from t1 where (a1 = 'b' or a1 = 'd' or a1 = 'a' or a1 = 'c') and (a2 > 'a') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	130	NULL	4	Using where; Using index
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	130	NULL	64	Using where; Using index
 explain select a1,a2,b,min(c),max(c) from t1 where (a1 = 'b' or a1 = 'd' or a1 = 'a' or a1 = 'c') and (a2 > 'a') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	130	NULL	4	Using where; Using index
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	130	NULL	64	Using where; Using index
 explain select a1,min(c),max(c)      from t1 where a1 >= 'b' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	1	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	32	Using where; Using index
 explain select a1,  max(c)           from t1 where a1 in ('a','b','d') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	3	Using where; Using index
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	96	Using where; Using index
 explain select a1,a2,b,       max(c) from t2 where a1 < 'd' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_2	65	NULL	#	Using where
+1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	65	NULL	#	Using where; Using index
 explain select a1,a2,b,min(c),max(c) from t2 where a1 < 'd' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_2	65	NULL	#	Using where
+1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	65	NULL	#	Using where; Using index
 explain select a1,a2,b,min(c),max(c) from t2 where a1 >= 'b' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_2	65	NULL	#	Using where
+1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	65	NULL	#	Using where; Using index
 explain select a1,a2,b,       max(c) from t2 where a1 >= 'c' or a1 < 'b' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	146	NULL	#	Using where; Using index for group-by
+1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	65	NULL	#	Using where; Using index
 explain select a1, max(c)            from t2 where a1 >= 'c' or a1 < 'b' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	146	NULL	#	Using where; Using index for group-by
+1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	65	NULL	#	Using where; Using index
 explain select a1,a2,b,min(c),max(c) from t2 where a1 >= 'c' or a2 < 'b' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	163	NULL	#	Using where; Using index for group-by
@@ -350,7 +350,7 @@
 1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	129	NULL	#	Using where; Using index
 explain select a1,min(c),max(c)      from t2 where a1 >= 'b' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_2	65	NULL	#	Using where
+1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	65	NULL	#	Using where; Using index
 explain select a1,  max(c)           from t2 where a1 in ('a','b','d') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	65	NULL	#	Using where; Using index
@@ -1377,13 +1377,13 @@
 1	SIMPLE	t1	range	NULL	idx_t1_1	163	NULL	129	Using where; Using index for group-by
 explain select a1,a2,b,min(c) from t1 where ((a1 > 'a') or (a1 < '9'))  and ((a2 >= 'b') and (a2 < 'z')) and (b = 'a') and ((c < 'h112') or (c = 'j121') or (c > 'k121' and c < 'm122') or (c > 'o122')) group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	163	NULL	2	Using where; Using index for group-by
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	64	Using where; Using index
 explain select a1,a2,b,min(c) from t1 where ((a1 > 'a') or (a1 < '9'))  and ((a2 >= 'b') and (a2 < 'z')) and (b = 'a') and ((c = 'j121') or (c > 'k121' and c < 'm122') or (c > 'o122') or (c < 'h112') or (c = 'c111')) group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	163	NULL	2	Using where; Using index for group-by
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	64	Using where; Using index
 explain select a1,a2,b,min(c) from t1 where (a1 > 'a') and (a2 > 'a') and (b = 'c') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	1	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	32	Using where; Using index
 explain select a1,a2,b,min(c) from t1 where (ord(a1) > 97) and (ord(a2) + ord(a1) > 194) and (b = 'c') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t1	range	NULL	idx_t1_1	147	NULL	129	Using where; Using index for group-by
@@ -1398,13 +1398,13 @@
 1	SIMPLE	t2	range	NULL	idx_t2_1	163	NULL	#	Using where; Using index for group-by
 explain select a1,a2,b,min(c) from t2 where ((a1 > 'a') or (a1 < '9'))  and ((a2 >= 'b') and (a2 < 'z')) and (b = 'a') and ((c < 'h112') or (c = 'j121') or (c > 'k121' and c < 'm122') or (c > 'o122')) group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	163	NULL	#	Using where; Using index for group-by
+1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	65	NULL	#	Using where; Using index
 explain select a1,a2,b,min(c) from t2 where ((a1 > 'a') or (a1 < '9'))  and ((a2 >= 'b') and (a2 < 'z')) and (b = 'a') and ((c = 'j121') or (c > 'k121' and c < 'm122') or (c > 'o122') or (c < 'h112') or (c = 'c111')) group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	163	NULL	#	Using where; Using index for group-by
+1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	65	NULL	#	Using where; Using index
 explain select a1,a2,b,min(c) from t2 where (a1 > 'a') and (a2 > 'a') and (b = 'c') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_2	65	NULL	#	Using where
+1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_1	65	NULL	#	Using where; Using index
 select a1,a2,b,min(c),max(c) from t1 where (a1 >= 'c' or a2 < 'b') and (b > 'a') group by a1,a2,b;
 a1	a2	b	min(c)	max(c)
 a	a	b	e112	h112
@@ -1500,7 +1500,7 @@
 1	SIMPLE	t1	range	NULL	idx_t1_1	163	NULL	129	Using where; Using index for group-by
 explain select a1,a2,b from t1 where (a1 > 'a') and (a2 > 'a') and (b = 'c') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	147	NULL	1	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	32	Using where; Using index
 explain select a1,a2,b from t2 where (a1 >= 'c' or a2 < 'b') and (b > 'a') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_2	146	NULL	#	Using where; Using index for group-by
@@ -1512,7 +1512,7 @@
 1	SIMPLE	t2	range	NULL	idx_t2_1	163	NULL	#	Using where; Using index for group-by
 explain select a1,a2,b from t2 where (a1 > 'a') and (a2 > 'a') and (b = 'c') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_2	146	NULL	#	Using where
+1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_2	65	NULL	#	Using where; Using index
 select a1,a2,b from t1 where (a1 >= 'c' or a2 < 'b') and (b > 'a') group by a1,a2,b;
 a1	a2	b
 a	a	b
@@ -1565,7 +1565,7 @@
 Note	1003	select distinct `test`.`t1`.`a1` AS `a1`,`test`.`t1`.`a2` AS `a2`,`test`.`t1`.`b` AS `b`,`test`.`t1`.`c` AS `c` from `test`.`t1` where ((`test`.`t1`.`c` = 'i121') and (`test`.`t1`.`b` = 'a') and (`test`.`t1`.`a2` >= 'b'))
 explain select distinct a1,a2,b from t1 where (a1 > 'a') and (a2 > 'a') and (b = 'c');
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	147	NULL	1	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	32	Using where; Using index
 explain select distinct b from t1 where (a2 >= 'b') and (b = 'a');
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t1	index	NULL	idx_t1_2	147	NULL	128	Using where; Using index
@@ -1582,7 +1582,7 @@
 Note	1003	select distinct `test`.`t2`.`a1` AS `a1`,`test`.`t2`.`a2` AS `a2`,`test`.`t2`.`b` AS `b`,`test`.`t2`.`c` AS `c` from `test`.`t2` where ((`test`.`t2`.`c` = 'i121') and (`test`.`t2`.`b` = 'a') and (`test`.`t2`.`a2` >= 'b'))
 explain select distinct a1,a2,b from t2 where (a1 > 'a') and (a2 > 'a') and (b = 'c');
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_2	146	NULL	#	Using where
+1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_2	65	NULL	#	Using where; Using index
 explain select distinct b from t2 where (a2 >= 'b') and (b = 'a');
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t2	index	NULL	idx_t2_2	146	NULL	164	Using where; Using index
@@ -1711,7 +1711,7 @@
 1	SIMPLE	t1	range	NULL	idx_t1_1	163	NULL	129	Using where; Using index for group-by
 explain select distinct a1,a2,b from t1 where (a1 > 'a') and (a2 > 'a') and (b = 'c') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	147	NULL	1	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	32	Using where; Using index
 explain select distinct b from t1 where (a2 >= 'b') and (b = 'a') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t1	range	NULL	idx_t1_1	147	NULL	129	Using where; Using index for group-by; Using temporary; Using filesort
@@ -1726,7 +1726,7 @@
 1	SIMPLE	t2	range	NULL	idx_t2_1	163	NULL	#	Using where; Using index for group-by
 explain select distinct a1,a2,b from t2 where (a1 > 'a') and (a2 > 'a') and (b = 'c') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_2	146	NULL	#	Using where
+1	SIMPLE	t2	range	idx_t2_0,idx_t2_1,idx_t2_2	idx_t2_2	65	NULL	#	Using where; Using index
 explain select distinct b from t2 where (a2 >= 'b') and (b = 'a') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t2	range	NULL	idx_t2_2	146	NULL	#	Using where; Using index for group-by; Using temporary; Using filesort
@@ -1806,7 +1806,7 @@
 1	SIMPLE	t1	index	NULL	idx_t1_1	163	NULL	128	Using where; Using index
 explain extended select count(distinct a1,a2,b) from t1 where (a1 > 'a') and (a2 > 'a') and (b = 'c');
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_0	65	NULL	1	100.00	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	32	100.00	Using where; Using index
 Warnings:
 Note	1003	select count(distinct `test`.`t1`.`a1`,`test`.`t1`.`a2`,`test`.`t1`.`b`) AS `count(distinct a1,a2,b)` from `test`.`t1` where ((`test`.`t1`.`b` = 'c') and (`test`.`t1`.`a1` > 'a') and (`test`.`t1`.`a2` > 'a'))
 explain select count(distinct b) from t1 where (a2 >= 'b') and (b = 'a');
@@ -1814,7 +1814,7 @@
 1	SIMPLE	t1	index	NULL	idx_t1_2	147	NULL	128	Using where; Using index
 explain extended select ord(a1) + count(distinct a1,a2,b) from t1 where (a1 > 'a') and (a2 > 'a');
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_0	65	NULL	1	100.00	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	32	100.00	Using where; Using index
 Warnings:
 Note	1003	select (ord(`test`.`t1`.`a1`) + count(distinct `test`.`t1`.`a1`,`test`.`t1`.`a2`,`test`.`t1`.`b`)) AS `ord(a1) + count(distinct a1,a2,b)` from `test`.`t1` where ((`test`.`t1`.`a1` > 'a') and (`test`.`t1`.`a2` > 'a'))
 select count(distinct a1,a2,b) from t1 where (a2 >= 'b') and (b = 'a');
@@ -1834,16 +1834,16 @@
 104
 explain select a1,a2,b, concat(min(c), max(c)) from t1 where a1 < 'd' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	1	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	32	Using where; Using index
 explain select concat(a1,min(c)),b from t1 where a1 < 'd' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	1	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	32	Using where; Using index
 explain select concat(a1,min(c)),b,max(c) from t1 where a1 < 'd' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	1	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	32	Using where; Using index
 explain select concat(a1,a2),b,min(c),max(c) from t1 where a1 < 'd' group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	1	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	65	NULL	32	Using where; Using index
 explain select concat(ord(min(b)),ord(max(b))),min(b),max(b) from t1 group by a1,a2;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t1	range	NULL	idx_t1_1	147	NULL	129	Using index for group-by
@@ -1922,19 +1922,19 @@
 explain extended select a1,a2,min(b),max(b) from t1
 where (a1 = 'b' or a1 = 'd' or a1 = 'a' or a1 = 'c') and (a2 > 'a') and (c > 'a111') group by a1,a2;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	130	NULL	4	100.00	Using where; Using index
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	130	NULL	64	100.00	Using where; Using index
 Warnings:
 Note	1003	select `test`.`t1`.`a1` AS `a1`,`test`.`t1`.`a2` AS `a2`,min(`test`.`t1`.`b`) AS `min(b)`,max(`test`.`t1`.`b`) AS `max(b)` from `test`.`t1` where (((`test`.`t1`.`a1` = 'b') or (`test`.`t1`.`a1` = 'd') or (`test`.`t1`.`a1` = 'a') or (`test`.`t1`.`a1` = 'c')) and (`test`.`t1`.`a2` > 'a') and (`test`.`t1`.`c` > 'a111')) group by `test`.`t1`.`a1`,`test`.`t1`.`a2`
 explain extended select a1,a2,b,min(c),max(c) from t1
 where (a1 = 'b' or a1 = 'd' or a1 = 'a' or a1 = 'c') and (a2 > 'a') and (d > 'xy2') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	130	NULL	4	100.00	Using where
+1	SIMPLE	t1	ALL	idx_t1_0,idx_t1_1,idx_t1_2	NULL	NULL	NULL	128	50.00	Using where; Using temporary; Using filesort
 Warnings:
 Note	1003	select `test`.`t1`.`a1` AS `a1`,`test`.`t1`.`a2` AS `a2`,`test`.`t1`.`b` AS `b`,min(`test`.`t1`.`c`) AS `min(c)`,max(`test`.`t1`.`c`) AS `max(c)` from `test`.`t1` where (((`test`.`t1`.`a1` = 'b') or (`test`.`t1`.`a1` = 'd') or (`test`.`t1`.`a1` = 'a') or (`test`.`t1`.`a1` = 'c')) and (`test`.`t1`.`a2` > 'a') and (`test`.`t1`.`d` > 'xy2')) group by `test`.`t1`.`a1`,`test`.`t1`.`a2`,`test`.`t1`.`b`
 explain extended select a1,a2,b,c from t1
 where (a1 = 'b' or a1 = 'd' or a1 = 'a' or a1 = 'c') and (a2 > 'a') and (d > 'xy2') group by a1,a2,b,c;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	130	NULL	4	100.00	Using where
+1	SIMPLE	t1	ALL	idx_t1_0,idx_t1_1,idx_t1_2	NULL	NULL	NULL	128	50.00	Using where; Using temporary; Using filesort
 Warnings:
 Note	1003	select `test`.`t1`.`a1` AS `a1`,`test`.`t1`.`a2` AS `a2`,`test`.`t1`.`b` AS `b`,`test`.`t1`.`c` AS `c` from `test`.`t1` where (((`test`.`t1`.`a1` = 'b') or (`test`.`t1`.`a1` = 'd') or (`test`.`t1`.`a1` = 'a') or (`test`.`t1`.`a1` = 'c')) and (`test`.`t1`.`a2` > 'a') and (`test`.`t1`.`d` > 'xy2')) group by `test`.`t1`.`a1`,`test`.`t1`.`a2`,`test`.`t1`.`b`,`test`.`t1`.`c`
 explain select a1,a2,b,max(c),min(c) from t2 where (a2 = 'a') and (b = 'b') or (b < 'b') group by a1;
@@ -1942,7 +1942,7 @@
 1	SIMPLE	t2	index	NULL	idx_t2_1	163	NULL	164	Using where; Using index
 explain extended select a1,a2,b from t1 where (a1 = 'b' or a1 = 'd' or a1 = 'a' or a1 = 'c') and (a2 > 'a') and (c > 'a111') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	130	NULL	4	100.00	Using where; Using index
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_1	130	NULL	64	100.00	Using where; Using index
 Warnings:
 Note	1003	select `test`.`t1`.`a1` AS `a1`,`test`.`t1`.`a2` AS `a2`,`test`.`t1`.`b` AS `b` from `test`.`t1` where (((`test`.`t1`.`a1` = 'b') or (`test`.`t1`.`a1` = 'd') or (`test`.`t1`.`a1` = 'a') or (`test`.`t1`.`a1` = 'c')) and (`test`.`t1`.`a2` > 'a') and (`test`.`t1`.`c` > 'a111')) group by `test`.`t1`.`a1`,`test`.`t1`.`a2`,`test`.`t1`.`b`
 explain select a1,a2,min(b),c from t2 where (a2 = 'a') and (c = 'a111') group by a1;
@@ -1966,12 +1966,12 @@
 1	SIMPLE	t1	index	NULL	idx_t1_2	147	NULL	128	Using index
 explain extended select a1,a2,count(a2) from t1 where (a1 > 'a') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	1	100.00	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	32	100.00	Using where; Using index
 Warnings:
 Note	1003	select `test`.`t1`.`a1` AS `a1`,`test`.`t1`.`a2` AS `a2`,count(`test`.`t1`.`a2`) AS `count(a2)` from `test`.`t1` where (`test`.`t1`.`a1` > 'a') group by `test`.`t1`.`a1`,`test`.`t1`.`a2`,`test`.`t1`.`b`
 explain extended select sum(ord(a1)) from t1 where (a1 > 'a') group by a1,a2,b;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	1	100.00	Using where
+1	SIMPLE	t1	range	idx_t1_0,idx_t1_1,idx_t1_2	idx_t1_2	65	NULL	32	100.00	Using where; Using index
 Warnings:
 Note	1003	select sum(ord(`test`.`t1`.`a1`)) AS `sum(ord(a1))` from `test`.`t1` where (`test`.`t1`.`a1` > 'a') group by `test`.`t1`.`a1`,`test`.`t1`.`a2`,`test`.`t1`.`b`
 explain select distinct(a1) from t1 where ord(a2) = 98;
@@ -2047,10 +2047,10 @@
 BB
 EXPLAIN SELECT a FROM t1 WHERE a='AA' GROUP BY a;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	ref	PRIMARY	PRIMARY	7	const	1	Using where; Using index
+1	SIMPLE	t1	ref	PRIMARY	PRIMARY	7	const	3	Using where; Using index
 EXPLAIN SELECT a FROM t1 WHERE a='BB' GROUP BY a;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	ref	PRIMARY	PRIMARY	7	const	1	Using where; Using index
+1	SIMPLE	t1	ref	PRIMARY	PRIMARY	7	const	3	Using where; Using index
 SELECT DISTINCT a FROM t1 WHERE a='BB';
 a
 BB

=== modified file 'mysql-test/suite/pbxt/r/join_nested.result'
--- mysql-test/suite/pbxt/r/join_nested.result	2009-12-27 16:48:27 +0000
+++ mysql-test/suite/pbxt/r/join_nested.result	2010-05-07 08:52:27 +0000
@@ -1055,7 +1055,7 @@
 (t8.b=t9.b OR t8.c IS NULL) AND
 (t9.a=1);
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t0	ref	idx_a	idx_a	5	const	1	
+1	SIMPLE	t0	ref	idx_a	idx_a	5	const	2	
 1	SIMPLE	t1	ref	idx_b	idx_b	5	test.t0.b	1	
 1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	3	
 1	SIMPLE	t3	ALL	NULL	NULL	NULL	NULL	2	

=== modified file 'mysql-test/suite/pbxt/r/negation_elimination.result'
--- mysql-test/suite/pbxt/r/negation_elimination.result	2009-11-24 10:19:08 +0000
+++ mysql-test/suite/pbxt/r/negation_elimination.result	2010-05-07 08:52:27 +0000
@@ -388,7 +388,7 @@
 test.t1	analyze	status	OK
 explain extended select a, not(not(a)), not(a <= 2 and not(a)), not(a not like "1"), not (a not in (1,2)), not(a != 2) from t1 where not(not(a)) having not(not(a));
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-1	SIMPLE	t1	index	NULL	a	5	NULL	5	100.00	Using where; Using index
+1	SIMPLE	t1	index	NULL	a	5	NULL	21	100.00	Using where; Using index
 Warnings:
 Note	1003	select `test`.`t1`.`a` AS `a`,(`test`.`t1`.`a` <> 0) AS `not(not(a))`,((`test`.`t1`.`a` > 2) or `test`.`t1`.`a`) AS `not(a <= 2 and not(a))`,(`test`.`t1`.`a` like '1') AS `not(a not like "1")`,(`test`.`t1`.`a` in (1,2)) AS `not (a not in (1,2))`,(`test`.`t1`.`a` = 2) AS `not(a != 2)` from `test`.`t1` where `test`.`t1`.`a` having `test`.`t1`.`a`
 drop table t1;

=== modified file 'mysql-test/suite/pbxt/r/null.result'
--- mysql-test/suite/pbxt/r/null.result	2009-08-17 15:57:58 +0000
+++ mysql-test/suite/pbxt/r/null.result	2010-05-07 08:52:27 +0000
@@ -179,7 +179,7 @@
 Warning	1265	Data truncated for column 'i' at row 513
 explain select * from t1 where i=2 or i is null;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	ref	i	i	4	const	1	Using index
+1	SIMPLE	t1	ref	i	i	4	const	25	Using index
 select count(*) from t1 where i=2 or i is null;
 count(*)
 9

=== modified file 'mysql-test/suite/pbxt/r/order_by.result'
--- mysql-test/suite/pbxt/r/order_by.result	2009-04-02 10:03:14 +0000
+++ mysql-test/suite/pbxt/r/order_by.result	2010-05-07 08:52:27 +0000
@@ -401,14 +401,14 @@
 1	0	
 explain select * from t1 where (a = 1 and b = 1 and c = 'b') or (a > 2) order by a desc;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	index	a	a	20	NULL	11	Using where; Using index
+1	SIMPLE	t1	range	a	a	20	NULL	7	Using where; Using index
 select * from t1 where (a = 1 and b = 1 and c = 'b') or (a > 2) order by a desc;
 a	b	c
 1	1	b
 1	1	b
 explain select * from t1 where a < 2 and b <= 1 order by a desc, b desc;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	a	a	4	NULL	1	Using where; Using index
+1	SIMPLE	t1	range	a	a	4	NULL	6	Using where; Using index
 select * from t1 where a < 2 and b <= 1 order by a desc, b desc;
 a	b	c
 1	1	b
@@ -432,7 +432,7 @@
 1	1	
 explain select * from t1 where a between 1 and 3 and b <= 1 order by a desc, b desc;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	a	a	8	NULL	1	Using where; Using index
+1	SIMPLE	t1	range	a	a	8	NULL	6	Using where; Using index
 select * from t1 where a between 1 and 3 and b <= 1 order by a desc, b desc;
 a	b	c
 2	1	b
@@ -444,7 +444,7 @@
 1	0	
 explain select * from t1 where a between 0 and 1 order by a desc, b desc;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	a	a	4	NULL	1	Using where; Using index
+1	SIMPLE	t1	range	a	a	4	NULL	6	Using where; Using index
 select * from t1 where a between 0 and 1 order by a desc, b desc;
 a	b	c
 1	3	b

=== modified file 'mysql-test/suite/pbxt/r/pbxt_ref_int.result'
--- mysql-test/suite/pbxt/r/pbxt_ref_int.result	2009-08-17 15:57:58 +0000
+++ mysql-test/suite/pbxt/r/pbxt_ref_int.result	2010-05-07 08:52:27 +0000
@@ -14,7 +14,7 @@
 drop table t1;
 set foreign_key_checks = 1;
 INSERT INTO t2 VALUES(2);
-ERROR 23000: Cannot add or update a child row: a foreign key constraint fails (Referenced table `t1` not found)
+ERROR 23000: Cannot add or update a child row: a foreign key constraint fails (Referenced table `test.t1` not found)
 drop table if exists parent, child, child_child;
 CREATE TABLE parent (
 id INT NOT NULL,
@@ -370,7 +370,7 @@
 CREATE TABLE t2 (s1 INT DEFAULT NULL, FOREIGN KEY (s1) REFERENCES t1 (s1));
 set foreign_key_checks = 1;
 insert into t2 values (1);
-ERROR 23000: Cannot add or update a child row: a foreign key constraint fails (Referenced table `t1` not found)
+ERROR 23000: Cannot add or update a child row: a foreign key constraint fails (Referenced table `test.t1` not found)
 set foreign_key_checks = 0;
 insert into t2 values (1);
 CREATE TABLE t1 (s1 INT PRIMARY KEY);

=== modified file 'mysql-test/suite/pbxt/r/range.result'
--- mysql-test/suite/pbxt/r/range.result	2009-08-17 15:57:58 +0000
+++ mysql-test/suite/pbxt/r/range.result	2010-05-07 08:52:27 +0000
@@ -964,5 +964,5 @@
 In following EXPLAIN the access method should be ref, #rows~=500 (and not 2)
 explain select * from t2 where a=1000 and b<11;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	range	a	a	10	NULL	1	Using where
+1	SIMPLE	t2	range	a	a	10	NULL	2	Using where
 drop table t1, t2;

=== modified file 'mysql-test/suite/pbxt/r/select.result'
--- mysql-test/suite/pbxt/r/select.result	2009-10-07 16:56:11 +0000
+++ mysql-test/suite/pbxt/r/select.result	2010-05-07 08:52:27 +0000
@@ -1384,52 +1384,52 @@
 test.t2	analyze	status	OK
 explain select t2.companynr,companyname from t4 left join t2 using (companynr) where t2.companynr > 0;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	Using where
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	Using where
 1	SIMPLE	t4	eq_ref	PRIMARY	PRIMARY	1	test.t2.companynr	1	
 explain select t2.companynr,companyname from t4 left join t2 using (companynr) where t2.companynr > 0 or t2.companynr < 0;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	Using where
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	Using where
 1	SIMPLE	t4	eq_ref	PRIMARY	PRIMARY	1	test.t2.companynr	1	
 explain select t2.companynr,companyname from t4 left join t2 using (companynr) where t2.companynr > 0 and t4.companynr > 0;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	Using where
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	Using where
 1	SIMPLE	t4	eq_ref	PRIMARY	PRIMARY	1	test.t2.companynr	1	
 explain select companynr,companyname from t4 left join t2 using (companynr) where companynr > 0;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t4	ALL	PRIMARY	NULL	NULL	NULL	12	Using where
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	
 explain select companynr,companyname from t4 left join t2 using (companynr) where companynr > 0 or companynr < 0;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t4	ALL	PRIMARY	NULL	NULL	NULL	12	Using where
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	
 explain select companynr,companyname from t4 left join t2 using (companynr) where companynr > 0 and companynr > 0;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t4	ALL	PRIMARY	NULL	NULL	NULL	12	Using where
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	
 explain select t2.companynr,companyname from t4 left join t2 using (companynr) where t2.companynr > 0 or t2.companynr is null;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t4	ALL	NULL	NULL	NULL	NULL	12	
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	Using where
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	Using where
 explain select t2.companynr,companyname from t4 left join t2 using (companynr) where t2.companynr > 0 or t2.companynr < 0 or t4.companynr > 0;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t4	ALL	PRIMARY	NULL	NULL	NULL	12	
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	Using where
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	Using where
 explain select t2.companynr,companyname from t4 left join t2 using (companynr) where ifnull(t2.companynr,1)>0;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t4	ALL	NULL	NULL	NULL	NULL	12	
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	Using where
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	Using where
 explain select companynr,companyname from t4 left join t2 using (companynr) where companynr > 0 or companynr is null;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t4	ALL	PRIMARY	NULL	NULL	NULL	12	Using where
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	
 explain select companynr,companyname from t4 left join t2 using (companynr) where companynr > 0 or companynr < 0 or companynr > 0;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t4	ALL	PRIMARY	NULL	NULL	NULL	12	Using where
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	
 explain select companynr,companyname from t4 left join t2 using (companynr) where ifnull(companynr,1)>0;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t4	ALL	NULL	NULL	NULL	NULL	12	Using where
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	
 select distinct t2.companynr,t4.companynr from t2,t4 where t2.companynr=t4.companynr+1;
 companynr	companynr
 37	36
@@ -1437,7 +1437,7 @@
 explain select distinct t2.companynr,t4.companynr from t2,t4 where t2.companynr=t4.companynr+1;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t4	index	NULL	PRIMARY	1	NULL	12	Using index; Using temporary
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	Using where; Using join buffer
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	Using where; Using join buffer
 select t2.fld1,t2.companynr,fld3,period from t3,t2 where t2.fld1 = 38208 and t2.fld1=t3.t2nr and period = 1008 or t2.fld1 = 38008 and t2.fld1 =t3.t2nr and period = 1008;
 fld1	companynr	fld3	period
 038008	37	reporters	1008
@@ -1511,7 +1511,7 @@
 70	absentee	vest	17788966	254128.0857	3272.5940	10709871.3069
 explain extended select count(*),min(fld4),max(fld4),sum(fld1),avg(fld1),std(fld1),variance(fld1) from t2 where companynr = 34 and fld4<>"";
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	100.00	Using where
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	100.00	Using where
 Warnings:
 Note	1003	select count(0) AS `count(*)`,min(`test`.`t2`.`fld4`) AS `min(fld4)`,max(`test`.`t2`.`fld4`) AS `max(fld4)`,sum(`test`.`t2`.`fld1`) AS `sum(fld1)`,avg(`test`.`t2`.`fld1`) AS `avg(fld1)`,std(`test`.`t2`.`fld1`) AS `std(fld1)`,variance(`test`.`t2`.`fld1`) AS `variance(fld1)` from `test`.`t2` where ((`test`.`t2`.`companynr` = 34) and (`test`.`t2`.`fld4` <> ''))
 select companynr,count(*),min(fld4),max(fld4),sum(fld1),avg(fld1),std(fld1),variance(fld1) from t2 group by companynr limit 3;
@@ -1955,7 +1955,7 @@
 1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE
 explain select fld3 from t2 where fld1=fld1;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1199	
+1	SIMPLE	t2	ALL	NULL	NULL	NULL	NULL	1200	
 select companynr,fld1 from t2 HAVING fld1=250501 or fld1=250502;
 companynr	fld1
 34	250501
@@ -2007,7 +2007,7 @@
 4181
 explain select min(fld1),max(fld1),count(*) from t2;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t2	index	NULL	fld1	4	NULL	1199	Using index
+1	SIMPLE	t2	index	NULL	fld1	4	NULL	1200	Using index
 select min(fld1),max(fld1),count(*) from t2;
 min(fld1)	max(fld1)	count(*)
 0	1232609	1199
@@ -2093,9 +2093,9 @@
 Field	Type	Collation	Null	Key	Default	Extra	Privileges	Comment
 show keys from t2;
 Table	Non_unique	Key_name	Seq_in_index	Column_name	Collation	Cardinality	Sub_part	Packed	Null	Index_type	Comment
-t2	0	PRIMARY	1	auto	A	1199	NULL	NULL		BTREE	
-t2	0	fld1	1	fld1	A	1199	NULL	NULL		BTREE	
-t2	1	fld3	1	fld3	A	1199	NULL	NULL		BTREE	
+t2	0	PRIMARY	1	auto	A	1200	NULL	NULL		BTREE	
+t2	0	fld1	1	fld1	A	1200	NULL	NULL		BTREE	
+t2	1	fld3	1	fld3	A	1200	NULL	NULL		BTREE	
 drop table t4, t3, t2, t1;
 DO 1;
 DO benchmark(100,1+1),1,1;

=== modified file 'storage/pbxt/ChangeLog'
--- storage/pbxt/ChangeLog	2009-12-21 13:13:15 +0000
+++ storage/pbxt/ChangeLog	2010-05-07 08:52:27 +0000
@@ -1,6 +1,111 @@
 PBXT Release Notes
 ==================
 
++------- 1.0.11 Pre-GA - 2010-05-11
+
+RN322: Creating a table the references a non-existing table can now only be done if you set: foreign_key_checks = 0. Also fixed a failure when creating tables with recursive foreign key declarations.
+
+RN321: Added "Extended record count" to the CHECK TABLE output. This indicates the number of records that have a data log component.
+
+RN320: All tests now run with MySQL 5.1.46.
+
+------- 1.0.10n RC4 - 2010-04-28
+
+RN319: Fix RN1/3 and RN1/4 back-ported from 1.1: Fixed a deadlock that could occur during low index cache situations and added some checks for index corruption, and added the try lock variation for R/W locks.
+
+RN318: Fixed a bug in the atomic R/W lock. This bug occurred on multi-core Linux when under extrem load. The affect was that an index lookup could fail. The index was not corrupted.
+
+------- 1.0.10m RC4 - 2010-03-29
+
+RN317: This change prevents a unscheduled checkpoint from occurring when the sweeper has work to do. Checkpoint required due to the Checkpoint threshold reached are done as usual.
+
+------- 1.0.10k RC4 - 2010-03-29
+
+RN316: Set the maximum delay, while waiting for previous transactions to commit to 1/100s. This situation occurs when cleanup begins of a long running transaction.
+
+RN315: Fixed a bug that could lead to a data log error, for example: Data log not found: '.../dlog-129602.xt'. This error occurred after a duplicate key error, dending on the table structure, because the row buffer was not restored after writing an extended record.
+
+RN314: Server startup time could be very long when data logs become large because the log size was not save in the header when a data log is full.
+
+------- 1.0.10j RC4 - 2010-03-24
+
+RN313: Fixed an error in the calculation of the handle data record (.xtd files) size when AVG_ROW_LENGTH is set explicitly to a value less than 12. For example:
+
+CREATE TABLE objs (
+  id int(10)  unsigned   NOT NULL,
+  objdata     mediumblob NOT NULL,
+  PRIMARY KEY (id)
+) ENGINE=PBXT AVG_ROW_LENGTH=10
+
+This table definition previously lead to corruption of the table because the handle data record was set to 24 (14+10), which is less than the minimum (for variable length records) handle data record size of 26.
+
+This minimum consists of 14 byte record header and 12 bytes reference to the extended record data (the part of the record in the data log).
+
+Tip: when setting AVG_ROW_LENGTH you should normally add 12 to the average row length estimate to ensure that the average length part of the record is always in the handle data file. This is important, for example if you wish to make sure that the rows used to build indexes are in the handle data file. CHECK TABLE tells you how many rows are in the "fixed length part" of the record (output in MySQL error log). In the example above, this would be AVG_ROW_LENGTH=17.
+
+The maximum size of a field can be calculated adding the maximum byte size as described here: http://dev.mysql.com/doc/refman/5.1/en/storage-requirements.html, and then add the following values, depending on the byte size:
+
+byte size <= 240, add 1
+byte size < 2^16 (65536), add 3
+byte size < 2^24 (16777216), add 4
+byte size > 2^24, add 5
+
+------- 1.0.10i RC4 - 2010-03-17
+
+RN312: Fixed bug #534361: Valgrind error: write of uninitialised bytes in xt_flush_indices()
+
+RN311: Fixed ilog corruption when running out of disk space during an index flush operation, which lead to corruption of the index.
+
+------- 1.0.10h RC4 - 2010-02-25
+
+RN310: Fixed Windows atomic INC/DEC operations, which lead to atomic R/W lock not working correctly. The result was that some index entries were not foound.
+
+RN309: Fixed a bug that caused a crash when the index was corrupted. The crash occurs if the index page in not completely written, and an item in the index has a bad length.
+
+RN308: Fixed bug #509803: can't run tpcc (cannot compare FKs that rely on indexes of different length).
+
+------- 1.0.10g RC4 - 2010-02-11
+
+RN307:  2010-02-15: Set the internal version number 1.0.10g.
+
+RN306: All tests now run with MySQL 5.1.42.
+
+RN305: Fixed a bug that could cause a crash in filesort. The problem was that the return row estimate was incorrect, which caused the result of estimate_rows_upper_bound() to overflow to zero. Row estimate has been changed, and no longer takes into account deleted rows (so the row estimate is now a maximum).
+
+RN304: Fixed bug #513012: On a table with a trigger the same record is updated more than once in one statement
+
+------- 1.0.10f RC4 - 2010-01-29
+
+RN303: Fix RN1/10 back-ported from 1.1: Fixed a bug in the record cache that caused PBXT to think it had run out of cache memory. The effect was that PBXT used less and less cache over time. The bug occurs during heavy concurrent access on the record cache. The affect is the PBXT gets slower and slower.
+
+RN302: Fix RN1/11 back-ported from 1.1: Corrected a problem that sometimes caused a pause in activity when the record cache was full.
+
+------- 1.0.10e RC4 - 2010-01-25
+
+RN301: Fixed index statistics calculation. This bug lead to the wrong indices being selected by the optimizer because all indices returned the same cost. 
+
+RN300: Fixed bug #509968: START TRANSACTION WITH CONSISTENT SNAPSHOT breaks transactional flow.
+
+RN299: Fixed bug #509218: Server asserts with Assertion `mutex->__data.__owner == 0' failed on high concurrency OLTP test.
+
+------- 1.0.10d RC4 - 2010-01-11
+
+RN298: Fixed a bug that caused huge amounts of transaction log to be written when pbxt_flush_log_at_trx_commit = 2.
+
+------- 1.0.10c RC4 - 2009-12-29
+
+RN297: Updated "LOCK TABLES ... READ LOCAL" behavior to be more restrictive and compatible with InnoDB 
+
+RN296: Fixed bug #499026: START TRANSACTION WITH CONSISTENT SNAPSHOT does not work for PBXT
+
+------- 1.0.10 RC4 - 2009-12-18
+
+RN295: PBXT tests now all run with MySQL 5.1.41.
+
+RN294: Fixed bug #483714: a broken table can prevent other tables from opening
+
+RN293: Added system variable pbxt_flush_log_at_trx_commit. The value of this variable determines whether the transaction log is written and/or flushed when a transaction is ended. A value of 0 means don't write or flush the transaction log, 1 means write and flush and 2 means write, but do not flush. No matter what the setting is choosen, the transaction log is written and flushed at least once per second.
+
 ------- 1.0.09g RC3 - 2009-12-16
 
 RN292: Fixed a bug that resulted in 2-phase commit not being used between PBXT and the binlog. This bug was a result of a hack which as added to solve a problem in an pre-release version of MySQL 5.1. The hack was removed. 

=== modified file 'storage/pbxt/src/backup_xt.cc'
--- storage/pbxt/src/backup_xt.cc	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/backup_xt.cc	2010-05-07 08:52:27 +0000
@@ -287,7 +287,7 @@
 		bd_table_no++;
 		try_(a)	{
 			xt_ha_open_database_of_table(self, (XTPathStrPtr) path);
-			tab = xt_use_table(self, (XTPathStrPtr) path, FALSE, FALSE, NULL);
+			tab = xt_use_table(self, (XTPathStrPtr) path, FALSE, FALSE);
 			pushr_(xt_heap_release, tab);
 			if (!(bd_ot = xt_db_open_table_using_tab(tab, bd_thread)))
 				xt_throw(self);
@@ -403,7 +403,7 @@
 	bd_thread->st_abort_trans = FALSE;
 	bd_thread->st_stat_ended = FALSE;
 	bd_thread->st_stat_trans = FALSE;
-	bd_thread->st_is_update = FALSE;
+	bd_thread->st_is_update = NULL;
 	if (!xt_xn_begin(bd_thread))
 		return backup::ERROR;
 	bd_state = BUP_STATE_AFTER_LOCK;
@@ -562,7 +562,7 @@
 		m_tables[rd_table_no-1].internal_name(path, sizeof(path));
 		try_(a)	{
 			xt_ha_open_database_of_table(self, (XTPathStrPtr) path);
-			tab = xt_use_table(self, (XTPathStrPtr) path, FALSE, FALSE, NULL);
+			tab = xt_use_table(self, (XTPathStrPtr) path, FALSE, FALSE);
 			pushr_(xt_heap_release, tab);
 			if (!(rd_ot = xt_db_open_table_using_tab(tab, rd_thread)))
 				xt_throw(self);

=== modified file 'storage/pbxt/src/cache_xt.cc'
--- storage/pbxt/src/cache_xt.cc	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/cache_xt.cc	2010-05-07 08:52:27 +0000
@@ -90,7 +90,7 @@
 #define IDX_CAC_INIT_LOCK(s, i)			xt_spinxslock_init_with_autoname(s, &(i)->cs_lock)
 #define IDX_CAC_FREE_LOCK(s, i)			xt_spinxslock_free(s, &(i)->cs_lock)	
 #define IDX_CAC_READ_LOCK(i, s)			xt_spinxslock_slock(&(i)->cs_lock, (s)->t_id)
-#define IDX_CAC_WRITE_LOCK(i, s)		xt_spinxslock_xlock(&(i)->cs_lock, (s)->t_id)
+#define IDX_CAC_WRITE_LOCK(i, s)		xt_spinxslock_xlock(&(i)->cs_lock, FALSE, (s)->t_id)
 #define IDX_CAC_UNLOCK(i, s)			xt_spinxslock_unlock(&(i)->cs_lock, (s)->t_id)
 #endif
 
@@ -178,6 +178,7 @@
 KEY_CACHE my_cache;
 #undef	pthread_rwlock_rdlock
 #undef	pthread_rwlock_wrlock
+#undef	pthread_rwlock_try_wrlock
 #undef	pthread_rwlock_unlock
 #undef	pthread_mutex_lock
 #undef	pthread_mutex_unlock
@@ -410,7 +411,7 @@
 	/* Because of the lock order, I have to release the
 	 * handle before I get a lock on the cache block.
 	 *
-	 * But, by doing this, thie cache block may be gone!
+	 * But, by doing this, this cache block may be gone!
 	 */
 	if (block) {
 		IDX_CAC_READ_LOCK(seg, thread);
@@ -420,6 +421,11 @@
 				/* Found the block... 
 				 * {HANDLE-COUNT-SLOCK}
 				 * 04.05.2009, changed to slock.
+				 * The xlock causes too much contention
+				 * on the cache block for read only loads.
+				 *
+				 * Is it safe?
+				 * See below...
 				 */
 				XT_IPAGE_READ_LOCK(&block->cb_lock);
 				goto block_found;
@@ -691,6 +697,9 @@
 		}
 	}
 
+	/* Must be done before freeing the blocks! */
+	ind_handle_exit(self);
+
 	if (ind_cac_globals.cg_blocks) {
 		xt_free(self, ind_cac_globals.cg_blocks);
 		ind_cac_globals.cg_blocks = NULL;
@@ -702,7 +711,6 @@
 		ind_cac_globals.cg_buffer = NULL;
 	}
 #endif
-	ind_handle_exit(self);
 
 	memset(&ind_cac_globals, 0, sizeof(ind_cac_globals));
 }
@@ -882,7 +890,58 @@
 	while (xblock) {
 		if (block == xblock) {
 			/* Found the block... */
-			XT_IPAGE_WRITE_LOCK(&block->cb_lock, ot->ot_thread->t_id);
+			/* It is possible that a thread enters this code holding a
+			 * lock on a page. This can cause a deadlock:
+			 *
+			 * #0	0x91faa2ce in semaphore_wait_signal_trap
+			 * #1	0x91fb1da5 in pthread_mutex_lock
+			 * #2	0x00e2ec13 in xt_p_mutex_lock at pthread_xt.cc:544
+			 * #3	0x00e6c30a in xt_xsmutex_xlock at lock_xt.cc:1547
+			 * #4	0x00dee402 in ind_free_block at cache_xt.cc:879
+			 * #5	0x00dee76a in ind_cac_free_lru_blocks at cache_xt.cc:1033
+			 * #6	0x00def8d1 in xt_ind_reserve at cache_xt.cc:1513
+			 * #7	0x00e22118 in xt_idx_insert at index_xt.cc:2047
+			 * #8	0x00e4d7ee in xt_tab_new_record at table_xt.cc:4702
+			 * #9	0x00e0ff0b in ha_pbxt::write_row at ha_pbxt.cc:2340
+			 * #10	0x0023a00f in handler::ha_write_row at handler.cc:4570
+			 * #11	0x001a32c8 in write_record at sql_insert.cc:1568
+			 * #12	0x001ab635 in mysql_insert at sql_insert.cc:812
+			 * #13	0x0010e068 in mysql_execute_command at sql_parse.cc:3066
+			 * #14	0x0011480d in mysql_parse at sql_parse.cc:5787
+			 * #15	0x00115afb in dispatch_command at sql_parse.cc:1200
+			 * #16	0x00116de2 in do_command at sql_parse.cc:857
+			 * #17	0x00101ee4 in handle_one_connection at sql_connect.cc:1115
+			 * #18	0x91fdb155 in _pthread_start
+			 * #19	0x91fdb012 in thread_start
+			 * 
+			 * #0	0x91fb146e in __semwait_signal
+			 * #1	0x91fb12ef in nanosleep$UNIX2003
+			 * #2	0x91fb1236 in usleep$UNIX2003
+			 * #3	0x00e52112 in xt_yield at thread_xt.cc:1274
+			 * #4	0x00e6c0eb in xt_spinxslock_xlock at lock_xt.cc:1456
+			 * #5	0x00dee444 in ind_free_block at cache_xt.cc:886
+			 * #6	0x00dee76a in ind_cac_free_lru_blocks at cache_xt.cc:1033
+			 * #7	0x00deeaf0 in ind_cac_fetch at cache_xt.cc:1130
+			 * #8	0x00def604 in xt_ind_fetch at cache_xt.cc:1386
+			 * #9	0x00e2159a in xt_idx_update_row_id at index_xt.cc:2489
+			 * #10	0x00e603c8 in xn_sw_clean_indices at xaction_xt.cc:1932
+			 * #11	0x00e606d4 in xn_sw_cleanup_variation at xaction_xt.cc:2056
+			 * #12	0x00e60e29 in xn_sw_cleanup_xact at xaction_xt.cc:2276
+			 * #13	0x00e615ed in xn_sw_main at xaction_xt.cc:2433
+			 * #14	0x00e61919 in xn_sw_run_thread at xaction_xt.cc:2564
+			 * #15	0x00e53f80 in thr_main at thread_xt.cc:1017
+			 * #16	0x91fdb155 in _pthread_start
+			 * #17	0x91fdb012 in thread_start
+			 *
+			 * So we back off if a lock is held!
+			 */
+			if (!XT_IPAGE_WRITE_TRY_LOCK(&block->cb_lock, ot->ot_thread->t_id)) {
+				IDX_CAC_UNLOCK(seg, ot->ot_thread);
+#ifdef DEBUG_CHECK_IND_CACHE
+				xt_ind_check_cache(NULL);
+#endif
+				return FALSE;
+			}
 			if (block->cb_state != IDX_CAC_BLOCK_CLEAN) {
 				/* This block cannot be freeed: */
 				XT_IPAGE_UNLOCK(&block->cb_lock, TRUE);
@@ -1376,6 +1435,7 @@
 	register XTIndBlockPtr	block;
 	DcSegmentPtr			seg;
 	xtWord2					branch_size;
+	u_int					rec_size;
 	xtBool					xlock = FALSE;
 
 #ifdef DEBUG
@@ -1386,10 +1446,24 @@
 		return FAILED;
 
 	branch_size = XT_GET_DISK_2(((XTIdxBranchDPtr) block->cb_data)->tb_size_2);
-	if (XT_GET_INDEX_BLOCK_LEN(branch_size) < 2 || XT_GET_INDEX_BLOCK_LEN(branch_size) > XT_INDEX_PAGE_SIZE) {
-		IDX_CAC_UNLOCK(seg, ot->ot_thread);
-		xt_register_taberr(XT_REG_CONTEXT, XT_ERR_INDEX_CORRUPTED, ot->ot_table->tab_name);
-		return FAILED;
+	rec_size = XT_GET_INDEX_BLOCK_LEN(branch_size);
+	if (rec_size < 2 || rec_size > XT_INDEX_PAGE_SIZE)
+		goto failed_corrupt;
+	if (ind->mi_fix_key) {
+		rec_size -= 2;
+		if (XT_IS_NODE(branch_size)) {
+			if (rec_size != 0) {
+				if (rec_size < XT_NODE_REF_SIZE)
+					goto failed_corrupt;
+				rec_size -= XT_NODE_REF_SIZE;
+				if ((rec_size % (ind->mi_key_size + XT_RECORD_REF_SIZE + XT_NODE_REF_SIZE)) != 0)
+					goto failed_corrupt;
+			}
+		}
+		else {
+			if ((rec_size % (ind->mi_key_size + XT_RECORD_REF_SIZE)) != 0)
+				goto failed_corrupt;
+		}
 	}
 
 	switch (ltype) {
@@ -1450,6 +1524,11 @@
 	iref->ir_block = block;
 	iref->ir_branch = (XTIdxBranchDPtr) block->cb_data;
 	return OK;
+
+	failed_corrupt:
+	IDX_CAC_UNLOCK(seg, ot->ot_thread);
+	xt_register_taberr(XT_REG_CONTEXT, XT_ERR_INDEX_CORRUPTED, ot->ot_table->tab_name);
+	return FAILED;
 }
 
 xtPublic xtBool xt_ind_release(XTOpenTablePtr ot, XTIndexPtr ind, XTPageUnlockType XT_NDEBUG_UNUSED(utype), XTIndReferencePtr iref)

=== modified file 'storage/pbxt/src/cache_xt.h'
--- storage/pbxt/src/cache_xt.h	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/cache_xt.h	2010-05-07 08:52:27 +0000
@@ -58,7 +58,8 @@
 #define XT_IPAGE_INIT_LOCK(s, i)		xt_atomicrwlock_init_with_autoname(s, i)
 #define XT_IPAGE_FREE_LOCK(s, i)		xt_atomicrwlock_free(s, i)	
 #define XT_IPAGE_READ_LOCK(i)			xt_atomicrwlock_slock(i)
-#define XT_IPAGE_WRITE_LOCK(i, o)		xt_atomicrwlock_xlock(i, o)
+#define XT_IPAGE_WRITE_LOCK(i, o)		xt_atomicrwlock_xlock(i, FALSE, o)
+#define XT_IPAGE_WRITE_TRY_LOCK(i, o)	xt_atomicrwlock_xlock(i, TRUE, o)
 #define XT_IPAGE_UNLOCK(i, x)			xt_atomicrwlock_unlock(i, x)
 #elif defined(XT_IPAGE_USE_PTHREAD_RW)
 #define XT_IPAGE_LOCK_TYPE				xt_rwlock_type
@@ -66,20 +67,23 @@
 #define XT_IPAGE_FREE_LOCK(s, i)		xt_free_rwlock(i)	
 #define XT_IPAGE_READ_LOCK(i)			xt_slock_rwlock_ns(i)
 #define XT_IPAGE_WRITE_LOCK(i, s)		xt_xlock_rwlock_ns(i)
+#define XT_IPAGE_WRITE_TRY_LOCK(i, s)	xt_xlock_try_rwlock_ns(i)
 #define XT_IPAGE_UNLOCK(i, x)			xt_unlock_rwlock_ns(i)
 #elif defined(XT_IPAGE_USE_SPINXSLOCK)
 #define XT_IPAGE_LOCK_TYPE				XTSpinXSLockRec
 #define XT_IPAGE_INIT_LOCK(s, i)		xt_spinxslock_init_with_autoname(s, i)
 #define XT_IPAGE_FREE_LOCK(s, i)		xt_spinxslock_free(s, i)	
 #define XT_IPAGE_READ_LOCK(i)			xt_spinxslock_slock(i)
-#define XT_IPAGE_WRITE_LOCK(i, o)		xt_spinxslock_xlock(i, o)
+#define XT_IPAGE_WRITE_LOCK(i, o)		xt_spinxslock_xlock(i, FALSE, o)
+#define XT_IPAGE_WRITE_TRY_LOCK(i, o)	xt_spinxslock_xlock(i, TRUE, o)
 #define XT_IPAGE_UNLOCK(i, x)			xt_spinxslock_unlock(i, x)
 #else // XT_IPAGE_USE_SKEW_RW
 #define XT_IPAGE_LOCK_TYPE				XTSkewRWLockRec
 #define XT_IPAGE_INIT_LOCK(s, i)		xt_skewrwlock_init_with_autoname(s, i)
 #define XT_IPAGE_FREE_LOCK(s, i)		xt_skewrwlock_free(s, i)	
 #define XT_IPAGE_READ_LOCK(i)			xt_skewrwlock_slock(i)
-#define XT_IPAGE_WRITE_LOCK(i, o)		xt_skewrwlock_xlock(i, o)
+#define XT_IPAGE_WRITE_LOCK(i, o)		xt_skewrwlock_xlock(i, FALSE, o)
+#define XT_IPAGE_WRITE_TRY_LOCK(i, o)	xt_skewrwlock_xlock(i, TRUE, o)
 #define XT_IPAGE_UNLOCK(i, x)			xt_skewrwlock_unlock(i, x)
 #endif
 
@@ -103,10 +107,10 @@
 	struct XTIndBlock	*cb_lr_used;					/* Less recently used blocks. */
 	/* Protected by cb_lock: */
 	XT_IPAGE_LOCK_TYPE	cb_lock;
-	xtWord1				cb_state;						/* Block status. */
+	xtWord4				cp_flush_seq;
 	xtWord2				cb_handle_count;				/* TRUE if this page is referenced by a handle. */
-	xtWord2				cp_flush_seq;
 	xtWord2				cp_del_count;					/* Number of deleted entries. */
+	xtWord1				cb_state;						/* Block status. */
 #ifdef XT_USE_DIRECT_IO_ON_INDEX
 	xtWord1				*cb_data;
 #else

=== modified file 'storage/pbxt/src/database_xt.cc'
--- storage/pbxt/src/database_xt.cc	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/database_xt.cc	2010-05-07 08:52:27 +0000
@@ -68,6 +68,7 @@
 xtPublic int				xt_db_auto_increment_mode;		/* 0 = MySQL compatible, 1 = PrimeBase Compatible. */
 xtPublic int				xt_db_offline_log_function;		/* 0 = recycle logs, 1 = delete logs, 2 = keep logs */
 xtPublic int				xt_db_sweeper_priority;			/* 0 = low (default), 1 = normal, 2 = high */
+xtPublic int				xt_db_flush_log_at_trx_commit;	/* 0 = no-write/no-flush, 1 = yes, 2 = write/no-flush */
 
 xtPublic XTSortedListPtr	xt_db_open_db_by_id = NULL;
 xtPublic XTHashTabPtr		xt_db_open_databases = NULL;
@@ -288,6 +289,7 @@
 				/* Wait for the checkpointer: */
 				xt_wait_for_checkpointer(self, db);
 			}
+			xt_stop_flusher(self, db);
 			xt_stop_checkpointer(self, db);
 			xt_stop_writer(self, db);
 			xt_stop_sweeper(self, db);
@@ -317,6 +319,7 @@
 {
 	XTDatabaseHPtr	db = (XTDatabaseHPtr) x;
 
+	xt_stop_flusher(self, db);
 	xt_stop_checkpointer(self, db);
 	xt_stop_compactor(self, db);
 	xt_stop_sweeper(self, db);
@@ -475,6 +478,8 @@
 		xt_start_compactor(self, db);
 		xt_start_writer(self, db);
 		xt_start_checkpointer(self, db);
+		if (xt_db_flush_log_at_trx_commit == 0 || xt_db_flush_log_at_trx_commit == 2)
+			xt_start_flusher(self, db);
 
 		popr_();
 		xt_ht_put(self, xt_db_open_databases, db);
@@ -574,6 +579,7 @@
 	pushr_(xt_ht_unlock, xt_db_open_databases);
 
 	/* Shutdown the database daemons: */
+	xt_stop_flusher(self, db);
 	xt_stop_checkpointer(self, db);
 	xt_stop_sweeper(self, db);
 	xt_stop_compactor(self, db);
@@ -902,7 +908,7 @@
 	XTTableHPtr			tab;
 	xtTableID			tab_id;
 
-	pushsr_(tab, xt_heap_release, xt_use_table(self, tab_name, no_load, missing_ok, NULL));
+	pushsr_(tab, xt_heap_release, xt_use_table(self, tab_name, no_load, missing_ok));
 	if (!tab) {
 		freer_(); // xt_heap_release(tab)
 		return NULL;

=== modified file 'storage/pbxt/src/database_xt.h'
--- storage/pbxt/src/database_xt.h	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/database_xt.h	2010-05-07 08:52:27 +0000
@@ -60,6 +60,7 @@
 extern int				xt_db_auto_increment_mode;
 extern int				xt_db_offline_log_function;
 extern int				xt_db_sweeper_priority;
+extern int				xt_db_flush_log_at_trx_commit;
 
 extern XTSortedListPtr	xt_db_open_db_by_id;
 extern XTHashTabPtr		xt_db_open_databases;
@@ -187,6 +188,10 @@
 	xt_mutex_type			db_cp_lock;
 	xt_cond_type			db_cp_cond;								/* Writer condition when idle (must bw woken by log flush! */
 	XTCheckPointStateRec	db_cp_state;							/* The checkpoint state. */
+
+	/* The "flusher" thread (used when pbxt_flush_log_at_trx_commit = 0 or 2) */
+	struct XTThread			*db_fl_thread;							/* The flusher thread (flushes the transation log). */
+	xt_mutex_type			db_fl_lock;
 } XTDatabaseRec, *XTDatabaseHPtr;		/* Heap pointer */
 
 #define XT_FOR_USER					0

=== modified file 'storage/pbxt/src/datadic_xt.cc'
--- storage/pbxt/src/datadic_xt.cc	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/datadic_xt.cc	2010-05-07 08:52:27 +0000
@@ -1142,8 +1142,8 @@
 
 void XTParseTable::parseReferenceDefinition(XTThreadPtr self, u_int req_cols)
 {
-	int		on_delete = XT_KEY_ACTION_DEFAULT;
-	int		on_update = XT_KEY_ACTION_DEFAULT;
+	int		on_delete = XT_KEY_ACTION_RESTRICT;
+	int		on_update = XT_KEY_ACTION_RESTRICT;
 	char	name[XT_IDENTIFIER_NAME_SIZE];
 	char	parent_name[XT_IDENTIFIER_NAME_SIZE];
 	u_int	cols = 0;
@@ -1437,7 +1437,7 @@
 		XTTableHPtr	tab;
 
 		/* Find the table... */
-		pushsr_(tab, xt_heap_release, xt_use_table(self, (XTPathStrPtr) path, FALSE, TRUE, NULL));
+		pushsr_(tab, xt_heap_release, xt_use_table(self, (XTPathStrPtr) path, FALSE, TRUE));
 
 		/* Clone the foreign key definitions: */
 		if (tab && tab->tab_dic.dic_table) {
@@ -2027,24 +2027,52 @@
 void XTDDTableRef::deleteAllRows(XTThreadPtr self)
 {
 	XTOpenTablePtr	ot;
-	xtInt8			row_count;
+	xtBool			eof;
+	xtWord1			*buffer;
 
 	if (!tr_fkey->getReferenceIndexPtr())
-		throw_();
+		xt_throw(self);
 
 	if (!tr_fkey->getIndexPtr())
-		throw_();
+		xt_throw(self);
 
 	if (!(ot = xt_db_open_table_using_tab(tr_fkey->co_table->dt_table, self)))
-		throw_();
+		xt_throw(self);
 
+	/* {FREE-ROWS-BAD} */
+	/*
 	row_count = ((xtInt8) ot->ot_table->tab_row_eof_id) - 1;
 	row_count -= (xtInt8) ot->ot_table->tab_row_fnum;
+	*/
+	/* Check if there are any rows in the referencing table: */
+	if (!xt_tab_seq_init(ot))
+		goto failed;
+
+	if (!(buffer = (xtWord1 *) xt_malloc(self, ot->ot_table->tab_dic.dic_mysql_buf_size)))
+		goto failed_1;
+
+	if (!xt_tab_seq_next(ot, buffer, &eof))
+		goto failed_2;
+
+	xt_free(self, buffer);
+
+	xt_tab_seq_exit(ot);
 
 	xt_db_return_table_to_pool_ns(ot);
 
-	if (row_count > 0)
+	if (!eof)
 		xt_throw_ixterr(XT_CONTEXT, XT_ERR_ROW_IS_REFERENCED, tr_fkey->co_name);
+	return;
+
+	failed_2:
+	xt_free(self, buffer);
+
+	failed_1:
+	xt_tab_seq_exit(ot);
+
+	failed:
+	xt_db_return_table_to_pool_ns(ot);
+	xt_throw(self);
 }
 
 void  XTDDIndex::init(XTThreadPtr self, XTObject *obj)
@@ -2117,7 +2145,7 @@
 	}
 	xt_sb_concat(self, sb, "`)");
 	
-	if (fk_on_delete != XT_KEY_ACTION_DEFAULT && fk_on_delete != XT_KEY_ACTION_RESTRICT) {
+	if (fk_on_delete != XT_KEY_ACTION_RESTRICT) {
 		xt_sb_concat(self, sb, " ON DELETE ");
 		switch (fk_on_delete) {
 			case XT_KEY_ACTION_CASCADE:		xt_sb_concat(self, sb, "CASCADE"); break;
@@ -2126,10 +2154,9 @@
 			case XT_KEY_ACTION_NO_ACTION:	xt_sb_concat(self, sb, "NO ACTION"); break;
 		}
 	}
-	if (fk_on_update != XT_KEY_ACTION_DEFAULT && fk_on_update != XT_KEY_ACTION_RESTRICT) {
+	if (fk_on_update != XT_KEY_ACTION_RESTRICT) {
 		xt_sb_concat(self, sb, " ON UPDATE ");
 		switch (fk_on_update) {
-			case XT_KEY_ACTION_DEFAULT:		xt_sb_concat(self, sb, "RESTRICT"); break;
 			case XT_KEY_ACTION_RESTRICT:	xt_sb_concat(self, sb, "RESTRICT"); break;
 			case XT_KEY_ACTION_CASCADE:		xt_sb_concat(self, sb, "CASCADE"); break;
 			case XT_KEY_ACTION_SET_NULL:	xt_sb_concat(self, sb, "SET NULL"); break;
@@ -2259,8 +2286,8 @@
 {
 	XTDDTable *ref_tab;
 
-	xt_xlock_rwlock(self, &co_table->dt_ref_lock);
-	pushr_(xt_unlock_rwlock, &co_table->dt_ref_lock);
+	xt_recurrwlock_xlock(self, &co_table->dt_ref_lock);
+	pushr_(xt_recurrwlock_unxlock, &co_table->dt_ref_lock);
 
 	if ((ref_tab = fk_ref_table)) {			
 		fk_ref_table = NULL;
@@ -2270,7 +2297,7 @@
 
 	fk_ref_index = UINT_MAX;
 
-	freer_(); // xt_unlock_rwlock(&co_table->dt_ref_lock);
+	freer_(); // xt_recurrwlock_unxlock(&co_table->dt_ref_lock);
 }
 
 /*
@@ -2289,7 +2316,7 @@
 	/* This lock ensures that the foreign key references are not
 	 * changed.
 	 */
-	xt_slock_rwlock_ns(&co_table->dt_ref_lock);
+	xt_recurrwlock_slock_ns(&co_table->dt_ref_lock);
 
 	if (!(loc_ind = getIndexPtr()))
 		goto failed;
@@ -2374,11 +2401,11 @@
 	xt_db_return_table_to_pool_ns(ot);
 
 	failed:
-	xt_unlock_rwlock_ns(&co_table->dt_ref_lock);
+	xt_recurrwlock_unslock_ns(&co_table->dt_ref_lock);
 	return false;
 
 	success:
-	xt_unlock_rwlock_ns(&co_table->dt_ref_lock);
+	xt_recurrwlock_unslock_ns(&co_table->dt_ref_lock);
 	return true;
 }
 
@@ -2389,7 +2416,6 @@
 {
 	switch (action)
 	{
-	case XT_KEY_ACTION_DEFAULT:
 	case XT_KEY_ACTION_RESTRICT:
 		return "RESTRICT";
 	case XT_KEY_ACTION_CASCADE:
@@ -2407,7 +2433,7 @@
 
 void XTDDTable::init(XTThreadPtr self)
 {
-	xt_init_rwlock_with_autoname(self, &dt_ref_lock);
+	xt_recurrwlock_init_with_autoname(self, &dt_ref_lock);
 	dt_trefs = NULL;
 }
 
@@ -2444,7 +2470,7 @@
 		ptr->release(self);
 	}
 
-	xt_free_rwlock(&dt_ref_lock);
+	xt_recurrwlock_free(&dt_ref_lock);
 }
 
 XTDDColumn *XTDDTable::findColumn(char *name)
@@ -2520,8 +2546,8 @@
 			throw_();
 	}
 
-	xt_xlock_rwlock(self, &dt_ref_lock);
-	pushr_(xt_unlock_rwlock, &dt_ref_lock);
+	xt_recurrwlock_xlock(self, &dt_ref_lock);
+	pushr_(xt_recurrwlock_unxlock, &dt_ref_lock);
 
 	if (!(tr = new XTDDTableRef()))
 		xt_throw_errno(XT_CONTEXT, XT_ENOMEM);
@@ -2536,7 +2562,7 @@
 	 */
 	xt_heap_reference(self, fk->co_table->dt_table);
 
-	freer_(); // xt_unlock_rwlock(&dt_ref_lock);
+	freer_(); // xt_recurrwlock_unxlock(&dt_ref_lock);
 }
 
 /*
@@ -2546,8 +2572,8 @@
 {
 	XTDDTableRef	*tr, *prev_tr = NULL;
 
-	xt_xlock_rwlock(self, &dt_ref_lock);
-	pushr_(xt_unlock_rwlock, &dt_ref_lock);
+	xt_recurrwlock_xlock(self, &dt_ref_lock);
+	pushr_(xt_recurrwlock_unxlock, &dt_ref_lock);
 
 	tr = dt_trefs;
 	while (tr) {
@@ -2561,7 +2587,7 @@
 		prev_tr = tr;
 		tr = tr->tr_next;
 	}
-	freer_(); // xt_unlock_rwlock(&dt_ref_lock);
+	freer_(); // xt_recurrwlock_unxlock(&dt_ref_lock);
 	if (tr)
 		tr->release(self);
 }
@@ -2588,8 +2614,8 @@
 
 			dt->attachReference(self, fk);
 
-			xt_xlock_rwlock(self, &dt_ref_lock);
-			pushr_(xt_unlock_rwlock, &dt_ref_lock);
+			xt_recurrwlock_xlock(self, &dt_ref_lock);
+			pushr_(xt_recurrwlock_unxlock, &dt_ref_lock);
 			/* Referenced the table, not the index!
 			 * We do this because we know that if the table is referenced, the
 			 * index will remain valid!
@@ -2599,7 +2625,7 @@
 			 */
 			xt_heap_reference(self, dt->dt_table);
 			fk->fk_ref_table = dt;
-			freer_(); // xt_unlock_rwlock(&dt_ref_lock);
+			freer_(); // xt_recurrwlock_unxlock(&dt_ref_lock);
 		}
 	}
 }
@@ -2626,7 +2652,7 @@
 			/* get pointer to the referenced table, load it if needed
 			 * cyclic references are being handled, absent table is ignored
 			 */
-			tab = xt_use_table_no_lock(self, db, fk->fk_ref_tab_name, /*TRUE*/FALSE, /*FALSE*/TRUE, NULL, NULL);
+			tab = xt_use_table_no_lock(self, db, fk->fk_ref_tab_name, /*TRUE*/FALSE, /*FALSE*/TRUE, NULL);
 
 			if (tab) {
 				pushr_(xt_heap_release, tab);
@@ -2663,8 +2689,8 @@
 	XTDDTableRef	*tr;
 	XTDDTable		*tab;
 
-	xt_xlock_rwlock(self, &dt_ref_lock);
-	pushr_(xt_unlock_rwlock, &dt_ref_lock);
+	xt_recurrwlock_xlock(self, &dt_ref_lock);
+	pushr_(xt_recurrwlock_unxlock, &dt_ref_lock);
 
 	for (u_int i=0; i<dt_fkeys.size(); i++) {
 		fk = dt_fkeys.itemAt(i);
@@ -2675,13 +2701,13 @@
 				/* To avoid deadlock we do not hold more than
 				 * one lock at a time!
 				 */
-				freer_(); // xt_unlock_rwlock(&dt_ref_lock);
+				freer_(); // xt_recurrwlock_unxlock(&dt_ref_lock);
 	
 				tab->removeReference(self, fk);
 				xt_heap_release(self, tab->dt_table); /* We referenced the table, not the index! */
 	
-				xt_xlock_rwlock(self, &dt_ref_lock);
-				pushr_(xt_unlock_rwlock, &dt_ref_lock);
+				xt_recurrwlock_xlock(self, &dt_ref_lock);
+				pushr_(xt_recurrwlock_unxlock, &dt_ref_lock);
 			}
 		}
 	}
@@ -2689,13 +2715,13 @@
 	while (dt_trefs) {
 		tr = dt_trefs;
 		dt_trefs = tr->tr_next;
-		freer_(); // xt_unlock_rwlock(&dt_ref_lock);
+		freer_(); // xt_recurrwlock_unxlock(&dt_ref_lock);
 		tr->release(self);
-		xt_xlock_rwlock(self, &dt_ref_lock);
-		pushr_(xt_unlock_rwlock, &dt_ref_lock);
+		xt_recurrwlock_xlock(self, &dt_ref_lock);
+		pushr_(xt_recurrwlock_unxlock, &dt_ref_lock);
 	}
 
-	freer_(); // xt_unlock_rwlock(&dt_ref_lock);
+	freer_(); // xt_recurrwlock_unxlock(&dt_ref_lock);
 }
 
 void XTDDTable::checkForeignKeys(XTThreadPtr self, bool temp_table)
@@ -2727,7 +2753,7 @@
 		// TODO: dont close table immediately so it can be possibly reused in this loop
 		XTTable *ref_tab;
 
-		pushsr_(ref_tab, xt_heap_release, xt_use_table(self, fk->fk_ref_tab_name, FALSE, TRUE, NULL));
+		pushsr_(ref_tab, xt_heap_release, xt_use_table(self, fk->fk_ref_tab_name, FALSE, TRUE));
 		if (ref_tab && !fk->checkReferencedTypes(ref_tab->tab_dic.dic_table))
 			throw_();
 		freer_();
@@ -2845,7 +2871,7 @@
 		return false;
 	rec_ptr = rec_buf.ib_db.db_data;
 
-	xt_slock_rwlock_ns(&dt_ref_lock);
+	xt_recurrwlock_slock_ns(&dt_ref_lock);
 	tr = dt_trefs;
 	while (tr) {
 		if (!tr->checkReference(rec_ptr, ot->ot_thread)) {
@@ -2854,7 +2880,7 @@
 		}
 		tr = tr->tr_next;
 	}
-	xt_unlock_rwlock_ns(&dt_ref_lock);
+	xt_recurrwlock_unslock_ns(&dt_ref_lock);
 	xt_ib_free(NULL, &rec_buf);
 	return ok;
 }
@@ -2875,7 +2901,7 @@
 		rec_ptr = rec_buf.ib_db.db_data;
 		
 	}
-	xt_slock_rwlock_ns(&dt_ref_lock);
+	xt_recurrwlock_slock_ns(&dt_ref_lock);
 	tr = dt_trefs;
 	while (tr) {
 		if (!tr->modifyRow(ot, rec_ptr, NULL, ot->ot_thread)) {
@@ -2884,7 +2910,7 @@
 		}
 		tr = tr->tr_next;
 	}
-	xt_unlock_rwlock_ns(&dt_ref_lock);
+	xt_recurrwlock_unslock_ns(&dt_ref_lock);
 	xt_ib_free(NULL, &rec_buf);
 	return ok;
 }
@@ -2893,8 +2919,8 @@
 {
 	XTDDTableRef	*tr;
 
-	xt_slock_rwlock(self, &dt_ref_lock);
-	pushr_(xt_unlock_rwlock, &dt_ref_lock);
+	xt_recurrwlock_slock(self, &dt_ref_lock);
+	pushr_(xt_recurrwlock_unslock, &dt_ref_lock);
 
 	tr = dt_trefs;
 	while (tr) {
@@ -2902,7 +2928,7 @@
 		tr = tr->tr_next;
 	}
 
-	freer_(); // xt_unlock_rwlock(&dt_ref_lock);
+	freer_(); // xt_recurrwlock_unslock(&dt_ref_lock);
 }
 
 bool XTDDTable::updateRow(XTOpenTablePtr ot, xtWord1 *before, xtWord1 *after)
@@ -2932,7 +2958,7 @@
 	ok = true;
 	before_buf.ib_free = FALSE;
 
-	xt_slock_rwlock_ns(&dt_ref_lock);
+	xt_recurrwlock_slock_ns(&dt_ref_lock);
 	if ((tr = dt_trefs)) {
 		if (!before) {
 			if (!xt_tab_load_record(ot, ot->ot_curr_rec_id, &before_buf))
@@ -2948,7 +2974,7 @@
 			tr = tr->tr_next;
 		}
 	}
-	xt_unlock_rwlock_ns(&dt_ref_lock);
+	xt_recurrwlock_unslock_ns(&dt_ref_lock);
 	
 	xt_ib_free(NULL, &before_buf);
 	return ok;

=== modified file 'storage/pbxt/src/datadic_xt.h'
--- storage/pbxt/src/datadic_xt.h	2009-08-18 07:46:53 +0000
+++ storage/pbxt/src/datadic_xt.h	2010-05-07 08:52:27 +0000
@@ -45,7 +45,6 @@
 #define XT_DD_KEY_PRIMARY			2
 #define XT_DD_KEY_FOREIGN			3
 
-#define XT_KEY_ACTION_DEFAULT		0
 #define XT_KEY_ACTION_RESTRICT		1
 #define XT_KEY_ACTION_CASCADE		2
 #define XT_KEY_ACTION_SET_NULL		3
@@ -259,7 +258,7 @@
 	XTList<XTDDColumn>		dt_cols;
 	XTList<XTDDIndex>		dt_indexes;
 
-	xt_rwlock_type			dt_ref_lock;			/* The lock for adding and using references. */
+	XTRecurRWLockRec		dt_ref_lock;			/* The lock for adding and using references. */
 	XTList<XTDDForeignKey>	dt_fkeys;				/* The foreign keys on this table. */
 	XTDDTableRef			*dt_trefs;				/* A list of tables that reference this table. */
 

=== modified file 'storage/pbxt/src/datalog_xt.cc'
--- storage/pbxt/src/datalog_xt.cc	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/datalog_xt.cc	2010-05-07 08:52:27 +0000
@@ -1148,6 +1148,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;
@@ -1952,7 +1957,7 @@
 	log_rec.xl_status_1 = XT_LOG_ENT_DEL_LOG;
 	log_rec.xl_checksum_1 = XT_CHECKSUM_1(data_log->dlf_log_id);
 	XT_SET_DISK_4(log_rec.xl_log_id_4, data_log->dlf_log_id);
-	if (!xt_xlog_log_data(self, sizeof(XTXactNewLogEntryDRec), (XTXactLogBufferDPtr) &log_rec, TRUE)) {
+	if (!xt_xlog_log_data(self, sizeof(XTXactNewLogEntryDRec), (XTXactLogBufferDPtr) &log_rec, XT_XLOG_WRITE_AND_FLUSH)) {
 		db->db_datalogs.dls_set_log_state(data_log, XT_DL_TO_COMPACT);
 		xt_throw(self);
 	}

=== modified file 'storage/pbxt/src/filesys_xt.h'
--- storage/pbxt/src/filesys_xt.h	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/filesys_xt.h	2010-05-07 08:52:27 +0000
@@ -119,7 +119,7 @@
 #define FILE_MAP_INIT_LOCK(s, i)		xt_spinxslock_init_with_autoname(s, i)
 #define FILE_MAP_FREE_LOCK(s, i)		xt_spinxslock_free(s, i)	
 #define FILE_MAP_READ_LOCK(i, o)		xt_spinxslock_slock(i, o)
-#define FILE_MAP_WRITE_LOCK(i, o)		xt_spinxslock_xlock(i, o)
+#define FILE_MAP_WRITE_LOCK(i, o)		xt_spinxslock_xlock(i, FALSE, o)
 #define FILE_MAP_UNLOCK(i, o)			xt_spinxslock_unlock(i, o)
 #endif
 

=== modified file 'storage/pbxt/src/ha_pbxt.cc'
--- storage/pbxt/src/ha_pbxt.cc	2010-01-06 21:27:53 +0000
+++ storage/pbxt/src/ha_pbxt.cc	2010-05-07 08:52:27 +0000
@@ -113,6 +113,7 @@
 static int		pbxt_recover(handlerton *hton, XID *xid_list, uint len);
 static int		pbxt_commit_by_xid(handlerton *hton, XID *xid);
 static int		pbxt_rollback_by_xid(handlerton *hton, XID *xid);
+static int		pbxt_start_consistent_snapshot(handlerton *hton, THD *thd);
 #endif
 static void		ha_aquire_exclusive_use(XTThreadPtr self, XTSharePtr share, ha_pbxt *mine);
 static void		ha_release_exclusive_use(XTThreadPtr self, XTSharePtr share);
@@ -286,7 +287,7 @@
 	char		func_buf[50], *ptr;
 	XTThreadPtr	thread = xt_get_self(); 
 
-	if ((ptr = strchr(function, '('))) {
+	if ((ptr = const_cast<char *>(strchr(function, '(')))) {
 		ptr--;
 		while (ptr > function) {
 			if (!(isalnum(*ptr) || *ptr == '_'))
@@ -345,13 +346,13 @@
 	return xt_ht_casehash(share->sh_table_path->ps_path);
 }
 
-static void ha_open_share(XTThreadPtr self, XTShareRec *share, xtBool *tabled_opened)
+static void ha_open_share(XTThreadPtr self, XTShareRec *share)
 {
 	xt_lock_mutex(self, (xt_mutex_type *) share->sh_ex_mutex);
 	pushr_(xt_unlock_mutex, share->sh_ex_mutex);
 
 	if (!share->sh_table) {
-		share->sh_table = xt_use_table(self, share->sh_table_path, FALSE, FALSE, tabled_opened);
+		share->sh_table = xt_use_table(self, share->sh_table_path, FALSE, FALSE);
 		share->sh_dic_key_count = share->sh_table->tab_dic.dic_key_count;
 		share->sh_dic_keys = share->sh_table->tab_dic.dic_keys;
 		share->sh_recalc_selectivity = FALSE;
@@ -411,7 +412,7 @@
  * This structure contains information that is common to all handles.
  * (i.e. it is table specific).
  */
-static XTSharePtr ha_get_share(XTThreadPtr self, const char *table_path, bool open_table, xtBool *tabled_opened)
+static XTSharePtr ha_get_share(XTThreadPtr self, const char *table_path, bool open_table)
 {
 	XTShareRec	*share;
 
@@ -433,7 +434,7 @@
 		share->sh_table_path = (XTPathStrPtr) xt_dup_string(self, table_path);
 
 		if (open_table)
-			ha_open_share(self, share, tabled_opened);
+			ha_open_share(self, share);
 
 		popr_(); // Discard ha_cleanup_share(share);
 
@@ -476,6 +477,25 @@
 	return removed;
 }
 
+static inline void thd_init_xact(THD *thd, XTThreadPtr self, bool set_table_trans)
+{
+	self->st_xact_mode = thd_tx_isolation(thd) <= ISO_READ_COMMITTED ? XT_XACT_COMMITTED_READ : XT_XACT_REPEATABLE_READ;
+	self->st_ignore_fkeys = (thd_test_options(thd, OPTION_NO_FOREIGN_KEY_CHECKS)) != 0;
+	self->st_auto_commit = (thd_test_options(thd,(OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) == 0;
+	if (set_table_trans) {
+#ifdef DRIZZLED
+		self->st_table_trans = FALSE;
+#else
+		self->st_table_trans = thd_sql_command(thd) == SQLCOM_LOCK_TABLES;
+#endif
+	}
+	self->st_abort_trans = FALSE;
+	self->st_stat_ended = FALSE;
+	self->st_stat_trans = FALSE;
+	XT_PRINT0(self, "xt_xn_begin\n");
+	xt_xres_wait_for_recovery(self, XT_RECOVER_SWEPT);
+}
+
 /*
  * -----------------------------------------------------------------------
  * PUBLIC FUNCTIONS
@@ -1146,6 +1166,7 @@
 		pbxt_hton->show_status = pbxt_show_status;
 		pbxt_hton->flags = HTON_NO_FLAGS; /* HTON_CAN_RECREATE - Without this flags TRUNCATE uses delete_all_rows() */
 		pbxt_hton->slot = (uint)-1; /* assign invald value, so we know when it's inited later */
+		pbxt_hton->start_consistent_snapshot = pbxt_start_consistent_snapshot;
 #if defined(MYSQL_SUPPORTS_BACKUP) && defined(XT_ENABLE_ONLINE_BACKUP)
 		pbxt_hton->get_backup_engine = pbxt_backup_engine;
 #endif
@@ -1175,13 +1196,8 @@
 		 * +1 Temporary thread (e.g. TempForClose, TempForEnd)
 		 */
 #ifndef DRIZZLED
-		if (pbxt_max_threads == 0) {
-			// Embedded server sets max_connections=1
-			if (max_connections > 1)
-				pbxt_max_threads = max_connections + 7;
-			else
-				pbxt_max_threads = 100;
-		}
+		if (pbxt_max_threads == 0)
+			pbxt_max_threads = max_connections + 7;
 #endif
 		self = xt_init_threading(pbxt_max_threads);				/* Create the main self: */
 		if (!self)
@@ -1294,7 +1310,7 @@
 				#6	0x000debe1 in THD::THD at sql_class.cc:631
 				#7	0x00e207a4 in myxt_create_thread at myxt_xt.cc:2666
 				#8	0x00e3134b in tabc_fr_run_thread at tabcache_xt.cc:982
-				#9	0x00e422ca in thr_main_pbxt at thread_xt.cc:1006
+				#9	0x00e422ca in xt_thread_main at thread_xt.cc:1006
 				#10	0x91ff7c55 in _pthread_start
 				#11	0x91ff7b12 in thread_start
 			 *
@@ -1427,8 +1443,43 @@
  * 
  * 3. If in BEGIN/END we must call ha_rollback() if we abort the transaction
  *    internally.
+ *
+ * NOTE ON CONSISTENT SNAPSHOTS:
+ * 
+ * PBXT itself doesn't need this functiona as its transaction mechanism provides
+ * consistent snapshots for all transactions by default. This function is needed
+ * only for multi-engine cases like this:
+ *
+ * CREATE TABLE t1 ... ENGINE=INNODB
+ * CREATE TABLE t2 ... ENGINE=PBXT
+ * START TRANSACTION WITH CONSISTENT SNAPSHOT
+ * SELECT * FROM t1 <-- at this point we need to know about the snapshot
  */
 
+static int pbxt_start_consistent_snapshot(handlerton *hton, THD *thd)
+{
+	int err          = 0;
+	XTThreadPtr self = ha_set_current_thread(thd, &err);
+
+	if (!self->st_database && pbxt_database) {
+		xt_ha_open_database_of_table(self, (XTPathStrPtr) NULL);
+	}
+
+	thd_init_xact(thd, self, true);
+
+	if (xt_xn_begin(self)) {
+		trans_register_ha(thd, TRUE, hton);	
+	} else {
+		err = xt_ha_pbxt_thread_error_for_mysql(thd, self, FALSE);
+	}
+
+	/*
+	 * As of MySQL 5.1.41 the return value is not checked, so the server might assume 
+	 * everything is fine even it isn't. InnoDB returns 0 on success.
+	 */
+	return err;
+}
+
 /*
  * Commit the PBXT transaction of the given thread.
  * thd is the MySQL thread structure.
@@ -1557,7 +1608,7 @@
 	return err;
 }
 
-static XTThreadPtr ha_temp_open_global_database(handlerton *hton, THD **ret_thd, int *temp_thread, const char *thread_name, int *err)
+static XTThreadPtr ha_temp_open_global_database(handlerton *hton, THD **ret_thd, int *temp_thread, char *thread_name, int *err)
 {
 	THD			*thd;
 	XTThreadPtr	self = NULL;
@@ -1870,7 +1921,6 @@
 	THD				*thd = current_thd;
 	int				err = 0;
 	XTThreadPtr		self;	
-	xtBool			tabled_opened = FALSE;
 
 	if (!(self = ha_set_current_thread(thd, &err)))
 		return xt_ha_pbxt_to_mysql_error(err);
@@ -1878,24 +1928,30 @@
 	try_(a) {
 		xt_ha_open_database_of_table(self, pb_share->sh_table_path);
 
-		ha_open_share(self, pb_share, &tabled_opened);
+		ha_open_share(self, pb_share);
 
 		if (!(pb_open_tab = xt_db_open_table_using_tab(pb_share->sh_table, self)))
 			xt_throw(self);
 		pb_open_tab->ot_thread = self;
 
-		if (tabled_opened) {
+		/* {TABLE-STATS}
+		 * We no longer use the information that a table
+		 * was opened in order to know when to calculate
+		 * statistics.
+		 */
+		if (!pb_open_tab->ot_table->tab_ind_stat_calc_time) {
 #ifdef LOAD_TABLE_ON_OPEN
 			xt_tab_load_table(self, pb_open_tab);
 #else
 			xt_tab_load_row_pointers(self, pb_open_tab);
 #endif
-			xt_ind_set_index_selectivity(self, pb_open_tab);
+			xt_ind_set_index_selectivity(pb_open_tab, self);
 			/* If the number of rows is less than 150 we will recalculate the
 			 * selectity of the indices, as soon as the number of rows
 			 * exceeds 200 (see [**])
 			 */
-			pb_share->sh_recalc_selectivity = (pb_share->sh_table->tab_row_eof_id - 1 - pb_share->sh_table->tab_row_fnum) < 150;
+			/* {FREE-ROWS-BAD} */
+			pb_share->sh_recalc_selectivity = (pb_share->sh_table->tab_row_eof_id - 1 /* - pb_share->sh_table->tab_row_fnum */) < 150;
 		}
 
 		/* I am not doing this anymore because it was only required
@@ -2269,7 +2325,6 @@
 	THD			*thd = current_thd;
 	int			err = 0;
 	XTThreadPtr	self;
-	xtBool		tabled_opened = FALSE;
 
 	ref_length = XT_RECORD_OFFS_SIZE;
 
@@ -2282,28 +2337,30 @@
 	try_(a) {
 		xt_ha_open_database_of_table(self, (XTPathStrPtr) table_path);
 
-		pb_share = ha_get_share(self, table_path, true, &tabled_opened);
+		pb_share = ha_get_share(self, table_path, false);
 		ha_add_to_handler_list(self, pb_share, this);
 		if (pb_share->sh_table_lock) {
 			if (!ha_wait_for_shared_use(this, pb_share))
 				xt_throw(self);
 		}
 
-		ha_open_share(self, pb_share, &tabled_opened);
+		ha_open_share(self, pb_share);
 
 		thr_lock_data_init(&pb_share->sh_lock, &pb_lock, NULL);
 		if (!(pb_open_tab = xt_db_open_table_using_tab(pb_share->sh_table, self)))
 			xt_throw(self);
 		pb_open_tab->ot_thread = self;
 
-		if (tabled_opened) {
+		/* {TABLE-STATS} */
+		if (!pb_open_tab->ot_table->tab_ind_stat_calc_time) {
 #ifdef LOAD_TABLE_ON_OPEN
 			xt_tab_load_table(self, pb_open_tab);
 #else
 			xt_tab_load_row_pointers(self, pb_open_tab);
 #endif
-			xt_ind_set_index_selectivity(self, pb_open_tab);
-			pb_share->sh_recalc_selectivity = (pb_share->sh_table->tab_row_eof_id - 1 - pb_share->sh_table->tab_row_fnum) < 150;
+			xt_ind_set_index_selectivity(pb_open_tab, self);
+			/* {FREE-ROWS-BAD} */
+			pb_share->sh_recalc_selectivity = (pb_share->sh_table->tab_row_eof_id - 1 /* - pb_share->sh_table->tab_row_fnum */) < 150;
 		}
 
 		init_auto_increment(0);
@@ -2411,7 +2468,7 @@
 			self->st_abort_trans = FALSE;
 			self->st_stat_ended = FALSE;
 			self->st_stat_trans = FALSE;
-			self->st_is_update = FALSE;
+			self->st_is_update = NULL;
 			if (!xt_xn_begin(self)) {
 				xt_spinlock_unlock(&tab->tab_ainc_lock);
 				xt_throw(self);
@@ -2651,8 +2708,14 @@
 		 * and if it gets dup-key error it tries UPDATE, so the same row can be overwriten multiple 
 		 * times within the same statement
 		 */
-		if (err == HA_ERR_FOUND_DUPP_KEY && pb_open_tab->ot_thread->st_is_update)
-			pb_open_tab->ot_thread->st_update_id++;
+		if (err == HA_ERR_FOUND_DUPP_KEY && pb_open_tab->ot_thread->st_is_update) {
+			/* Pop the update stack: */
+			//pb_open_tab->ot_thread->st_update_id++;
+			XTOpenTablePtr curr = pb_open_tab->ot_thread->st_is_update;
+
+			pb_open_tab->ot_thread->st_is_update = curr->ot_prev_update;
+			curr->ot_prev_update = NULL;
+		}
 	}
 
 	done:
@@ -2720,9 +2783,12 @@
 
 	xt_xlog_check_long_writer(self);
 
-	if (!self->st_is_update) {
-		self->st_is_update = TRUE;
-		self->st_update_id++;
+	/* {UPDATE-STACK} */
+	if (self->st_is_update != pb_open_tab) {
+		/* Push the update stack: */
+		pb_open_tab->ot_prev_update = self->st_is_update;
+		self->st_is_update = pb_open_tab;
+		pb_open_tab->ot_update_id++;
 	}
 
 	if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
@@ -3120,6 +3186,7 @@
 	active_index = idx;
 
 	if (pb_open_tab->ot_table->tab_dic.dic_disable_index) {
+		active_index = MAX_KEY;
 		xt_tab_set_index_error(pb_open_tab->ot_table);
 		return ha_log_pbxt_thread_error_for_mysql(pb_ignore_dup_key);
 	}
@@ -3270,6 +3337,10 @@
 	int					prefix = 0;
 	XTIdxSearchKeyRec	search_key;
 
+	if (idx == MAX_KEY) {
+		err = HA_ERR_WRONG_INDEX;
+		goto done;
+	}
 #ifdef XT_TRACK_RETURNED_ROWS
 	ha_start_scan(pb_open_tab, idx);
 #endif
@@ -3320,6 +3391,7 @@
 		ha_return_row(pb_open_tab, idx);
 #endif
 	XT_DISABLED_TRACE(("search tx=%d val=%d err=%d\n", (int) pb_open_tab->ot_thread->st_xact_data->xd_start_xn_id, (int) XT_GET_DISK_4(key), err));
+	done:
 	if (err)
 		table->status = STATUS_NOT_FOUND;
 	else {
@@ -3364,6 +3436,10 @@
 	//statistic_increment(ha_read_next_count,&LOCK_status);
 	ASSERT_NS(pb_ex_in_use);
 
+	if (active_index == MAX_KEY) {
+		err = HA_ERR_WRONG_INDEX;
+		goto done;
+	}
 	ind = (XTIndexPtr) pb_share->sh_dic_keys[active_index];
 
 	if (!xt_idx_next(pb_open_tab, ind, NULL))
@@ -3376,6 +3452,7 @@
 	if (!err)
 		ha_return_row(pb_open_tab, active_index);
 #endif
+	done:
 	if (err)
 		table->status = STATUS_NOT_FOUND;
 	else {
@@ -3406,6 +3483,10 @@
 	//statistic_increment(ha_read_next_count,&LOCK_status);
 	ASSERT_NS(pb_ex_in_use);
 
+	if (active_index == MAX_KEY) {
+		err = HA_ERR_WRONG_INDEX;
+		goto done;
+	}
 	ind = (XTIndexPtr) pb_share->sh_dic_keys[active_index];
 
 	search_key.sk_key_value.sv_flags = HA_READ_KEY_EXACT;
@@ -3425,6 +3506,7 @@
 	if (!err)
 		ha_return_row(pb_open_tab, active_index);
 #endif
+	done:
 	if (err)
 		table->status = STATUS_NOT_FOUND;
 	else {
@@ -3446,6 +3528,10 @@
 	//statistic_increment(ha_read_prev_count,&LOCK_status);
 	ASSERT_NS(pb_ex_in_use);
 
+	if (active_index == MAX_KEY) {
+		err = HA_ERR_WRONG_INDEX;
+		goto done;
+	}
 	ind = (XTIndexPtr) pb_share->sh_dic_keys[active_index];
 
 	if (!xt_idx_prev(pb_open_tab, ind, NULL))
@@ -3458,6 +3544,7 @@
 	if (!err)
 		ha_return_row(pb_open_tab, active_index);
 #endif
+	done:
 	if (err)
 		table->status = STATUS_NOT_FOUND;
 	else {
@@ -3480,6 +3567,18 @@
 	//statistic_increment(ha_read_first_count,&LOCK_status);
 	ASSERT_NS(pb_ex_in_use);
 
+	/* This is required because MySQL ignores the error returned
+	 * init init_index sometimes, for example:
+	 *
+     * if (!table->file->inited)
+     *    table->file->ha_index_init(tab->index, tab->sorted);
+     *  if ((error=tab->table->file->index_first(tab->table->record[0])))
+	 */
+	if (active_index == MAX_KEY) {
+		err = HA_ERR_WRONG_INDEX;
+		goto done;
+	}
+
 #ifdef XT_TRACK_RETURNED_ROWS
 	ha_start_scan(pb_open_tab, active_index);
 #endif
@@ -3498,6 +3597,7 @@
 	if (!err)
 		ha_return_row(pb_open_tab, active_index);
 #endif
+	done:
 	if (err)
 		table->status = STATUS_NOT_FOUND;
 	else {
@@ -3520,6 +3620,11 @@
 	//statistic_increment(ha_read_last_count,&LOCK_status);
 	ASSERT_NS(pb_ex_in_use);
 
+	if (active_index == MAX_KEY) {
+		err = HA_ERR_WRONG_INDEX;
+		goto done;
+	}
+
 #ifdef XT_TRACK_RETURNED_ROWS
 	ha_start_scan(pb_open_tab, active_index);
 #endif
@@ -3538,6 +3643,7 @@
 	if (!err)
 		ha_return_row(pb_open_tab, active_index);
 #endif
+	done:
 	if (err)
 		table->status = STATUS_NOT_FOUND;
 	else {
@@ -3825,8 +3931,34 @@
 
 	if ((ot = pb_open_tab)) {
 		if (flag & HA_STATUS_VARIABLE) {
-			stats.deleted = ot->ot_table->tab_row_fnum;
-			stats.records = (ha_rows) (ot->ot_table->tab_row_eof_id - 1 - stats.deleted);
+			/* {FREE-ROWS-BAD}
+			 * Free row count is not reliable, so ignore it.
+			 * The problem is if tab_row_fnum > tab_row_eof_id - 1 then
+			 * we have a very bad result.
+			 *
+			 * If stats.records+EXTRA_RECORDS == 0 as returned by 
+			 * estimate_rows_upper_bound(), then filesort will crash here:
+			 *
+			 * make_sortkey(param,sort_keys[idx++],ref_pos);
+			 * 
+			 * #0	0x000bf69c in Field_long::sort_string at field.cc:3766
+			 * #1	0x0022e1f1 in make_sortkey at filesort.cc:769
+			 * #2	0x0022f1cf in find_all_keys at filesort.cc:619
+			 * #3	0x00230eec in filesort at filesort.cc:243
+			 * #4	0x001b9d89 in mysql_update at sql_update.cc:415
+			 * #5	0x0010db12 in mysql_execute_command at sql_parse.cc:2959
+			 * #6	0x0011480d in mysql_parse at sql_parse.cc:5787
+			 * #7	0x00115afb in dispatch_command at sql_parse.cc:1200
+			 * #8	0x00116de2 in do_command at sql_parse.cc:857
+			 * #9	0x00101ee4 in handle_one_connection at sql_connect.cc:1115
+			 *
+			 * The problem is that sort_keys is allocated to handle just 1 vector.
+			 * Sorting one vector crashes. Although I could not find a check for
+			 * the actual number of vectors. But it must assume that it has at
+			 * least EXTRA_RECORDS vectors.
+			 */
+			stats.deleted = /* ot->ot_table->tab_row_fnum */ 0;
+			stats.records = (ha_rows) (ot->ot_table->tab_row_eof_id - 1 /* - stats.deleted */);
 			stats.data_file_length = xt_rec_id_to_rec_offset(ot->ot_table, ot->ot_table->tab_rec_eof_id);
 			stats.index_file_length = xt_ind_node_to_offset(ot->ot_table, ot->ot_table->tab_ind_eof);
 			stats.delete_length = ot->ot_table->tab_rec_fnum * ot->ot_rec_size;
@@ -4454,11 +4586,13 @@
 				}
 
 				if (pb_share->sh_recalc_selectivity) {
-					if ((pb_share->sh_table->tab_row_eof_id - 1 - pb_share->sh_table->tab_row_fnum) >= 200) {
+					/* {FREE-ROWS-BAD} */
+					if ((pb_share->sh_table->tab_row_eof_id - 1 /* - pb_share->sh_table->tab_row_fnum */) >= 200) {
 						/* [**] */
 						pb_share->sh_recalc_selectivity = FALSE;
-						xt_ind_set_index_selectivity(self, pb_open_tab);
-						pb_share->sh_recalc_selectivity = (pb_share->sh_table->tab_row_eof_id - 1 - pb_share->sh_table->tab_row_fnum) < 150;
+						xt_ind_set_index_selectivity(pb_open_tab, self);
+						/* {FREE-ROWS-BAD} */
+						pb_share->sh_recalc_selectivity = (pb_share->sh_table->tab_row_eof_id - 1 /* - pb_share->sh_table->tab_row_fnum */) < 150;
 					}
 				}
 			}
@@ -4497,7 +4631,7 @@
 				if (!pb_share->sh_table) {
 					xt_ha_open_database_of_table(self, pb_share->sh_table_path);
 
-					ha_open_share(self, pb_share, NULL);
+					ha_open_share(self, pb_share);
 				}
 			}
 			catch_(a) {
@@ -4603,8 +4737,8 @@
 			cont_(b);
 		}
 
-		/* See {IS-UPDATE-STAT} */
-		self->st_is_update = FALSE;
+		/* See {IS-UPDATE-STAT} nad {UPDATE-STACK} */
+		self->st_is_update = NULL;
 
 		/* Auto begin a transaction (if one is not already running): */
 		if (!self->st_xact_data) {
@@ -4612,19 +4746,8 @@
 			(void) ASSERT_NS(ISO_READ_UNCOMMITTED == XT_XACT_UNCOMMITTED_READ);
 			(void) ASSERT_NS(ISO_SERIALIZABLE == XT_XACT_SERIALIZABLE);
 
-			self->st_xact_mode = thd_tx_isolation(thd) <= ISO_READ_COMMITTED ? XT_XACT_COMMITTED_READ : XT_XACT_REPEATABLE_READ;
-			self->st_ignore_fkeys = (thd_test_options(thd,OPTION_NO_FOREIGN_KEY_CHECKS)) != 0;
-			self->st_auto_commit = (thd_test_options(thd, (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) == 0;
-#ifdef DRIZZLED
-			self->st_table_trans = FALSE;
-#else
-			self->st_table_trans = thd_sql_command(thd) == SQLCOM_LOCK_TABLES;
-#endif
-			self->st_abort_trans = FALSE;
-			self->st_stat_ended = FALSE;
-			self->st_stat_trans = FALSE;
-			XT_PRINT0(self, "xt_xn_begin\n");
-			xt_xres_wait_for_recovery(self, XT_RECOVER_SWEPT);
+			thd_init_xact(thd, self, true);
+
 			if (!xt_xn_begin(self)) {
 				err = xt_ha_pbxt_thread_error_for_mysql(thd, self, pb_ignore_dup_key);
 				pb_ex_in_use = 0;
@@ -4847,19 +4970,27 @@
 	 * are nested within an open close of the select t1
 	 * statement.
 	 */
-	self->st_is_update = FALSE;
+	/* {UPDATE-STACK}
+	 * Add to this I add the following:
+	 * A trigger in the middle of an update also causes nested
+	 * statements. If I reset st_is_update, then then
+	 * when the trigger returns the system thinks we
+	 * are in a different update statement, and may
+	 * update the same row again.
+	 */
+	if (self->st_is_update == pb_open_tab) {
+		/* Pop the update stack: */
+		XTOpenTablePtr curr = pb_open_tab->ot_thread->st_is_update;
+
+		pb_open_tab->ot_thread->st_is_update = curr->ot_prev_update;
+		curr->ot_prev_update = NULL;
+	}
 
 	/* See comment {START-TRANS} */
 	if (!self->st_xact_data) {
-		self->st_xact_mode = thd_tx_isolation(thd) <= ISO_READ_COMMITTED ? XT_XACT_COMMITTED_READ : XT_XACT_REPEATABLE_READ;
-		self->st_ignore_fkeys = (thd_test_options(thd, OPTION_NO_FOREIGN_KEY_CHECKS)) != 0;
-		self->st_auto_commit = (thd_test_options(thd,(OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) == 0;
-		/* self->st_table_trans = not set here! */
-		self->st_abort_trans = FALSE;
-		self->st_stat_ended = FALSE;
-		self->st_stat_trans = FALSE;
-		XT_PRINT0(self, "xt_xn_begin\n");
-		xt_xres_wait_for_recovery(self, XT_RECOVER_SWEPT);
+
+		thd_init_xact(thd, self, false);
+
 		if (!xt_xn_begin(self)) {
 			err = xt_ha_pbxt_thread_error_for_mysql(thd, self, pb_ignore_dup_key);
 			goto complete;
@@ -4915,6 +5046,18 @@
  */
 THR_LOCK_DATA **ha_pbxt::store_lock(THD *thd, THR_LOCK_DATA **to, enum thr_lock_type lock_type)
 {
+	/*
+	 * TL_READ means concurrent INSERTs are allowed. This is a problem as in this mode
+	 * PBXT is not compatible with MyISAM which allows INSERTs but isolates them from
+	 * current "transaction" (started by LOCK TABLES, ended by UNLOCK TABLES). PBXT 
+	 * used to allow INSERTs and made them visible to the locker (on commit). 
+	 * While MySQL manual doesn't state anything regarding row visibility limitations 
+	 * we choose to convert local locks into normal read locks for better compatibility 
+	 * with MyISAM.
+	 */
+	if (lock_type == TL_READ)
+		lock_type = TL_READ_NO_INSERT;
+
 	if (lock_type != TL_IGNORE && pb_lock.type == TL_UNLOCK) {
 		/* Set to TRUE for operations that require a table lock: */
 		switch (thd_sql_command(thd)) {
@@ -5112,7 +5255,7 @@
 			 * We also cannot use pb_share because the handler used
 			 * to delete a table is not openned correctly.
 			 */
-			share = ha_get_share(self, table_path, false, NULL);
+			share = ha_get_share(self, table_path, false);
 			pushr_(ha_unget_share, share);
 			ha_aquire_exclusive_use(self, share, NULL);
 			pushr_(ha_release_exclusive_use, share);
@@ -5271,7 +5414,7 @@
 		 * called without correctly initializing
 		 * the handler!
 		 */
-		share = ha_get_share(self, from, true, NULL);
+		share = ha_get_share(self, from, true);
 		pushr_(ha_unget_share, share);
 		ha_aquire_exclusive_use(self, share, NULL);
 		pushr_(ha_release_exclusive_use, share);
@@ -5852,6 +5995,11 @@
 	NULL, NULL, FALSE);
 #endif
 
+static MYSQL_SYSVAR_INT(flush_log_at_trx_commit, xt_db_flush_log_at_trx_commit,
+	PLUGIN_VAR_OPCMDARG,
+	"Determines whether the transaction log is written and/or flushed when a transaction is committed (no matter what the setting the log is written and flushed once per second), 0 = no write & no flush, 1 = write & flush (default), 2 = write & no flush.",
+	NULL, NULL, 1, 0, 2, 1);
+
 static struct st_mysql_sys_var* pbxt_system_variables[] = {
   MYSQL_SYSVAR(index_cache_size),
   MYSQL_SYSVAR(record_cache_size),
@@ -5870,6 +6018,7 @@
   MYSQL_SYSVAR(sweeper_priority),
   MYSQL_SYSVAR(max_threads),
   MYSQL_SYSVAR(support_xa),
+  MYSQL_SYSVAR(flush_log_at_trx_commit),
   NULL
 };
 #endif

=== modified file 'storage/pbxt/src/index_xt.cc'
--- storage/pbxt/src/index_xt.cc	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/index_xt.cc	2010-05-07 08:52:27 +0000
@@ -1328,10 +1328,12 @@
 	XT_SET_DISK_2(leaf->tb_size_2, XT_MAKE_NODE_SIZE(result->sr_item.i_total_size));
 }
 
-static void idx_get_middle_branch_item(XTIndexPtr ind, XTIdxBranchDPtr branch, XTIdxKeyValuePtr value, XTIdxResultPtr result)
+static xtBool idx_get_middle_branch_item(XTOpenTablePtr ot, XTIndexPtr ind, XTIdxBranchDPtr branch, XTIdxKeyValuePtr value, XTIdxResultPtr result)
 {
 	xtWord1	*bitem;
 
+	ASSERT_NS(result->sr_item.i_node_ref_size == 0 || result->sr_item.i_node_ref_size == XT_NODE_REF_SIZE);
+	ASSERT_NS((int) result->sr_item.i_total_size >= 0 && result->sr_item.i_total_size <= XT_INDEX_PAGE_SIZE*2);
 	if (ind->mi_fix_key) {
 		u_int full_item_size = result->sr_item.i_item_size + result->sr_item.i_node_ref_size;
 
@@ -1346,18 +1348,25 @@
 	}
 	else {
 		u_int	node_ref_size;
-		u_int	ilen;
+		u_int	ilen, tlen;
 		xtWord1	*bend;
 
 		node_ref_size = result->sr_item.i_node_ref_size;
-		bitem = branch->tb_data + node_ref_size;;
+		bitem = branch->tb_data + node_ref_size;
 		bend = &branch->tb_data[(result->sr_item.i_total_size - node_ref_size) / 2 + node_ref_size];
 		ilen = 0;
 		if (bitem < bend) {
+			tlen = 0;
 			for (;;) {
 				ilen = myxt_get_key_length(ind, bitem);
-				if (bitem + ilen + XT_RECORD_REF_SIZE + node_ref_size >= bend)
+				tlen += ilen + XT_RECORD_REF_SIZE + node_ref_size;
+				if (bitem + ilen + XT_RECORD_REF_SIZE + node_ref_size >= bend) {
+					if (ilen > XT_INDEX_PAGE_SIZE || tlen > result->sr_item.i_total_size) {
+						xt_register_taberr(XT_REG_CONTEXT, XT_ERR_INDEX_CORRUPTED, ot->ot_table->tab_name);
+						return FAILED;
+					}
 					break;
+				}
 				bitem += ilen + XT_RECORD_REF_SIZE + node_ref_size;
 			}
 		}
@@ -1370,6 +1379,7 @@
 		xt_get_record_ref(bitem + ilen, &value->sv_rec_id, &value->sv_row_id);
 		memcpy(value->sv_key, bitem, value->sv_length);
 	}
+	return OK;
 }
 
 static size_t idx_write_branch_item(XTIndexPtr XT_UNUSED(ind), xtWord1 *item, XTIdxKeyValuePtr value)
@@ -1438,7 +1448,8 @@
 	/* We assume that value can be overwritten (which is the case) */
 	key_value.sv_flags = XT_SEARCH_WHOLE_KEY;
 	key_value.sv_key = key_buf;
-	idx_get_middle_branch_item(ind, iref.ir_branch, &key_value, &result);
+	if (!idx_get_middle_branch_item(ot, ind, iref.ir_branch, &key_value, &result))
+		goto failed_1;
 
 	if (!idx_new_branch(ot, ind, &new_branch))
 		goto failed_1;
@@ -1567,7 +1578,8 @@
 	ASSERT_NS(result.sr_item.i_total_size > XT_INDEX_PAGE_DATA_SIZE);
 
 	/* We assume that value can be overwritten (which is the case) */
-	idx_get_middle_branch_item(ind, &ot->ot_ind_wbuf, key_value, &result);
+	if (!idx_get_middle_branch_item(ot, ind, &ot->ot_ind_wbuf, key_value, &result))
+		goto failed_1;
 
 	if (!idx_new_branch(ot, ind, &new_branch))
 		goto failed_1;
@@ -2041,7 +2053,7 @@
 	memcpy(&ot->ot_ind_wbuf, iref.ir_branch, offsetof(XTIdxBranchDRec, tb_data) + result.sr_item.i_total_size);
 	idx_insert_leaf_item(ind, &ot->ot_ind_wbuf, &key_value, &result);
 	IDX_TRACE("%d-> %x\n", (int) XT_NODE_ID(current), (int) XT_GET_DISK_2(ot->ot_ind_wbuf.tb_size_2));
-	ASSERT_NS(result.sr_item.i_total_size > XT_INDEX_PAGE_DATA_SIZE);
+	ASSERT_NS(result.sr_item.i_total_size > XT_INDEX_PAGE_DATA_SIZE && result.sr_item.i_total_size <= XT_INDEX_PAGE_DATA_SIZE*2);
 
 	/* This is the number of potential writes. In other words, the total number
 	 * of blocks that may be accessed.
@@ -2053,7 +2065,8 @@
 		goto failed_1;
 
 	/* Key does not fit, must split... */
-	idx_get_middle_branch_item(ind, &ot->ot_ind_wbuf, &key_value, &result);
+	if (!idx_get_middle_branch_item(ot, ind, &ot->ot_ind_wbuf, &key_value, &result))
+		goto failed_1;
 
 	if (!idx_new_branch(ot, ind, &new_branch))
 		goto failed_1;
@@ -3317,7 +3330,7 @@
 	return FALSE;
 }
 
-static void idx_set_index_selectivity(XTThreadPtr self, XTOpenTablePtr ot, XTIndexPtr ind)
+static void idx_set_index_selectivity(XTOpenTablePtr ot, XTIndexPtr ind, XTThreadPtr thread)
 {
 	static const xtRecordID MAX_RECORDS = 100;
 
@@ -3368,7 +3381,7 @@
 				last_rec = ot->ot_curr_rec_id;
 
 				key_len = ot->ot_ind_state.i_item_size - XT_RECORD_REF_SIZE;
-				xt_ind_unlock_handle(ot->ot_ind_rhandle);
+				xt_ind_lock_handle(ot->ot_ind_rhandle);
 				memcpy(key_buf, ot->ot_ind_rhandle->ih_branch->tb_data + ot->ot_ind_state.i_item_offset, key_len);
 				xt_ind_unlock_handle(ot->ot_ind_rhandle);
 			}
@@ -3410,7 +3423,7 @@
 		last_iter_rec = last_rec;
 
 		if (ot->ot_ind_rhandle) {
-			xt_ind_release_handle(ot->ot_ind_rhandle, FALSE, self);
+			xt_ind_release_handle(ot->ot_ind_rhandle, FALSE, thread);
 			ot->ot_ind_rhandle = NULL;
 		}
 	}
@@ -3431,8 +3444,10 @@
 	return;
 
 	failed_1:
-	xt_ind_release_handle(ot->ot_ind_rhandle, FALSE, self);
-	ot->ot_ind_rhandle = NULL;
+	if (ot->ot_ind_rhandle) {
+		xt_ind_release_handle(ot->ot_ind_rhandle, FALSE, thread);
+		ot->ot_ind_rhandle = NULL;
+	}
 
 	failed:
 	xt_tab_disable_index(ot->ot_table, XT_INDEX_CORRUPTED);
@@ -3440,16 +3455,23 @@
 	return;
 }
 
-xtPublic void xt_ind_set_index_selectivity(XTThreadPtr self, XTOpenTablePtr ot)
+xtPublic void xt_ind_set_index_selectivity(XTOpenTablePtr ot, XTThreadPtr thread)
 {
 	XTTableHPtr		tab = ot->ot_table;
 	XTIndexPtr		*ind;
 	u_int			i;
+	time_t			now;
 
-	if (!tab->tab_dic.dic_disable_index) {
-		for (i=0, ind=tab->tab_dic.dic_keys; i<tab->tab_dic.dic_key_count; i++, ind++)
-			idx_set_index_selectivity(self, ot, *ind);
+	now = time(NULL);
+	xt_lock_mutex_ns(&tab->tab_ind_stat_lock);
+	if (tab->tab_ind_stat_calc_time < now) {
+		if (!tab->tab_dic.dic_disable_index) {
+			for (i=0, ind=tab->tab_dic.dic_keys; i<tab->tab_dic.dic_key_count; i++, ind++)
+				idx_set_index_selectivity(ot, *ind, thread);
+		}
+		tab->tab_ind_stat_calc_time = time(NULL);
 	}
+	xt_unlock_mutex_ns(&tab->tab_ind_stat_lock);
 }
 
 /*
@@ -3740,7 +3762,8 @@
 static xtBool idx_flush_dirty_list(XTIndexLogPtr il, XTOpenTablePtr ot, u_int *flush_count, XTIndBlockPtr *flush_list)
 {
 	for (u_int i=0; i<*flush_count; i++)
-		il->il_write_block(ot, flush_list[i]);
+		if (!il->il_write_block(ot, flush_list[i]))
+			return FAILED;
 	*flush_count = 0;
 	return OK;
 }
@@ -3793,7 +3816,7 @@
 	xtIndexNodeID			ind_free;
 	xtBool					something_to_free = FALSE;
 	xtIndexNodeID			last_address, next_address;
-	xtWord2					curr_flush_seq;
+	xtWord4					curr_flush_seq;
 	XTIndFreeListPtr		list_ptr;
 	u_int					dirty_blocks;
 	XTCheckPointTablePtr	cp_tab;
@@ -3810,8 +3833,9 @@
 	if (!tab->tab_db->db_indlogs.ilp_get_log(&il, ot->ot_thread))
 		goto failed_3;
 
-	il->il_reset(tab->tab_id);
-	if (!il->il_write_byte(ot, XT_DT_FREE_LIST))
+	if (!il->il_reset(ot))
+		goto failed_2;
+	if (!il->il_write_byte(ot, XT_DT_LOG_HEAD))
 		goto failed_2;
 	if (!il->il_write_word4(ot, tab->tab_id))
 		goto failed_2;
@@ -3849,7 +3873,7 @@
 			wrote_something = TRUE;
 			while (block) {
 				ASSERT_NS(block->cb_state == IDX_CAC_BLOCK_DIRTY);
-				ASSERT_NS(block->cp_flush_seq == curr_flush_seq);
+				ASSERT_NS((block->cp_flush_seq == curr_flush_seq) || xt_xn_is_before(block->cp_flush_seq, curr_flush_seq));
 				if (!ind_add_to_dirty_list(il, ot, &flush_count, flush_list, block))
 					goto failed;
 				block = block->cb_dirty_next;
@@ -4023,7 +4047,7 @@
 					fblock = block;
 					block = block->cb_dirty_next;
 					ASSERT_NS(fblock->cb_state == IDX_CAC_BLOCK_DIRTY);
-					if (fblock->cp_flush_seq == curr_flush_seq) {
+					if (fblock->cp_flush_seq == curr_flush_seq || xt_xn_is_before(fblock->cp_flush_seq, curr_flush_seq)) {
 						/* Take the block off the dirty list: */
 						if (fblock->cb_dirty_next)
 							fblock->cb_dirty_next->cb_dirty_prev = fblock->cb_dirty_prev;
@@ -4254,12 +4278,32 @@
 	xt_unlock_mutex_ns(&ilp_lock);
 }
 
-void XTIndexLog::il_reset(xtTableID tab_id)
+xtBool XTIndexLog::il_reset(XTOpenTable *ot)
 {
+	XTIndLogHeadDRec	log_head;
+	xtTableID			tab_id = ot->ot_table->tab_id;
+
 	il_tab_id = tab_id;
 	il_log_eof = 0;
 	il_buffer_len = 0;
 	il_buffer_offset = 0;
+
+	/* We must write the header and flush here or the "previous" status (from the
+	 * last flush run) could remain. Failure to write the file completely leave the
+	 * old header in place, and other parts of the file changed.
+	 * This would lead to index corruption.  
+	 */
+	log_head.ilh_data_type = XT_DT_LOG_HEAD;
+	XT_SET_DISK_4(log_head.ilh_tab_id_4, tab_id);
+	XT_SET_DISK_4(log_head.ilh_log_eof_4, 0);
+
+	if (!xt_pwrite_file(il_of, 0, sizeof(XTIndLogHeadDRec), (xtWord1 *) &log_head, &ot->ot_thread->st_statistics.st_ilog, ot->ot_thread))
+		return FAILED;
+
+	if (!xt_flush_file(il_of, &ot->ot_thread->st_statistics.st_ilog, ot->ot_thread))
+		return FAILED;
+
+	return OK;
 }
 
 void XTIndexLog::il_close(xtBool delete_it)

=== modified file 'storage/pbxt/src/index_xt.h'
--- storage/pbxt/src/index_xt.h	2009-08-17 11:12:36 +0000
+++ storage/pbxt/src/index_xt.h	2010-05-07 08:52:27 +0000
@@ -30,6 +30,7 @@
 #include <mysql_version.h>
 #include <my_bitmap.h>
 #endif
+#include <time.h>
 
 #include "thread_xt.h"
 #include "linklist_xt.h"
@@ -293,7 +294,6 @@
  */
 typedef struct XTIndex {
 	u_int				mi_index_no;				/* The index number (used by MySQL). */
-	xt_mutex_type		mi_flush_lock;				/* Lock the index during flushing. */
 
 	/* Protected by the mi_rwlock lock: */
 	XT_INDEX_LOCK_TYPE	mi_rwlock;					/* This lock protects the structure of the index.
@@ -407,7 +407,7 @@
 	off_t					il_buffer_offset;
 
 
-	void					il_reset(xtTableID tab_id);
+	xtBool					il_reset(XTOpenTable *ot);
 	void					il_close(xtBool delete_it);
 	void					il_release();
 
@@ -478,7 +478,7 @@
 xtBool	xt_idx_next(register struct XTOpenTable *ot, register struct XTIndex *ind, register XTIdxSearchKeyPtr search_key);
 xtBool	xt_idx_prev(register struct XTOpenTable *ot, register struct XTIndex *ind, register XTIdxSearchKeyPtr search_key);
 xtBool	xt_idx_read(struct XTOpenTable *ot, struct XTIndex *ind, xtWord1 *rec_buf);
-void	xt_ind_set_index_selectivity(XTThreadPtr self, struct XTOpenTable *ot);
+void	xt_ind_set_index_selectivity(struct XTOpenTable *ot, XTThreadPtr thread);
 void	xt_check_indices(struct XTOpenTable *ot);
 void	xt_load_indices(XTThreadPtr self, struct XTOpenTable *ot);
 void	xt_ind_count_deleted_items(struct XTTable *ot, struct XTIndex *ind, struct XTIndBlock *block);

=== modified file 'storage/pbxt/src/lock_xt.cc'
--- storage/pbxt/src/lock_xt.cc	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/lock_xt.cc	2010-05-07 08:52:27 +0000
@@ -1444,7 +1444,7 @@
 #endif
 }
 
-xtPublic xtBool xt_spinxslock_xlock(XTSpinXSLockPtr sxs, xtThreadID XT_NDEBUG_UNUSED(thd_id))
+xtPublic xtBool xt_spinxslock_xlock(XTSpinXSLockPtr sxs, xtBool try_lock, xtThreadID XT_NDEBUG_UNUSED(thd_id))
 {
 	register xtWord2 set;
 
@@ -1453,6 +1453,8 @@
 		set = xt_atomic_tas2(&sxs->sxs_xlocked, 1);
 		if (!set)
 			break;
+		if (try_lock)
+			return FALSE;
 		xt_yield();
 	}
 
@@ -1460,9 +1462,25 @@
 	sxs->sxs_locker = thd_id;
 #endif
 
-	/* Wait for all the reader to wait! */
-	while (sxs->sxs_wait_count < sxs->sxs_rlock_count)
-		xt_yield();
+	/* Wait for all the readers to wait! */
+	while (sxs->sxs_wait_count < sxs->sxs_rlock_count) {
+		sxs->sxs_xwaiter = 1;
+		xt_yield(); //*
+		/* This should not be required, because there is only one thread
+		 * accessing this value. However, the lock fails if this
+		 * is not done with an atomic op.
+		 *
+		 * This is because threads on other processors have the
+		 * value in processor cache. So they do not
+		 * notice that the value has been set to zero.
+		 * They think it is still 1 and march through
+		 * the barrier (sxs->sxs_xwaiter < sxs->sxs_xlocked) below.
+		 *
+		 * In the meantime, this X locker has gone on thinking
+		 * all is OK.
+		 */
+		xt_atomic_tas2(&sxs->sxs_xwaiter, 0);
+	}
 
 #ifdef XT_THREAD_LOCK_INFO
 	xt_thread_lock_info_add_owner(&sxs->sxs_lock_info);
@@ -1474,12 +1492,12 @@
 {
 	xt_atomic_inc2(&sxs->sxs_rlock_count);
 
-	/* Check if there could be an X locker: */
-	if (sxs->sxs_xlocked) {
-		/* I am waiting... */
+	/* Wait as long as the locker is not waiting: */
+	while (sxs->sxs_xwaiter < sxs->sxs_xlocked) {
 		xt_atomic_inc2(&sxs->sxs_wait_count);
-		while (sxs->sxs_xlocked)
+		while (sxs->sxs_xwaiter < sxs->sxs_xlocked) {
 			xt_yield();
+		}
 		xt_atomic_dec2(&sxs->sxs_wait_count);
 	}
 
@@ -1493,12 +1511,17 @@
 {
 	if (xlocked) {
 #ifdef DEBUG
+		ASSERT_NS(sxs->sxs_locker && sxs->sxs_xlocked);
 		sxs->sxs_locker = 0;
 #endif
 		sxs->sxs_xlocked = 0;
 	}
-	else
+	else {
+#ifdef DEBUG
+		ASSERT_NS(sxs->sxs_rlock_count > 0);
+#endif
 		xt_atomic_dec2(&sxs->sxs_rlock_count);
+	}
 
 #ifdef XT_THREAD_LOCK_INFO
 	xt_thread_lock_info_release_owner(&sxs->sxs_lock_info);
@@ -1698,7 +1721,7 @@
 #endif
 }
 
-xtPublic xtBool xt_atomicrwlock_xlock(XTAtomicRWLockPtr arw, xtThreadID XT_NDEBUG_UNUSED(thr_id))
+xtPublic xtBool xt_atomicrwlock_xlock(XTAtomicRWLockPtr arw, xtBool try_lock, xtThreadID XT_NDEBUG_UNUSED(thr_id))
 {
 	register xtWord2 set;
 
@@ -1707,6 +1730,8 @@
 		set = xt_atomic_tas2(&arw->arw_xlock_set, 1);
 		if (!set)
 			break;
+		if (try_lock)
+			return FALSE;
 		xt_yield();
 	}
 
@@ -1721,7 +1746,7 @@
 #ifdef XT_THREAD_LOCK_INFO
 	xt_thread_lock_info_add_owner(&arw->arw_lock_info);
 #endif
-	return OK;
+	return TRUE;
 }
 
 xtPublic xtBool xt_atomicrwlock_slock(XTAtomicRWLockPtr arw)
@@ -1799,7 +1824,7 @@
 #endif
 }
 
-xtPublic xtBool xt_skewrwlock_xlock(XTSkewRWLockPtr srw, xtThreadID XT_NDEBUG_UNUSED(thr_id))
+xtPublic xtBool xt_skewrwlock_xlock(XTSkewRWLockPtr srw, xtBool try_lock, xtThreadID XT_NDEBUG_UNUSED(thr_id))
 {
 	register xtWord2 set;
 
@@ -1808,6 +1833,8 @@
 		set = xt_atomic_tas2(&srw->srw_xlock_set, 1);
 		if (!set)
 			break;
+		if (try_lock)
+			return FALSE;
 		xt_yield();
 	}
 
@@ -1822,7 +1849,7 @@
 #ifdef XT_THREAD_LOCK_INFO
 	xt_thread_lock_info_add_owner(&srw->srw_lock_info);
 #endif
-	return OK;
+	return TRUE;
 }
 
 xtPublic xtBool xt_skewrwlock_slock(XTSkewRWLockPtr srw)
@@ -1869,6 +1896,124 @@
 
 /*
  * -----------------------------------------------------------------------
+ * RECURSIVE R/W LOCK (allows X lockers to lock again)
+ */
+
+#ifdef XT_THREAD_LOCK_INFO
+void xt_recursivemutex_init(XTThreadPtr self, XTRecursiveMutexPtr rm, const char *name)
+{
+	rm->rm_locker = NULL;
+	rm->rm_lock_count = 0;
+	xt_init_mutex(self, &rm->rm_mutex, name);
+}
+#else
+xtPublic void xt_recursivemutex_init(XTThreadPtr self, XTRecursiveMutexPtr rm)
+{
+	rm->rm_locker = NULL;
+	rm->rm_lock_count = 0;
+	xt_init_mutex(self, &rm->rm_mutex);
+}
+#endif
+
+xtPublic void xt_recursivemutex_free(XTRecursiveMutexPtr rm)
+{
+	xt_free_mutex(&rm->rm_mutex);
+#ifdef XT_THREAD_LOCK_INFO
+	xt_thread_lock_info_free(&rm->rm_lock_info);
+#endif
+}
+
+xtPublic void xt_recursivemutex_lock(XTThreadPtr self, XTRecursiveMutexPtr rm)
+{
+	if (self != rm->rm_locker) {
+		xt_lock_mutex(self, &rm->rm_mutex);
+		rm->rm_locker = self;
+	}
+	rm->rm_lock_count++;
+}
+
+xtPublic void xt_recursivemutex_unlock(XTThreadPtr self, XTRecursiveMutexPtr rm)
+{
+	ASSERT(self == rm->rm_locker);
+	ASSERT(rm->rm_lock_count > 0);
+	rm->rm_lock_count--;
+	if (!rm->rm_lock_count) {
+		rm->rm_locker = NULL;
+		xt_unlock_mutex(self, &rm->rm_mutex);
+	}
+}
+
+/*
+ * -----------------------------------------------------------------------
+ * RECURSIVE MUTEX (allows lockers to lock again)
+ */
+
+#ifdef XT_THREAD_LOCK_INFO
+void xt_recurrwlock_init(struct XTThread *self, XTRecurRWLockPtr rrw, const char *name)
+{
+	rrw->rrw_locker = NULL;
+	rrw->rrw_lock_count = 0;
+	xt_init_rwlock(self, &rrw->rrw_lock, name);
+}
+#else
+void xt_recurrwlock_init(struct XTThread *self, XTRecurRWLockPtr rrw)
+{
+	rrw->rrw_locker = NULL;
+	rrw->rrw_lock_count = 0;
+	xt_init_rwlock(self, &rrw->rrw_lock);
+}
+#endif
+
+void xt_recurrwlock_free(XTRecurRWLockPtr rrw)
+{
+	xt_free_rwlock(&rrw->rrw_lock);
+#ifdef XT_THREAD_LOCK_INFO
+	xt_thread_lock_info_free(&rrw->rrw_lock_info);
+#endif
+}
+
+void xt_recurrwlock_xlock(struct XTThread *self, XTRecurRWLockPtr rrw)
+{
+	if (self != rrw->rrw_locker) {
+		xt_xlock_rwlock(self, &rrw->rrw_lock);
+		rrw->rrw_locker = self;
+	}
+	rrw->rrw_lock_count++;
+}
+
+void xt_recurrwlock_slock(struct XTThread *self, XTRecurRWLockPtr rrw)
+{
+	xt_slock_rwlock(self, &rrw->rrw_lock);
+}
+
+void xt_recurrwlock_slock_ns(XTRecurRWLockPtr rrw)
+{
+	xt_slock_rwlock_ns(&rrw->rrw_lock);
+}
+
+void xt_recurrwlock_unxlock(struct XTThread *self, XTRecurRWLockPtr rrw)
+{
+	ASSERT(self == rrw->rrw_locker);
+	ASSERT(rrw->rrw_lock_count > 0);
+	rrw->rrw_lock_count--;
+	if (!rrw->rrw_lock_count) {
+		rrw->rrw_locker = NULL;
+		xt_unlock_rwlock(self, &rrw->rrw_lock);
+	}
+}
+
+void xt_recurrwlock_unslock(struct XTThread *self, XTRecurRWLockPtr rrw)
+{
+	xt_unlock_rwlock(self, &rrw->rrw_lock);
+}
+
+void xt_recurrwlock_unslock_ns(XTRecurRWLockPtr rrw)
+{
+	xt_unlock_rwlock_ns(&rrw->rrw_lock);
+}
+
+/*
+ * -----------------------------------------------------------------------
  * UNIT TESTS
  */
 
@@ -2031,7 +2176,7 @@
 			xt_rwmutex_unlock(&data->xs_lock, self->t_id);
 		}
 		else if (data->xs_which_lock == LOCK_SPINXSLOCK) {
-			xt_spinxslock_xlock(&data->xs_spinrwlock, self->t_id);
+			xt_spinxslock_xlock(&data->xs_spinrwlock, FALSE, self->t_id);
 			lck_do_job(self, data->xs_which_job, data, FALSE);
 			xt_spinxslock_unlock(&data->xs_spinrwlock, TRUE);
 		}
@@ -2041,12 +2186,12 @@
 			xt_xsmutex_unlock(&data->xs_fastrwlock, self->t_id);
 		}
 		else if (data->xs_which_lock == LOCK_ATOMICRWLOCK) {
-			xt_atomicrwlock_xlock(&data->xs_atomicrwlock, self->t_id);
+			xt_atomicrwlock_xlock(&data->xs_atomicrwlock, FALSE, self->t_id);
 			lck_do_job(self, data->xs_which_job, data, FALSE);
 			xt_atomicrwlock_unlock(&data->xs_atomicrwlock, TRUE);
 		}
 		else if (data->xs_which_lock == LOCK_SKEWRWLOCK) {
-			xt_skewrwlock_xlock(&data->xs_skewrwlock, self->t_id);
+			xt_skewrwlock_xlock(&data->xs_skewrwlock, FALSE, self->t_id);
 			lck_do_job(self, data->xs_which_job, data, FALSE);
 			xt_skewrwlock_unlock(&data->xs_skewrwlock, TRUE);
 		}

=== modified file 'storage/pbxt/src/lock_xt.h'
--- storage/pbxt/src/lock_xt.h	2009-08-17 11:12:36 +0000
+++ storage/pbxt/src/lock_xt.h	2010-05-07 08:52:27 +0000
@@ -109,7 +109,8 @@
 inline void xt_atomic_inc2(volatile xtWord2 *mptr)
 {
 #ifdef XT_ATOMIC_WIN32_X86
-	__asm LOCK INC	WORD PTR mptr
+	__asm MOV  ECX, mptr
+	__asm LOCK INC	WORD PTR [ECX]
 #elif defined(XT_ATOMIC_GNUC_X86)
 	asm volatile ("lock; incw %0" : : "m" (*mptr) : "memory");
 #elif defined(XT_ATOMIC_GCC_OPS)
@@ -125,7 +126,8 @@
 inline void xt_atomic_dec2(volatile xtWord2 *mptr)
 {
 #ifdef XT_ATOMIC_WIN32_X86
-	__asm LOCK DEC	WORD PTR mptr
+	__asm MOV  ECX, mptr
+	__asm LOCK DEC	WORD PTR [ECX]
 #elif defined(XT_ATOMIC_GNUC_X86)
 	asm volatile ("lock; decw %0" : : "m" (*mptr) : "memory");
 #elif defined(XT_ATOMIC_GCC_OPS)
@@ -427,6 +429,7 @@
 
 typedef struct XTSpinXSLock {
 	volatile xtWord2			sxs_xlocked;
+	volatile xtWord2			sxs_xwaiter;
 	volatile xtWord2			sxs_rlock_count;
 	volatile xtWord2			sxs_wait_count;			/* The number of readers waiting for the xlocker. */
 #ifdef DEBUG
@@ -446,7 +449,7 @@
 void xt_spinxslock_init(struct XTThread *self, XTSpinXSLockPtr sxs);
 #endif
 void xt_spinxslock_free(struct XTThread *self, XTSpinXSLockPtr sxs);
-xtBool xt_spinxslock_xlock(XTSpinXSLockPtr sxs, xtThreadID thd_id);
+xtBool xt_spinxslock_xlock(XTSpinXSLockPtr sxs, xtBool try_lock, xtThreadID thd_id);
 xtBool xt_spinxslock_slock(XTSpinXSLockPtr sxs);
 xtBool xt_spinxslock_unlock(XTSpinXSLockPtr sxs, xtBool xlocked);
 
@@ -500,7 +503,7 @@
 void xt_atomicrwlock_init(struct XTThread *self, XTAtomicRWLockPtr xsl);
 #endif
 void xt_atomicrwlock_free(struct XTThread *self, XTAtomicRWLockPtr xsl);
-xtBool xt_atomicrwlock_xlock(XTAtomicRWLockPtr xsl, xtThreadID thr_id);
+xtBool xt_atomicrwlock_xlock(XTAtomicRWLockPtr xsl, xtBool try_lock, xtThreadID thr_id);
 xtBool xt_atomicrwlock_slock(XTAtomicRWLockPtr xsl);
 xtBool xt_atomicrwlock_unlock(XTAtomicRWLockPtr xsl, xtBool xlocked);
 
@@ -525,7 +528,7 @@
 void xt_skewrwlock_init(struct XTThread *self, XTSkewRWLockPtr xsl);
 #endif
 void xt_skewrwlock_free(struct XTThread *self, XTSkewRWLockPtr xsl);
-xtBool xt_skewrwlock_xlock(XTSkewRWLockPtr xsl, xtThreadID thr_id);
+xtBool xt_skewrwlock_xlock(XTSkewRWLockPtr xsl, xtBool try_lock, xtThreadID thr_id);
 xtBool xt_skewrwlock_slock(XTSkewRWLockPtr xsl);
 xtBool xt_skewrwlock_unlock(XTSkewRWLockPtr xsl, xtBool xlocked);
 
@@ -713,4 +716,57 @@
 #define XT_HAVE_LOCK			2
 #define XT_WAITING				3
 
+/*
+ * -----------------------------------------------------------------------
+ * RECURSIVE MUTEX (allows lockers to lock again)
+ */
+
+typedef struct XTRecursiveMutex {
+	struct XTThread				*rm_locker;
+	u_int						rm_lock_count;
+	xt_mutex_type				rm_mutex;
+
+#ifdef XT_THREAD_LOCK_INFO
+	XTThreadLockInfoRec			rm_lock_info;
+	const char				    *rm_name;
+#endif
+} XTRecursiveMutexRec, *XTRecursiveMutexPtr;
+
+#ifdef XT_THREAD_LOCK_INFO
+#define xt_recursivemutex_init_with_autoname(a,b) xt_recursivemutex_init(a,b,LOCKLIST_ARG_SUFFIX(b))
+void xt_recursivemutex_init(struct XTThread *self, XTRecursiveMutexPtr rm, const char *name);
+#else
+#define xt_recursivemutex_init_with_autoname(a,b) xt_recursivemutex_init(a,b)
+void xt_recursivemutex_init(struct XTThread *self, XTRecursiveMutexPtr rm);
+#endif
+void xt_recursivemutex_free(XTRecursiveMutexPtr rm);
+void xt_recursivemutex_lock(struct XTThread *self, XTRecursiveMutexPtr rm);
+void xt_recursivemutex_unlock(struct XTThread *self, XTRecursiveMutexPtr rm);
+
+typedef struct XTRecurRWLock {
+	struct XTThread				*rrw_locker;
+	u_int						rrw_lock_count;
+	xt_rwlock_type				rrw_lock;
+
+#ifdef XT_THREAD_LOCK_INFO
+	XTThreadLockInfoRec			rrw_lock_info;
+	const char				    *rrw_name;
+#endif
+} XTRecurRWLockRec, *XTRecurRWLockPtr;
+
+#ifdef XT_THREAD_LOCK_INFO
+#define xt_recurrwlock_init_with_autoname(a,b) xt_recurrwlock_init(a,b,LOCKLIST_ARG_SUFFIX(b))
+void xt_recurrwlock_init(struct XTThread *self, XTRecurRWLockPtr rrw, const char *name);
+#else
+#define xt_recurrwlock_init_with_autoname(a,b) xt_recurrwlock_init(a,b)
+void xt_recurrwlock_init(struct XTThread *self, XTRecurRWLockPtr rrw);
+#endif
+void xt_recurrwlock_free(XTRecurRWLockPtr rrw);
+void xt_recurrwlock_xlock(struct XTThread *self, XTRecurRWLockPtr rrw);
+void xt_recurrwlock_slock(struct XTThread *self, XTRecurRWLockPtr rrw);
+void xt_recurrwlock_slock_ns(XTRecurRWLockPtr rrw);
+void xt_recurrwlock_unxlock(struct XTThread *self, XTRecurRWLockPtr rrw);
+void xt_recurrwlock_unslock(struct XTThread *self, XTRecurRWLockPtr rrw);
+void xt_recurrwlock_unslock_ns(XTRecurRWLockPtr rrw);
+
 #endif

=== modified file 'storage/pbxt/src/locklist_xt.cc'
--- storage/pbxt/src/locklist_xt.cc	2010-04-21 00:25:59 +0000
+++ storage/pbxt/src/locklist_xt.cc	2010-05-07 08:52:27 +0000
@@ -180,6 +180,10 @@
 				lock_type = "XTAtomicRWLock";
 				lock_name = li->li_atomic_rwlock->arw_name;
 				break;
+			case XTThreadLockInfo::SKEW_RW_LOCK:
+				lock_type = "XTSkewRWLock";
+				lock_name = li->li_skew_rwlock->srw_name;
+				break;
 		}
 
 		xt_ttracef(self, "  #lock#%d: type: %s name: %s \n", count, lock_type, lock_name);

=== modified file 'storage/pbxt/src/myxt_xt.cc'
--- storage/pbxt/src/myxt_xt.cc	2009-12-10 11:36:05 +0000
+++ storage/pbxt/src/myxt_xt.cc	2010-05-07 08:52:27 +0000
@@ -255,6 +255,11 @@
 	xtWord1					*end;
 	xtWord1					*start;
 
+#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++)
 	{
@@ -531,7 +536,7 @@
 		key += length;
 	}
 
-	return fkey_ind->mi_fix_key ? fkey_ind->mi_key_size : (u_int) (key - start);		/* Return keylength */
+	return (u_int) (key - start);
 }
 
 /* I may be overcautious here, but can I assume that
@@ -2132,10 +2137,10 @@
 {
 	enter_();
 	/* The dirty list of cache pages should be empty here! */
-	ASSERT(!mi->mi_dirty_list);
+	/* This is not the case if we were not able to flush data. E.g. when running out of disk space */
+	//ASSERT(!mi->mi_dirty_list);
 	ASSERT(!mi->mi_free_list);
 
-	xt_free_mutex(&mi->mi_flush_lock);
 	xt_spinlock_free(self, &mi->mi_dirty_lock);
 	XT_INDEX_FREE_LOCK(self, mi);
 	myxt_bitmap_free(self, &mi->mi_col_map);
@@ -2174,7 +2179,6 @@
 	pushsr_(ind, my_deref_index_data, (XTIndexPtr) xt_calloc(self, MX_OFFSETOF(XTIndexRec, mi_seg) + sizeof(XTIndexSegRec) * index->key_parts));
 
 	XT_INDEX_INIT_LOCK(self, ind);
-	xt_init_mutex_with_autoname(self, &ind->mi_flush_lock);
 	xt_spinlock_init_with_autoname(self, &ind->mi_dirty_lock);
 	ind->mi_index_no = idx;
 	ind->mi_flags = (index->flags & (HA_NOSAME | HA_NULL_ARE_EQUAL | HA_UNIQUE_CHECK));
@@ -2556,8 +2560,12 @@
 			ave_row_size += 3 + ave_data_size;
 
 		/* This is the length of the record required for all indexes: */
-		if (field_count + 1 == dic->dic_ind_cols_req)
-			dic->dic_ind_rec_len = max_data_size;
+		/* This was calculated incorrectly. Not a serius bug because it
+		 * is only used in the case of fixed length row, and in this
+		 * case the dic_ind_rec_len is set correctly below.
+		 */
+		if (field_count == dic->dic_ind_cols_req)
+			dic->dic_ind_rec_len = max_row_size;
  	}
 
 	dic->dic_min_row_size = min_row_size;
@@ -2624,6 +2632,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;
@@ -2861,6 +2883,7 @@
 	for (key_part = key->key_part; key_part != key_part_end; key_part++) {
 		if (!(cref = new XTDDColumnRef()))
 			xt_throw_errno(XT_CONTEXT, XT_ENOMEM);
+		cref->init(self);
 		ind->co_cols.append(self, cref);
 		cref->cr_col_name = xt_dup_string(self, (char *) key_part->field->field_name);
 	}

=== modified file 'storage/pbxt/src/pthread_xt.cc'
--- storage/pbxt/src/pthread_xt.cc	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/pthread_xt.cc	2010-05-07 08:52:27 +0000
@@ -39,25 +39,25 @@
 
 #ifdef XT_WIN
 
-void xt_p_init_threading(void)
+xtPublic void xt_p_init_threading(void)
 {
 }
 
-int xt_p_set_normal_priority(pthread_t thr)
+xtPublic int xt_p_set_normal_priority(pthread_t thr)
 {
 	if (!SetThreadPriority (thr, THREAD_PRIORITY_NORMAL))
 		return GetLastError();
 	return 0;
 }
 
-int xt_p_set_low_priority(pthread_t thr)
+xtPublic int xt_p_set_low_priority(pthread_t thr)
 {
 	if (!SetThreadPriority (thr, THREAD_PRIORITY_LOWEST))
 		return GetLastError();
 	return 0;
 }
 
-int xt_p_set_high_priority(pthread_t thr)
+xtPublic int xt_p_set_high_priority(pthread_t thr)
 {
 	if (!SetThreadPriority (thr, THREAD_PRIORITY_HIGHEST))
 		return GetLastError();
@@ -67,9 +67,9 @@
 #define XT_RWLOCK_MAGIC 0x78AC390E
 
 #ifdef XT_THREAD_LOCK_INFO
-int xt_p_mutex_init(xt_mutex_type *mutex, const pthread_mutexattr_t *attr, const char *n)
+xtPublic int xt_p_mutex_init(xt_mutex_type *mutex, const pthread_mutexattr_t *attr, const char *n)
 #else
-int xt_p_mutex_init(xt_mutex_type *mutex, const pthread_mutexattr_t *attr)
+xtPublic int xt_p_mutex_init(xt_mutex_type *mutex, const pthread_mutexattr_t *attr)
 #endif
 {
 	InitializeCriticalSection(&mutex->mt_cs);
@@ -80,7 +80,7 @@
 	return 0;
 }
 
-int xt_p_mutex_destroy(xt_mutex_type *mutex)
+xtPublic int xt_p_mutex_destroy(xt_mutex_type *mutex)
 {
 	DeleteCriticalSection(&mutex->mt_cs);
 #ifdef XT_THREAD_LOCK_INFO
@@ -89,7 +89,7 @@
 	return 0;
 }
 
-int xt_p_mutex_lock(xt_mutex_type *mx)
+xtPublic int xt_p_mutex_lock(xt_mutex_type *mx)
 {
 	EnterCriticalSection(&mx->mt_cs);
 #ifdef XT_THREAD_LOCK_INFO
@@ -98,7 +98,7 @@
 	return 0;
 }
 
-int xt_p_mutex_unlock(xt_mutex_type *mx)
+xtPublic int xt_p_mutex_unlock(xt_mutex_type *mx)
 {
 	LeaveCriticalSection(&mx->mt_cs);
 #ifdef XT_THREAD_LOCK_INFO
@@ -107,7 +107,7 @@
 	return 0;
 }
 
-int xt_p_mutex_trylock(xt_mutex_type *mutex)
+xtPublic int xt_p_mutex_trylock(xt_mutex_type *mutex)
 {
 #if(_WIN32_WINNT >= 0x0400)
 	/* NOTE: MySQL bug! was using?!
@@ -130,9 +130,9 @@
 }
 
 #ifdef XT_THREAD_LOCK_INFO
-int xt_p_rwlock_init(xt_rwlock_type *rwl, const pthread_condattr_t *attr, const char *n)
+xtPublic int xt_p_rwlock_init(xt_rwlock_type *rwl, const pthread_condattr_t *attr, const char *n)
 #else
-int xt_p_rwlock_init(xt_rwlock_type *rwl, const pthread_condattr_t *attr)
+xtPublic int xt_p_rwlock_init(xt_rwlock_type *rwl, const pthread_condattr_t *attr)
 #endif
 {
 	int result;
@@ -173,7 +173,7 @@
 	return result;
 }
 
-int xt_p_rwlock_destroy(xt_rwlock_type *rwl)
+xtPublic int xt_p_rwlock_destroy(xt_rwlock_type *rwl)
 {
 	int result = 0, result1 = 0, result2 = 0;
 
@@ -225,7 +225,7 @@
 }
 
 
-int xt_p_rwlock_rdlock(xt_rwlock_type *rwl)
+xtPublic int xt_p_rwlock_rdlock(xt_rwlock_type *rwl)
 {
 	int result;
 
@@ -262,7 +262,7 @@
 	return (xt_p_mutex_unlock (&(rwl->rw_ex_lock)));
 }
 
-int xt_p_rwlock_wrlock(xt_rwlock_type *rwl)
+xtPublic int xt_p_rwlock_wrlock(xt_rwlock_type *rwl)
 {
 	int result;
 
@@ -309,7 +309,54 @@
 	return result;
 }
 
-int xt_p_rwlock_unlock(xt_rwlock_type *rwl)
+xtPublic xtBool xt_p_rwlock_try_wrlock(xt_rwlock_type *rwl)
+{
+	int result;
+
+	if (rwl == NULL)
+		return FALSE;
+
+	if (rwl->rw_magic != XT_RWLOCK_MAGIC)
+		return FALSE;
+
+	if ((result = xt_p_mutex_trylock(&rwl->rw_ex_lock)) != 0)
+		return FALSE;
+
+	if ((result = xt_p_mutex_lock(&rwl->rw_sh_lock)) != 0) {
+		(void) xt_p_mutex_unlock(&rwl->rw_ex_lock);
+		return FALSE;
+	}
+
+	if (rwl->rw_ex_count == 0) {
+		if (rwl->rw_sh_complete_count > 0) {
+			rwl->rw_sh_count -= rwl->rw_sh_complete_count;
+			rwl->rw_sh_complete_count = 0;
+		}
+
+		if (rwl->rw_sh_count > 0) {
+			rwl->rw_sh_complete_count = -rwl->rw_sh_count;
+
+			do {
+				result = pthread_cond_wait (&rwl->rw_sh_cond, &rwl->rw_sh_lock.mt_cs);
+			}
+			while (result == 0 && rwl->rw_sh_complete_count < 0);
+
+			if (result == 0)
+				rwl->rw_sh_count = 0;
+		}
+	}
+
+	if (result == 0)
+		rwl->rw_ex_count++;
+
+#ifdef XT_THREAD_LOCK_INFO
+	xt_thread_lock_info_add_owner(&rwl->rw_lock_info);
+#endif
+
+	return TRUE;
+}
+
+xtPublic int xt_p_rwlock_unlock(xt_rwlock_type *rwl)
 {
 	int result, result1;
 
@@ -342,12 +389,12 @@
 	return ((result != 0) ? result : result1);
 }
 
-int xt_p_cond_wait(xt_cond_type *cond, xt_mutex_type *mutex)
+xtPublic int xt_p_cond_wait(xt_cond_type *cond, xt_mutex_type *mutex)
 {
 	return xt_p_cond_timedwait(cond, mutex, NULL);
 }
 
-int xt_p_cond_timedwait(xt_cond_type *cond, xt_mutex_type *mt, struct timespec *abstime)
+xtPublic int xt_p_cond_timedwait(xt_cond_type *cond, xt_mutex_type *mt, struct timespec *abstime)
 {
 	pthread_mutex_t	*mutex = &mt->mt_cs;
 	int				result;
@@ -393,7 +440,7 @@
 	return result == WAIT_TIMEOUT ? ETIMEDOUT : 0;
 }
 
-int xt_p_join(pthread_t thread, void **value)
+xtPublic int xt_p_join(pthread_t thread, void **value)
 {
 	DWORD exitcode;
 
@@ -676,6 +723,23 @@
 	return r;
 }
 
+xtPublic xtBool xt_p_rwlock_try_wrlock(xt_rwlock_type *rwlock)
+{
+	XTThreadPtr self = xt_get_self();
+	int			r;
+
+	ASSERT_NS(rwlock->rw_init == 67890);
+	r = pthread_rwlock_trywrlock(&rwlock->rw_plock);
+	if (r == 0) {
+		ASSERT_NS(!rwlock->rw_locker);
+		rwlock->rw_locker = self;
+#ifdef XT_THREAD_LOCK_INFO
+		xt_thread_lock_info_add_owner(&rwlock->rw_lock_info);
+#endif
+	}
+	return r == 0;
+}
+
 xtPublic int xt_p_rwlock_unlock(xt_rwlock_type *rwlock)
 {
 	XTThreadPtr self = xt_get_self();

=== modified file 'storage/pbxt/src/pthread_xt.h'
--- storage/pbxt/src/pthread_xt.h	2009-03-26 12:18:01 +0000
+++ storage/pbxt/src/pthread_xt.h	2010-05-07 08:52:27 +0000
@@ -101,13 +101,14 @@
 #else
 int xt_p_rwlock_init(xt_rwlock_type *rwlock, const pthread_condattr_t *attr);
 #endif
-int xt_p_rwlock_destroy(xt_rwlock_type *rwlock);
-int xt_p_rwlock_rdlock(xt_rwlock_type *mx);
-int xt_p_rwlock_wrlock(xt_rwlock_type *mx);
-int xt_p_rwlock_unlock(xt_rwlock_type *mx);
+int		xt_p_rwlock_destroy(xt_rwlock_type *rwlock);
+int		xt_p_rwlock_rdlock(xt_rwlock_type *mx);
+int		xt_p_rwlock_wrlock(xt_rwlock_type *mx);
+xtBool	xt_p_rwlock_try_wrlock(xt_rwlock_type *rwl);
+int		xt_p_rwlock_unlock(xt_rwlock_type *mx);
 
-int xt_p_cond_wait(xt_cond_type *cond, xt_mutex_type *mutex);
-int xt_p_cond_timedwait(xt_cond_type *cond, xt_mutex_type *mutex, struct timespec *abstime);
+int		xt_p_cond_wait(xt_cond_type *cond, xt_mutex_type *mutex);
+int		xt_p_cond_timedwait(xt_cond_type *cond, xt_mutex_type *mutex, struct timespec *abstime);
 
 int xt_p_join(pthread_t thread, void **value);
 
@@ -125,6 +126,7 @@
 
 #define xt_slock_rwlock_ns		xt_p_rwlock_rdlock
 #define xt_xlock_rwlock_ns		xt_p_rwlock_wrlock
+#define xt_xlock_try_rwlock_ns	xt_p_rwlock_try_wrlock
 #define xt_unlock_rwlock_ns		xt_p_rwlock_unlock
 
 #ifdef XT_THREAD_LOCK_INFO
@@ -225,9 +227,10 @@
 #endif
 } xt_rwlock_type;
 
-int xt_p_rwlock_rdlock(xt_rwlock_type *mx);
-int xt_p_rwlock_wrlock(xt_rwlock_type *mx);
-int xt_p_rwlock_unlock(xt_rwlock_type *mx);
+int		xt_p_rwlock_rdlock(xt_rwlock_type *mx);
+int		xt_p_rwlock_wrlock(xt_rwlock_type *mx);
+xtBool	xt_p_rwlock_try_wrlock(xt_rwlock_type *mx);
+int		xt_p_rwlock_unlock(xt_rwlock_type *mx);
 
 int xt_p_mutex_lock(xt_mutex_type *mx, u_int line, const char *file);
 int xt_p_mutex_unlock(xt_mutex_type *mx);
@@ -251,37 +254,39 @@
 }
 #endif
 
-#define xt_slock_rwlock_ns		xt_p_rwlock_rdlock
-#define xt_xlock_rwlock_ns		xt_p_rwlock_wrlock
-#define xt_unlock_rwlock_ns		xt_p_rwlock_unlock
+#define xt_slock_rwlock_ns			xt_p_rwlock_rdlock
+#define xt_xlock_rwlock_ns			xt_p_rwlock_wrlock
+#define xt_xlock_try_rwlock_ns		xt_p_rwlock_try_wrlock
+#define xt_unlock_rwlock_ns			xt_p_rwlock_unlock
 
-#define xt_lock_mutex_ns(x)		xt_p_mutex_lock(x, __LINE__, __FILE__)
-#define xt_unlock_mutex_ns		xt_p_mutex_unlock
-#define xt_mutex_trylock		xt_p_mutex_trylock
+#define xt_lock_mutex_ns(x)			xt_p_mutex_lock(x, __LINE__, __FILE__)
+#define xt_unlock_mutex_ns			xt_p_mutex_unlock
+#define xt_mutex_trylock			xt_p_mutex_trylock
 
 #else // DEBUG_LOCKING
 
-#define xt_rwlock_struct		_opaque_pthread_rwlock_t
-#define xt_mutex_struct			_opaque_pthread_mutex_t
-
-#define xt_rwlock_type			pthread_rwlock_t
-#define xt_mutex_type			pthread_mutex_t
-
-#define xt_slock_rwlock_ns		pthread_rwlock_rdlock
-#define xt_xlock_rwlock_ns		pthread_rwlock_wrlock
-#define xt_unlock_rwlock_ns		pthread_rwlock_unlock
-
-#define xt_lock_mutex_ns		pthread_mutex_lock
-#define xt_unlock_mutex_ns		pthread_mutex_unlock
-#define xt_mutex_trylock		pthread_mutex_trylock
-
-#define xt_p_mutex_trylock		pthread_mutex_trylock
-#define xt_p_mutex_destroy		pthread_mutex_destroy
-#define xt_p_mutex_init			pthread_mutex_init
-#define xt_p_rwlock_destroy		pthread_rwlock_destroy
-#define xt_p_rwlock_init		pthread_rwlock_init
-#define xt_p_cond_wait			pthread_cond_wait
-#define xt_p_cond_timedwait		pthread_cond_timedwait
+#define xt_rwlock_struct			_opaque_pthread_rwlock_t
+#define xt_mutex_struct				_opaque_pthread_mutex_t
+
+#define xt_rwlock_type				pthread_rwlock_t
+#define xt_mutex_type				pthread_mutex_t
+
+#define xt_slock_rwlock_ns			pthread_rwlock_rdlock
+#define xt_xlock_rwlock_ns			pthread_rwlock_wrlock
+#define xt_xlock_try_rwlock_ns(x)	(pthread_rwlock_trywrlock(x) == 0)
+#define xt_unlock_rwlock_ns			pthread_rwlock_unlock
+
+#define xt_lock_mutex_ns			pthread_mutex_lock
+#define xt_unlock_mutex_ns			pthread_mutex_unlock
+#define xt_mutex_trylock			pthread_mutex_trylock
+
+#define xt_p_mutex_trylock			pthread_mutex_trylock
+#define xt_p_mutex_destroy			pthread_mutex_destroy
+#define xt_p_mutex_init				pthread_mutex_init
+#define xt_p_rwlock_destroy			pthread_rwlock_destroy
+#define xt_p_rwlock_init			pthread_rwlock_init
+#define xt_p_cond_wait				pthread_cond_wait
+#define xt_p_cond_timedwait			pthread_cond_timedwait
 
 #endif // DEBUG_LOCKING
 

=== modified file 'storage/pbxt/src/restart_xt.cc'
--- storage/pbxt/src/restart_xt.cc	2010-01-06 21:27:53 +0000
+++ storage/pbxt/src/restart_xt.cc	2010-05-07 08:52:27 +0000
@@ -1315,7 +1315,7 @@
 		tab->tab_head_op_seq = op->or_op_seq;
 		if (tab->tab_wr_wake_freeer) {
 			if (!XTTableSeq::xt_op_is_before(tab->tab_head_op_seq, tab->tab_wake_freeer_op))
-				xt_wr_wake_freeer(self);
+				xt_wr_wake_freeer(self, ws->ws_db);
 		}
 		i++;
 	}
@@ -1498,7 +1498,7 @@
 		tab->tab_head_op_seq = op_seq;
 		if (tab->tab_wr_wake_freeer) {
 			if (!XTTableSeq::xt_op_is_before(tab->tab_head_op_seq, tab->tab_wake_freeer_op))
-				xt_wr_wake_freeer(self);
+				xt_wr_wake_freeer(self, ws->ws_db);
 		}
 
 		/* Apply any operations in the list that now follow on...
@@ -1575,10 +1575,12 @@
 static void xres_init_checkpoint_state(XTThreadPtr self, XTCheckPointStatePtr cp)
 {
 	xt_init_mutex_with_autoname(self, &cp->cp_state_lock);
+	cp->cp_inited = TRUE;
 }
 
 static void xres_free_checkpoint_state(XTThreadPtr self, XTCheckPointStatePtr cp)
 {
+	cp->cp_inited = FALSE;
 	xt_free_mutex(&cp->cp_state_lock);
 	if (cp->cp_table_ids) {
 		xt_free_sortedlist(self, cp->cp_table_ids);
@@ -1616,6 +1618,7 @@
 
 	xt_init_mutex_with_autoname(self, &db->db_cp_lock);
 	xt_init_cond(self, &db->db_cp_cond);
+	xt_init_mutex_with_autoname(self, &db->db_fl_lock);
 	
 	xres_init_checkpoint_state(self, &db->db_cp_state);
 	db->db_restart.xres_init(self, db, &db->db_wr_log_id, &db->db_wr_log_offset, &max_log_id);
@@ -1633,6 +1636,7 @@
 	xres_free_checkpoint_state(self, &db->db_cp_state);
 	xt_free_mutex(&db->db_cp_lock);
 	xt_free_cond(&db->db_cp_cond);
+	xt_free_mutex(&db->db_fl_lock);
 }
 
 /* ----------------------------------------------------------------------
@@ -2182,7 +2186,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;
 }
 
 /*
@@ -2531,10 +2535,10 @@
 	XTDatabaseHPtr		db = self->st_database;
 	u_int				curr_writer_total;
 	time_t				now;
+	xtXactID			sweep_count;
 
 	xt_set_low_priority(self);
 
-
 	while (!self->t_quit) {
 		/* Wait 2 seconds: */
 		curr_writer_total = db->db_xn_total_writer_count;
@@ -2549,9 +2553,13 @@
 		if (self->t_quit)
 			break;
 
-		if (curr_writer_total == db->db_xn_total_writer_count)
+		sweep_count = db->db_xn_curr_id + 1 - db->db_xn_to_clean_id;
+		if (curr_writer_total == db->db_xn_total_writer_count &&
+			!sweep_count &&
+			db->db_wr_idle == XT_THREAD_IDLE) {
 			/* No activity in 2 seconds: */
 			xres_cp_checkpoint(self, db, curr_writer_total, FALSE);
+		}
 		else {
 			/* There server is busy, check if we need to
 			 * write a checkpoint anyway...
@@ -2672,6 +2680,10 @@
 	XTOperationPtr			op;
 	XTCheckPointTableRec	cpt;
 	XTSortedListPtr			tables = NULL;
+	
+	/* during startup we can get an error before the checkpointer is inited */
+	if (!cp->cp_inited)
+		return FAILED;
 
 	/* First check if a checkpoint is already running: */
 	xt_lock_mutex_ns(&cp->cp_state_lock);
@@ -3314,7 +3326,7 @@
 	* #7	0x000c0db2 in THD::~THD at sql_class.cc:934
 	* #8	0x003b025b in myxt_destroy_thread at myxt_xt.cc:2999
 	* #9	0x003b66b5 in xn_xres_run_recovery_thread at restart_xt.cc:3196
-	* #10	0x003cbfbb in thr_main_pbxt at thread_xt.cc:1020
+	* #10	0x003cbfbb in xt_thread_main at thread_xt.cc:1020
 	*
 	myxt_destroy_thread(mysql_thread, TRUE);
 	*/
@@ -3350,3 +3362,123 @@
 		xt_wait_for_thread(tid, TRUE);
 	}
 }
+
+/* ----------------------------------------------------------------------
+ * L O G   F L U S H    P R O C E S S
+ */
+
+static void *xres_fl_run_thread(XTThreadPtr self)
+{
+	XTDatabaseHPtr	db = (XTDatabaseHPtr) self->t_data;
+	int				count;
+	void			*mysql_thread;
+	xtWord8			to_flush;
+
+	if (!(mysql_thread = myxt_create_thread()))
+		xt_throw(self);
+
+	while (!self->t_quit) {
+		try_(a) {
+			/*
+			 * The garbage collector requires that the database
+			 * is in use because.
+			 */
+			xt_use_database(self, db, XT_FOR_CHECKPOINTER);
+
+			/* This action is both safe and required (see details elsewhere) */
+			xt_heap_release(self, self->st_database);
+
+			xt_set_low_priority(self);
+
+			to_flush = xt_trace_clock() + XT_XLOG_FLUSH_FREQ * 1000;
+			for (;;) {
+				/* Wait 1 second: */
+				while (!self->t_quit && xt_trace_clock() < to_flush)
+					xt_sleep_milli_second(10);
+
+				if (self->t_quit)
+					break;
+
+				if (!db->db_xlog.xlog_flush(self))
+					xt_throw(self);
+
+				to_flush += XT_XLOG_FLUSH_FREQ * 1000;
+			}
+		}
+		catch_(a) {
+			/* This error is "normal"! */
+			if (self->t_exception.e_xt_err != XT_ERR_NO_DICTIONARY &&
+				!(self->t_exception.e_xt_err == XT_SIGNAL_CAUGHT &&
+				self->t_exception.e_sys_err == SIGTERM))
+				xt_log_and_clear_exception(self);
+		}
+		cont_(a);
+
+		/* Avoid releasing the database (done above) */
+		self->st_database = NULL;
+		xt_unuse_database(self, self);
+
+		/* After an exception, pause before trying again... */
+		/* Number of seconds */
+		count = 60;
+		while (!self->t_quit && count > 0) {
+			sleep(1);
+			count--;
+		}
+	}
+
+   /*
+	* {MYSQL-THREAD-KILL}
+	myxt_destroy_thread(mysql_thread, TRUE);
+	*/
+	return NULL;
+}
+
+static void xres_fl_free_thread(XTThreadPtr self, void *data)
+{
+	XTDatabaseHPtr db = (XTDatabaseHPtr) data;
+
+	if (db->db_fl_thread) {
+		xt_lock_mutex(self, &db->db_fl_lock);
+		pushr_(xt_unlock_mutex, &db->db_fl_lock);
+		db->db_fl_thread = NULL;
+		freer_(); // xt_unlock_mutex(&db->db_fl_lock)
+	}
+}
+
+xtPublic void xt_start_flusher(XTThreadPtr self, XTDatabaseHPtr db)
+{
+	char name[PATH_MAX];
+
+	sprintf(name, "FL-%s", xt_last_directory_of_path(db->db_main_path));
+	xt_remove_dir_char(name);
+	db->db_fl_thread = xt_create_daemon(self, name);
+	xt_set_thread_data(db->db_fl_thread, db, xres_fl_free_thread);
+	xt_run_thread(self, db->db_fl_thread, xres_fl_run_thread);
+}
+
+xtPublic void xt_stop_flusher(XTThreadPtr self, XTDatabaseHPtr db)
+{
+	XTThreadPtr thr_fl;
+
+	if (db->db_fl_thread) {
+		xt_lock_mutex(self, &db->db_fl_lock);
+		pushr_(xt_unlock_mutex, &db->db_fl_lock);
+
+		/* This pointer is safe as long as you have the transaction lock. */
+		if ((thr_fl = db->db_fl_thread)) {
+			xtThreadID tid = thr_fl->t_id;
+
+			/* Make sure the thread quits when woken up. */
+			xt_terminate_thread(self, thr_fl);
+
+			freer_(); // xt_unlock_mutex(&db->db_cp_lock)
+
+			xt_wait_for_thread(tid, FALSE);
+			db->db_fl_thread = NULL;
+		}
+		else
+			freer_(); // xt_unlock_mutex(&db->db_cp_lock)
+	}
+}
+

=== modified file 'storage/pbxt/src/restart_xt.h'
--- storage/pbxt/src/restart_xt.h	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/restart_xt.h	2010-05-07 08:52:27 +0000
@@ -92,6 +92,7 @@
 } XTXactRestartRec, *XTXactRestartPtr;
 
 typedef struct XTCheckPointState {
+	xtBool					cp_inited;						/* TRUE if structure was inited */
 	xt_mutex_type			cp_state_lock;					/* Lock and the entire checkpoint state. */
 	xtBool					cp_running;						/* TRUE if a checkpoint is running. */
 	xtLogID					cp_log_id;
@@ -136,6 +137,9 @@
 void xt_xres_start_database_recovery(XTThreadPtr self);
 void xt_xres_terminate_recovery(XTThreadPtr self);
 
+void xt_start_flusher(struct XTThread *self, struct XTDatabase *db);
+void xt_stop_flusher(struct XTThread *self, struct XTDatabase *db);
+
 #define XT_RECOVER_PENDING			0
 #define XT_RECOVER_DONE				1
 #define XT_RECOVER_SWEPT			2

=== modified file 'storage/pbxt/src/strutil_xt.cc'
--- storage/pbxt/src/strutil_xt.cc	2009-12-21 13:13:15 +0000
+++ storage/pbxt/src/strutil_xt.cc	2010-05-07 08:52:27 +0000
@@ -380,7 +380,7 @@
 /* Version number must also be set in configure.in! */
 xtPublic c_char *xt_get_version(void)
 {
-	return "1.0.09g RC";
+	return "1.0.11 Pre-GA";
 }
 
 /* Copy and URL decode! */

=== modified file 'storage/pbxt/src/tabcache_xt.cc'
--- storage/pbxt/src/tabcache_xt.cc	2009-11-27 15:37:02 +0000
+++ storage/pbxt/src/tabcache_xt.cc	2010-05-07 08:52:27 +0000
@@ -46,8 +46,10 @@
 xtPublic void xt_tc_set_cache_size(size_t cache_size)
 {
 	xt_tab_cache.tcm_cache_size = cache_size;
-	xt_tab_cache.tcm_low_level = cache_size / 4 * 3;		// Current 75%
-	xt_tab_cache.tcm_high_level = cache_size / 100 * 95;	// Current 95%
+	/* Multiplying by this number can overflow a 4 byte value! */
+	xt_tab_cache.tcm_low_level = (size_t) ((xtWord8) cache_size * (xtWord8) 70 / (xtWord8) 100);	// Current 70%
+	xt_tab_cache.tcm_high_level = (size_t) ((xtWord8) cache_size * 95 / (xtWord8) 100);				// Current 95%
+	xt_tab_cache.tcm_mid_level = (size_t) ((xtWord8) cache_size * 85 / (xtWord8) 100);				// Current 85%
 }
 
 /*
@@ -84,25 +86,30 @@
 
 xtPublic void xt_tc_exit(XTThreadPtr self)
 {
+	XTTabCacheSegPtr seg;
+
 	for (u_int i=0; i<XT_TC_SEGMENT_COUNT; i++) {
-		if (xt_tab_cache.tcm_segment[i].tcs_hash_table) {
-			if (xt_tab_cache.tcm_segment[i].tcs_cache_in_use) {
-				XTTabCachePagePtr page, tmp_page;
+		seg = &xt_tab_cache.tcm_segment[i];
+		if (seg->tcs_hash_table) {
+			XTTabCachePagePtr page, tmp_page;
 
-				for (size_t j=0; j<xt_tab_cache.tcm_hash_size; j++) {
-					page = xt_tab_cache.tcm_segment[i].tcs_hash_table[j];
-					while (page) {
-						tmp_page = page;
-						page = page->tcp_next;
-						xt_free(self, tmp_page);
-					}
+			for (size_t j=0; j<xt_tab_cache.tcm_hash_size; j++) {
+				page = seg->tcs_hash_table[j];
+				while (page) {
+					tmp_page = page;
+					page = page->tcp_next;
+					ASSERT_NS(seg->tcs_cache_in_use >= offsetof(XTTabCachePageRec, tcp_data) + tmp_page->tcp_data_size);
+					seg->tcs_cache_in_use -= (offsetof(XTTabCachePageRec, tcp_data) + tmp_page->tcp_data_size);
+					ASSERT_NS(seg->tcs_cache_in_use == 0 || seg->tcs_cache_in_use >= 25000);
+					xt_free(self, tmp_page);
 				}
 			}
 
-			xt_free(self, xt_tab_cache.tcm_segment[i].tcs_hash_table);
-			xt_tab_cache.tcm_segment[i].tcs_hash_table = NULL;
-			TAB_CAC_FREE_LOCK(self, &xt_tab_cache.tcm_segment[i].tcs_lock);
+			xt_free(self, seg->tcs_hash_table);
+			seg->tcs_hash_table = NULL;
+			TAB_CAC_FREE_LOCK(self, &seg->tcs_lock);
 		}
+		ASSERT_NS(seg->tcs_cache_in_use == 0);
 	}
 
 	xt_free_mutex(&xt_tab_cache.tcm_lock);
@@ -554,24 +561,24 @@
 		}
 		page = page->tcp_next;
 	}
+	
+	size_t page_size = offsetof(XTTabCachePageRec, tcp_data) + this->tci_page_size;
+
 	TAB_CAC_UNLOCK(&seg->tcs_lock, thread->t_id);
 	
 	/* Page not found, allocate a new page: */
-	size_t page_size = offsetof(XTTabCachePageRec, tcp_data) + this->tci_page_size;
 	if (!(new_page = (XTTabCachePagePtr) xt_malloc_ns(page_size)))
 		return FAILED;
-	/* Increment cache used. */
-	seg->tcs_cache_in_use += page_size;
 
 	/* Check the level of the cache: */
 	size_t cache_used = 0;
 	for (int i=0; i<XT_TC_SEGMENT_COUNT; i++)
 		cache_used += dcg->tcm_segment[i].tcs_cache_in_use;
 
-	if (cache_used > dcg->tcm_cache_high)
+	if (cache_used + page_size > dcg->tcm_cache_high)
 		dcg->tcm_cache_high = cache_used;
 
-	if (cache_used > dcg->tcm_cache_size) {
+	if (cache_used + page_size > dcg->tcm_cache_size) {
 		XTThreadPtr self;
 		time_t		now;
 
@@ -638,7 +645,7 @@
 			for (int i=0; i<XT_TC_SEGMENT_COUNT; i++)
 				cache_used += dcg->tcm_segment[i].tcs_cache_in_use;
 
-			if (cache_used <= dcg->tcm_high_level)
+			if (cache_used + page_size <= dcg->tcm_high_level)
 				break;
 			/*
 			 * If there is too little cache we can get stuck here.
@@ -663,7 +670,7 @@
 		while (time(NULL) < now + 5);
 		xt_unlock_mutex_ns(&dcg->tcm_freeer_lock);
 	}
-	else if (cache_used > dcg->tcm_high_level) {
+	else if (cache_used + page_size > dcg->tcm_high_level) {
 		/* Wake up the freeer because the cache level,
 		 * is higher than the high level.
 		 */
@@ -693,6 +700,9 @@
 	}
 	
 #ifdef XT_MEMSET_UNUSED_SPACE
+	else
+		red_size = 0;
+
 	/* Removing this is an optimization. It should not be required
 	 * to clear the unused space in the page.
 	 */
@@ -727,6 +737,15 @@
 	page->tcp_next = seg->tcs_hash_table[hash_idx];
 	seg->tcs_hash_table[hash_idx] = page;
 
+	/* GOTCHA! This increment was done just after the malloc!
+	 * So it was not protected by the segment lock!
+	 * The result was that this count was no longer reliable,
+	 * This resulted in the amount of cache being used becoming less, and\
+	 * less, because increments were lost over time!
+	 */
+	/* Increment cache used. */
+	seg->tcs_cache_in_use += page_size;
+
 	done_ok:
 	*ret_seg = seg;
 	*ret_page = page;
@@ -761,7 +780,7 @@
 	 * some will be missing, so the writer will not
 	 * be able to contniue.
 	 */
-	return xt_xlog_log_data(thread, sizeof(XTactNoOpEntryDRec), (XTXactLogBufferDPtr) &ent_rec, FALSE);
+	return xt_xlog_log_data(thread, sizeof(XTactNoOpEntryDRec), (XTXactLogBufferDPtr) &ent_rec, XT_XLOG_NO_WRITE_NO_FLUSH);
 }
 
 #ifdef XT_NOT_INLINE
@@ -828,13 +847,23 @@
 /*
  * Used by the writer to wake the freeer.
  */
-xtPublic void xt_wr_wake_freeer(XTThreadPtr self)
+xtPublic void xt_wr_wake_freeer(XTThreadPtr self, XTDatabaseHPtr db)
 {
+	/* BUG FIX: Was using tcm_freeer_cond.
+	 * This is incorrect. When the freeer waits for the
+	 * writter, it uses the writer's condition!
+	 */
+	xt_lock_mutex_ns(&db->db_wr_lock);
+	if (!xt_broadcast_cond_ns(&db->db_wr_cond))
+		xt_log_and_clear_exception_ns();
+	xt_unlock_mutex_ns(&db->db_wr_lock);
+/*
 	xt_lock_mutex(self, &xt_tab_cache.tcm_freeer_lock);
 	pushr_(xt_unlock_mutex, &xt_tab_cache.tcm_freeer_lock);
 	if (!xt_broadcast_cond_ns(&xt_tab_cache.tcm_freeer_cond))
 		xt_log_and_clear_exception_ns();
 	freer_(); // xt_unlock_mutex(&xt_tab_cache.tcm_freeer_lock)
+*/
 }
 
 /* Wait for a transaction to quit: */
@@ -1070,7 +1099,9 @@
 
 	/* Free the page: */
 	size_t freed_space = offsetof(XTTabCachePageRec, tcp_data) + page->tcp_data_size;
+	ASSERT_NS(seg->tcs_cache_in_use >= freed_space);
 	seg->tcs_cache_in_use -= freed_space;
+	ASSERT_NS(seg->tcs_cache_in_use == 0 || seg->tcs_cache_in_use >= 25000);
 	xt_free_ns(page);
 
 	TAB_CAC_UNLOCK(&seg->tcs_lock, self->t_id);
@@ -1083,6 +1114,7 @@
 {
 	register XTTabCacheMemPtr	dcg = &xt_tab_cache;
 	TCResourceRec				tc = { 0 };
+	int							i;
 
 	xt_set_low_priority(self);
 	dcg->tcm_freeer_busy = TRUE;
@@ -1095,14 +1127,20 @@
 		while (!self->t_quit) {
 			/* Total up the cache memory used: */
 			cache_used = 0;
-			for (int i=0; i<XT_TC_SEGMENT_COUNT; i++)
+			for (i=0; i<XT_TC_SEGMENT_COUNT; i++)
 				cache_used += dcg->tcm_segment[i].tcs_cache_in_use;
-			if (cache_used > dcg->tcm_cache_high) {
+
+			if (cache_used > dcg->tcm_cache_high)
 				dcg->tcm_cache_high = cache_used;
-			}
 
 			/* Check if the cache usage is over 95%: */
-			if (self->t_quit || cache_used < dcg->tcm_high_level)
+			if (self->t_quit)
+				break;
+
+			/* If threads are waiting then we are more aggressive about freeing
+			 * cache.
+			 */ 
+			if (cache_used < (dcg->tcm_threads_waiting ? dcg->tcm_mid_level : dcg->tcm_high_level))
 				break;
 
 			/* Reduce cache to the 75% level: */
@@ -1137,7 +1175,23 @@
 		 */
 		xt_db_approximate_time = time(NULL);
 		dcg->tcm_freeer_busy = FALSE;
-		tabc_fr_wait_for_cache(self, 500);
+		/* No idea, why, but I am getting an uneccesarry pause here.
+		 * I run DBT2 with low record cache.
+		 *
+		 * Every now and then there is a pause where the freeer is here,
+		 * and all user threads are waiting for the freeer.
+		 *
+		 * So adding the tcm_threads_waiting condition.
+		 */
+		if (dcg->tcm_threads_waiting) {
+			cache_used = 0;
+			for (i=0; i<XT_TC_SEGMENT_COUNT; i++)
+				cache_used += dcg->tcm_segment[i].tcs_cache_in_use;
+			if (cache_used < dcg->tcm_mid_level)
+				tabc_fr_wait_for_cache(self, 500);
+		}
+		else
+			tabc_fr_wait_for_cache(self, 500);
 		//tabc_fr_wait_for_cache(self, 30*1000);
 		dcg->tcm_freeer_busy = TRUE;
 		xt_db_approximate_time = time(NULL);
@@ -1174,7 +1228,7 @@
 		count = 2*60;
 #endif
 		while (!self->t_quit && count > 0) {
-			xt_db_approximate_time = xt_trace_clock();
+			xt_db_approximate_time = time(NULL);
 			sleep(1);
 			count--;
 		}

=== modified file 'storage/pbxt/src/tabcache_xt.h'
--- storage/pbxt/src/tabcache_xt.h	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/tabcache_xt.h	2010-05-07 08:52:27 +0000
@@ -29,6 +29,7 @@
 struct XTTable;
 struct XTOpenTable;
 struct XTTabCache;
+struct XTDatabase;
 
 #include "thread_xt.h"
 #include "filesys_xt.h"
@@ -226,6 +227,7 @@
 	size_t					tcm_cache_high;					/* The high water level of cache allocation. */
 	size_t					tcm_low_level;					/* This is the level to which the freeer will free, once it starts working. */
 	size_t					tcm_high_level;					/* This is the level at which the freeer will start to work (to avoid waiting)! */
+	size_t					tcm_mid_level;					/* At this level the freeer will not sleep if there are threads waiting. */
 
 	/* The free'er thread: */
 	struct XTThread			*tcm_freeer_thread;				/* The freeer thread . */
@@ -283,6 +285,6 @@
 void	xt_quit_freeer(XTThreadPtr self);
 void	xt_stop_freeer(XTThreadPtr self);
 void	xt_start_freeer(XTThreadPtr self);
-void	xt_wr_wake_freeer(XTThreadPtr self);
+void	xt_wr_wake_freeer(XTThreadPtr self, struct XTDatabase *db);
 
 #endif

=== modified file 'storage/pbxt/src/table_xt.cc'
--- storage/pbxt/src/table_xt.cc	2009-12-22 10:33:20 +0000
+++ storage/pbxt/src/table_xt.cc	2010-05-07 08:52:27 +0000
@@ -61,6 +61,11 @@
 
 #define CHECK_TABLE_STATS
 
+/* The problem is that this can take a long time
+ * if the table is very large!
+ */
+//#define CHECK_TABLE_READ_DATA_LOG
+
 #ifdef TRACE_TABLE_IDS
 //#define PRINTF		xt_ftracef
 #define PRINTF		xt_trace
@@ -217,6 +222,7 @@
 		xt_spinlock_free(self, &tab->tab_ainc_lock);
 		xt_free_mutex(&tab->tab_rec_flush_lock);
 		xt_free_mutex(&tab->tab_ind_flush_lock);
+		xt_free_mutex(&tab->tab_ind_stat_lock);
 		xt_free_mutex(&tab->tab_dic_field_lock);
 		xt_free_mutex(&tab->tab_row_lock);
 		xt_free_mutex(&tab->tab_ind_lock);
@@ -487,6 +493,12 @@
 	}
 	freer_(); // xt_describe_tables_exit(&desc)
 
+	/*
+	 * When we open all tables, we ignore problems with foreign keys.
+	 * This must be done or we will not be able to load tables that
+	 * were created with foreign key checks off.
+	 */
+	self->st_ignore_fkeys = 1;
 	/* 
 	 * The purpose of this code is to ensure that all tables are opened and cached,
 	 * which is actually only required if tables have foreign key references.
@@ -499,14 +511,30 @@
 	 * 
 	 * Cannot open tables in the loop above because db->db_table_by_id which is built 
 	 * above is used by xt_use_table_no_lock() 
+	 *
+	 * {TABLE-STATS}
+	 * NOTE: The code also lead to the statistics failing to work because 
+	 * the tables were already open when the handler was opened.
+	 * Previously we only caclulated statistics when a handler was opened
+	 * and the underlying table was also opened.
 	 */
 	xt_enum_tables_init(&edx);
 	while ((te_ptr = xt_enum_tables_next(self, db, &edx))) {
 		xt_strcpy(PATH_MAX, pbuf, te_ptr->te_tab_path->tp_path);
 		xt_add_dir_char(PATH_MAX, pbuf);
 		xt_strcat(PATH_MAX, pbuf, te_ptr->te_tab_name);
-		xt_heap_release(self, xt_use_table_no_lock(self, db, (XTPathStrPtr)pbuf, FALSE, FALSE, NULL, NULL));
+		try_(a) {
+			xt_heap_release(self, xt_use_table_no_lock(self, db, (XTPathStrPtr) pbuf, FALSE, FALSE, NULL));
+		}
+		catch_(a) {
+			/* ignore errors, because we are just loading all
+			 * the tables that we can...
+			 */
+			xt_log_and_clear_warning(self);
+		}
+		cont_(a);
 	}
+	self->st_ignore_fkeys = 0;
 
 	popr_(); // Discard xt_tab_exit_db(db)
 	exit_();
@@ -651,7 +679,7 @@
 			xt_strcpy(PATH_MAX, path, te_ptr->te_tab_path->tp_path);
 			xt_add_dir_char(PATH_MAX, path);
 			xt_strcat(PATH_MAX, path, te_ptr->te_tab_name);
-			tab = xt_use_table(self, (XTPathStrPtr) path, FALSE, FALSE, NULL);
+			tab = xt_use_table(self, (XTPathStrPtr) path, FALSE, FALSE);
 			tab_check_table(self, tab);
 			xt_heap_release(self, tab);
 			tab = NULL;
@@ -1009,6 +1037,7 @@
 /* a helper function to remove table from the open tables hash on exception
  * used in tab_new_handle() below
  */
+ #ifdef NO_LONGER_REQ
 static void xt_del_from_db_tables_ht(XTThreadPtr self, XTTableHPtr tab)
 {
 	XTTableEntryPtr	te_ptr;
@@ -1024,6 +1053,7 @@
 	if ((te_ptr = (XTTableEntryPtr) xt_sl_find(self, db->db_table_by_id, &tab_id)))
 		te_ptr->te_table = NULL;
 }
+#endif
 
 /*
  * Create a new table handle (i.e. open a table).
@@ -1067,6 +1097,7 @@
 	xt_spinlock_init_with_autoname(self, &tab->tab_ainc_lock);
 	xt_init_mutex_with_autoname(self, &tab->tab_rec_flush_lock);
 	xt_init_mutex_with_autoname(self, &tab->tab_ind_flush_lock);
+	xt_init_mutex_with_autoname(self, &tab->tab_ind_stat_lock);
 	xt_init_mutex_with_autoname(self, &tab->tab_dic_field_lock);
 	xt_init_mutex_with_autoname(self, &tab->tab_row_lock);
 	xt_init_mutex_with_autoname(self, &tab->tab_ind_lock);
@@ -1148,9 +1179,16 @@
      * will work if we have cyclic foreign key references.
      */ 
 	if (tab->tab_dic.dic_table) {
-		pushr_(xt_del_from_db_tables_ht, tab);
-		tab->tab_dic.dic_table->attachReferences(self, db);
-		popr_();
+		try_(a) {
+			tab->tab_dic.dic_table->attachReferences(self, db);
+		}
+		catch_(a) {
+			/* Errors are thrown when: set foreign_key_checks = 1 */
+			/* Undo everything done above: */
+			xt_ht_del(self, db->db_tables, tab->tab_name);
+			xt_throw(self);
+		}
+		cont_(a);
 	}
 
 	*r_tab = tab;
@@ -1162,7 +1200,7 @@
  * Get a reference to a table in the current database. The table reference is valid,
  * as long as the thread is using the database!!!
  */
-xtPublic XTTableHPtr xt_use_table_no_lock(XTThreadPtr self, XTDatabaseHPtr db, XTPathStrPtr name, xtBool no_load, xtBool missing_ok, XTDictionaryPtr dic, xtBool *opened)
+xtPublic XTTableHPtr xt_use_table_no_lock(XTThreadPtr self, XTDatabaseHPtr db, XTPathStrPtr name, xtBool no_load, xtBool missing_ok, XTDictionaryPtr dic)
 {
 	XTTableHPtr tab;
 
@@ -1181,9 +1219,6 @@
 
 		if (tab_new_handle(self, &tab, db, tab_id, name, FALSE, dic) == XT_TAB_NO_DICTIONARY)
 			xt_throw_taberr(XT_CONTEXT, XT_ERR_NO_DICTIONARY, name);
-
-		if (opened)
-			*opened = TRUE;
 	}
 	
 	if (tab)
@@ -1297,7 +1332,7 @@
 	XTSortedListInfoRec	li_undo;
 
 #ifdef TRACE_CREATE_TABLES
-	fprintf(stderr, "CREATE %s\n", name->ps_path);
+	printf("CREATE %s\n", name->ps_path);
 #endif
 	enter_();
 	if (strlen(xt_last_name_of_path(name->ps_path)) > XT_TABLE_NAME_SIZE-1)
@@ -1528,7 +1563,7 @@
 		 * as well.
 		 */
 		if (!old_tab_id) {
-			tab = xt_use_table_no_lock(self, db, name, FALSE, FALSE, NULL, NULL);
+			tab = xt_use_table_no_lock(self, db, name, FALSE, FALSE, NULL);
 			xt_heap_release(self, tab);
 		}
 	}
@@ -1556,7 +1591,7 @@
 			/* Same purpose as above {LOAD-FOR-FKS} (although this should work, 
 			 * beacuse this is a TRUNCATE TABLE.
 			 */
-			tab = xt_use_table_no_lock(self, db, name, FALSE, FALSE, NULL, NULL);
+			tab = xt_use_table_no_lock(self, db, name, FALSE, FALSE, NULL);
 			xt_heap_release(self, tab);
 		}
 		catch_(b) {
@@ -1599,7 +1634,7 @@
 	/* this code is not needed anymore as we open tables referred by FKs as necessary during checks
 	xt_ht_lock(self, db->db_tables);
 	pushr_(xt_ht_unlock, db->db_tables);
-	tab = xt_use_table_no_lock(self, db, name, FALSE, FALSE, NULL, NULL);
+	tab = xt_use_table_no_lock(self, db, name, FALSE, FALSE, NULL);
 	freer_(); // xt_ht_unlock(db->db_tables)
 	xt_heap_release(self, tab);
 	* CHANGED see {LOAD-FOR-FKS} above.
@@ -1619,7 +1654,7 @@
 	enter_();
 
 #ifdef TRACE_CREATE_TABLES
-	fprintf(stderr, "DROP %s\n", tab_name->ps_path);
+	printf("DROP %s\n", tab_name->ps_path);
 #endif
 
 	table_pool = tab_lock_table(self, tab_name, FALSE, TRUE, TRUE, &tab);
@@ -1775,9 +1810,10 @@
 	size_t					rec_size;
 	size_t					row_size;
 	u_llong					ext_data_len = 0;
+	u_llong					ext_rec_count = 0;
 
 #if defined(DUMP_CHECK_TABLE) || defined(CHECK_TABLE_STATS)
-	fprintf(stderr, "\nCHECK TABLE: %s\n", tab->tab_name->ps_path);
+	printf("\nCHECK TABLE: %s\n", tab->tab_name->ps_path);
 #endif
 
 	xt_lock_mutex(self, &tab->tab_db->db_co_ext_lock);
@@ -1787,38 +1823,38 @@
 	pushr_(xt_unlock_mutex, &tab->tab_rec_lock);
 
 #ifdef CHECK_TABLE_STATS
-	fprintf(stderr, "Record buffer size      = %lu\n", (u_long) tab->tab_dic.dic_mysql_buf_size);
-	fprintf(stderr, "Fixed length rec. len.  = %lu\n", (u_long) tab->tab_dic.dic_mysql_rec_size);
-	fprintf(stderr, "Handle data record size = %lu\n", (u_long) tab->tab_dic.dic_rec_size);
-	fprintf(stderr, "Min/max header size     = %d/%d\n", (int) offsetof(XTTabRecFix, rf_data), tab->tab_dic.dic_rec_fixed ? (int) offsetof(XTTabRecFix, rf_data) : (int) offsetof(XTTabRecExtDRec, re_data));
-	fprintf(stderr, "Min/avg/max record size = %llu/%llu/%llu\n", (u_llong) tab->tab_dic.dic_min_row_size, (u_llong) tab->tab_dic.dic_ave_row_size, (u_llong) tab->tab_dic.dic_max_row_size);
+	printf("Record buffer size      = %lu\n", (u_long) tab->tab_dic.dic_mysql_buf_size);
+	printf("Fixed length rec. len.  = %lu\n", (u_long) tab->tab_dic.dic_mysql_rec_size);
+	printf("Handle data record size = %lu\n", (u_long) tab->tab_dic.dic_rec_size);
+	printf("Min/max header size     = %d/%d\n", (int) offsetof(XTTabRecFix, rf_data), tab->tab_dic.dic_rec_fixed ? (int) offsetof(XTTabRecFix, rf_data) : (int) offsetof(XTTabRecExtDRec, re_data));
+	printf("Min/avg/max record size = %llu/%llu/%llu\n", (u_llong) tab->tab_dic.dic_min_row_size, (u_llong) tab->tab_dic.dic_ave_row_size, (u_llong) tab->tab_dic.dic_max_row_size);
 	if (tab->tab_dic.dic_def_ave_row_size)
-		fprintf(stderr, "Avg row len set for tab = %lu\n", (u_long) tab->tab_dic.dic_def_ave_row_size);
+		printf("Avg row len set for tab = %lu\n", (u_long) tab->tab_dic.dic_def_ave_row_size);
 	else
-		fprintf(stderr, "Avg row len set for tab = not specified\n");
-	fprintf(stderr, "Rows fixed length       = %s\n", tab->tab_dic.dic_rec_fixed ? "YES" : "NO");
+		printf("Avg row len set for tab = not specified\n");
+	printf("Rows fixed length       = %s\n", tab->tab_dic.dic_rec_fixed ? "YES" : "NO");
 	if (tab->tab_dic.dic_tab_flags & XT_TAB_FLAGS_TEMP_TAB)
-		fprintf(stderr, "Table type              = TEMP\n");
+		printf("Table type              = TEMP\n");
 	if (tab->tab_dic.dic_def_ave_row_size)
-		fprintf(stderr, "Maximum fixed size      = %lu\n", (u_long) XT_TAB_MAX_FIX_REC_LENGTH_SPEC);
+		printf("Maximum fixed size      = %lu\n", (u_long) XT_TAB_MAX_FIX_REC_LENGTH_SPEC);
 	else
-		fprintf(stderr, "Maximum fixed size      = %lu\n", (u_long) XT_TAB_MAX_FIX_REC_LENGTH);
-	fprintf(stderr, "Minimum variable size   = %lu\n", (u_long) XT_TAB_MIN_VAR_REC_LENGTH);
-	fprintf(stderr, "Minimum auto-increment  = %llu\n", (u_llong) tab->tab_dic.dic_min_auto_inc);
-	fprintf(stderr, "Number of columns       = %lu\n", (u_long) tab->tab_dic.dic_no_of_cols);
-	fprintf(stderr, "Number of fixed columns = %lu\n", (u_long) tab->tab_dic.dic_fix_col_count);
-	fprintf(stderr, "Columns req. for index  = %lu\n", (u_long) tab->tab_dic.dic_ind_cols_req);
+		printf("Maximum fixed size      = %lu\n", (u_long) XT_TAB_MAX_FIX_REC_LENGTH);
+	printf("Minimum variable size   = %lu\n", (u_long) XT_TAB_MIN_VAR_REC_LENGTH);
+	printf("Minimum auto-increment  = %llu\n", (u_llong) tab->tab_dic.dic_min_auto_inc);
+	printf("Number of columns       = %lu\n", (u_long) tab->tab_dic.dic_no_of_cols);
+	printf("Number of fixed columns = %lu\n", (u_long) tab->tab_dic.dic_fix_col_count);
+	printf("Columns req. for index  = %lu\n", (u_long) tab->tab_dic.dic_ind_cols_req);
 	if (tab->tab_dic.dic_ind_rec_len)
-		fprintf(stderr, "Rec len req. for index  = %llu\n", (u_llong) tab->tab_dic.dic_ind_rec_len);
-	fprintf(stderr, "Columns req. for blobs  = %lu\n", (u_long) tab->tab_dic.dic_blob_cols_req);
-	fprintf(stderr, "Number of blob columns  = %lu\n", (u_long) tab->tab_dic.dic_blob_count);
-	fprintf(stderr, "Number of indices       = %lu\n", (u_long) tab->tab_dic.dic_key_count);
+		printf("Rec len req. for index  = %llu\n", (u_llong) tab->tab_dic.dic_ind_rec_len);
+	printf("Columns req. for blobs  = %lu\n", (u_long) tab->tab_dic.dic_blob_cols_req);
+	printf("Number of blob columns  = %lu\n", (u_long) tab->tab_dic.dic_blob_count);
+	printf("Number of indices       = %lu\n", (u_long) tab->tab_dic.dic_key_count);
 #endif
 
 #ifdef DUMP_CHECK_TABLE
-	fprintf(stderr, "Records:-\n");
-	fprintf(stderr, "Free list: %llu (%llu)\n", (u_llong) tab->tab_rec_free_id, (u_llong) tab->tab_rec_fnum);
-	fprintf(stderr, "EOF:       %llu\n", (u_llong) tab->tab_rec_eof_id);
+	printf("Records:-\n");
+	printf("Free list: %llu (%llu)\n", (u_llong) tab->tab_rec_free_id, (u_llong) tab->tab_rec_fnum);
+	printf("EOF:       %llu\n", (u_llong) tab->tab_rec_eof_id);
 #endif
 
 	rec_size = XT_REC_EXT_HEADER_SIZE;
@@ -1830,24 +1866,24 @@
 			xt_throw(self);
 
 #ifdef DUMP_CHECK_TABLE
-		fprintf(stderr, "%-4llu ", (u_llong) rec_id);
+		printf("%-4llu ", (u_llong) rec_id);
 #endif
 		switch (rec_buf->tr_rec_type_1 & XT_TAB_STATUS_MASK) {
 			case XT_TAB_STATUS_FREED:
 #ifdef DUMP_CHECK_TABLE
-				fprintf(stderr, "======== ");
+				printf("======== ");
 #endif
 				free_rec_count++;
 				break;
 			case XT_TAB_STATUS_DELETE:
 #ifdef DUMP_CHECK_TABLE
-				fprintf(stderr, "delete   ");
+				printf("delete   ");
 #endif
 				delete_rec_count++;
 				break;
 			case XT_TAB_STATUS_FIXED:
 #ifdef DUMP_CHECK_TABLE
-				fprintf(stderr, "record-F ");
+				printf("record-F ");
 #endif
 				alloc_rec_count++;
 				row_size = myxt_store_row_length(ot, (char *) ot->ot_row_rbuffer + XT_REC_FIX_HEADER_SIZE);
@@ -1859,7 +1895,7 @@
 				break;
 			case XT_TAB_STATUS_VARIABLE:
 #ifdef DUMP_CHECK_TABLE
-				fprintf(stderr, "record-V ");
+				printf("record-V ");
 #endif
 				alloc_rec_count++;
 				row_size = myxt_load_row_length(ot, tab->tab_dic.dic_rec_size, ot->ot_row_rbuffer + XT_REC_FIX_HEADER_SIZE, NULL);
@@ -1871,9 +1907,10 @@
 				break;
 			case XT_TAB_STATUS_EXT_DLOG:
 #ifdef DUMP_CHECK_TABLE
-				fprintf(stderr, "record-X ");
+				printf("record-X ");
 #endif
 				alloc_rec_count++;
+				ext_rec_count++;
 				ext_data_len += XT_GET_DISK_4(rec_buf->re_log_dat_siz_4);
 				row_size = XT_GET_DISK_4(rec_buf->re_log_dat_siz_4) + ot->ot_rec_size - XT_REC_EXT_HEADER_SIZE;
 				alloc_rec_bytes += row_size;
@@ -1885,9 +1922,9 @@
 		}
 #ifdef DUMP_CHECK_TABLE
 		if (rec_buf->tr_rec_type_1 & XT_TAB_STATUS_CLEANED_BIT)
-			fprintf(stderr, "C");
+			printf("C");
 		else
-			fprintf(stderr, " ");
+			printf(" ");
 #endif
 		prev_rec_id = XT_GET_DISK_4(rec_buf->tr_prev_rec_id_4);
 		xn_id = XT_GET_DISK_4(rec_buf->tr_xact_id_4);
@@ -1895,14 +1932,15 @@
 		switch (rec_buf->tr_rec_type_1 & XT_TAB_STATUS_MASK) {
 			case XT_TAB_STATUS_FREED:
 #ifdef DUMP_CHECK_TABLE
-				fprintf(stderr, " prev=%-3llu (xact=%-3llu row=%lu)\n", (u_llong) prev_rec_id, (u_llong) xn_id, (u_long) row_id);
+				printf(" prev=%-3llu (xact=%-3llu row=%lu)\n", (u_llong) prev_rec_id, (u_llong) xn_id, (u_long) row_id);
 #endif
 				break;
 			case XT_TAB_STATUS_EXT_DLOG:
 #ifdef DUMP_CHECK_TABLE
-				fprintf(stderr, " prev=%-3llu  xact=%-3llu row=%lu  Xlog=%lu Xoff=%llu Xsiz=%lu\n", (u_llong) prev_rec_id, (u_llong) xn_id, (u_long) row_id, (u_long) XT_GET_DISK_2(rec_buf->re_log_id_2), (u_llong) XT_GET_DISK_6(rec_buf->re_log_offs_6), (u_long) XT_GET_DISK_4(rec_buf->re_log_dat_siz_4));
+				printf(" prev=%-3llu  xact=%-3llu row=%lu  Xlog=%lu Xoff=%llu Xsiz=%lu\n", (u_llong) prev_rec_id, (u_llong) xn_id, (u_long) row_id, (u_long) XT_GET_DISK_2(rec_buf->re_log_id_2), (u_llong) XT_GET_DISK_6(rec_buf->re_log_offs_6), (u_long) XT_GET_DISK_4(rec_buf->re_log_dat_siz_4));
 #endif
 
+#ifdef CHECK_TABLE_READ_DATA_LOG
 				log_size = XT_GET_DISK_4(rec_buf->re_log_dat_siz_4);
 				XT_GET_LOG_REF(log_id, log_offset, rec_buf);
 				if (!self->st_dlog_buf.dlb_read_log(log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data), (xtWord1 *) &ext_rec, self))
@@ -1919,10 +1957,11 @@
 						xt_logf(XT_INFO, "Table %s: record %llu, extended record %lu:%llu not valid\n", tab->tab_name, (u_llong) rec_id, (u_long) log_id, (u_llong) log_offset);
 					}
 				}
+#endif
 				break;
 			default:
 #ifdef DUMP_CHECK_TABLE
-				fprintf(stderr, " prev=%-3llu  xact=%-3llu row=%lu\n", (u_llong) prev_rec_id, (u_llong) xn_id, (u_long) row_id);
+				printf(" prev=%-3llu  xact=%-3llu row=%lu\n", (u_llong) prev_rec_id, (u_llong) xn_id, (u_long) row_id);
 #endif
 				break;
 		}
@@ -1930,17 +1969,19 @@
 	}
 	
 #ifdef CHECK_TABLE_STATS
-	if (!tab->tab_dic.dic_rec_fixed)
-		fprintf(stderr, "Extendend data length   = %llu\n", ext_data_len);
+	if (!tab->tab_dic.dic_rec_fixed) {
+		printf("Extended data length    = %llu\n", ext_data_len);
+		printf("Extended record count   = %llu\n", ext_rec_count);
+	}
 	
 	if (alloc_rec_count) {
-		fprintf(stderr, "Minumum comp. rec. len. = %llu\n", (u_llong) min_comp_rec_len);
-		fprintf(stderr, "Average comp. rec. len. = %llu\n", (u_llong) ((double) alloc_rec_bytes / (double) alloc_rec_count + (double) 0.5));
-		fprintf(stderr, "Maximum comp. rec. len. = %llu\n", (u_llong) max_comp_rec_len);
+		printf("Minumum comp. rec. len. = %llu\n", (u_llong) min_comp_rec_len);
+		printf("Average comp. rec. len. = %llu\n", (u_llong) ((double) alloc_rec_bytes / (double) alloc_rec_count + (double) 0.5));
+		printf("Maximum comp. rec. len. = %llu\n", (u_llong) max_comp_rec_len);
 	}
-	fprintf(stderr, "Free record count       = %llu\n", (u_llong) free_rec_count);
-	fprintf(stderr, "Deleted record count    = %llu\n", (u_llong) delete_rec_count);
-	fprintf(stderr, "Allocated record count  = %llu\n", (u_llong) alloc_rec_count);
+	printf("Free record count       = %llu\n", (u_llong) free_rec_count);
+	printf("Deleted record count    = %llu\n", (u_llong) delete_rec_count);
+	printf("Allocated record count  = %llu\n", (u_llong) alloc_rec_count);
 #endif
 	if (tab->tab_rec_fnum != free_rec_count)
 		xt_logf(XT_INFO, "Table %s: incorrect number of free blocks, %llu, should be: %llu\n", tab->tab_name, (u_llong) free_rec_count, (u_llong) tab->tab_rec_fnum);
@@ -1978,9 +2019,9 @@
 	pushr_(xt_unlock_mutex, &tab->tab_row_lock);
 
 #ifdef DUMP_CHECK_TABLE
-	fprintf(stderr, "Rows:-\n");
-	fprintf(stderr, "Free list: %llu (%llu)\n", (u_llong) tab->tab_row_free_id, (u_llong) tab->tab_row_fnum);
-	fprintf(stderr, "EOF:       %llu\n", (u_llong) tab->tab_row_eof_id);
+	printf("Rows:-\n");
+	printf("Free list: %llu (%llu)\n", (u_llong) tab->tab_row_free_id, (u_llong) tab->tab_row_fnum);
+	printf("EOF:       %llu\n", (u_llong) tab->tab_row_eof_id);
 #endif
 
 	rec_id = 1;
@@ -1988,13 +2029,13 @@
 		if (!tab->tab_rows.xt_tc_read_4(ot->ot_row_file, rec_id, &ref_id, self))
 			xt_throw(self);
 #ifdef DUMP_CHECK_TABLE
-		fprintf(stderr, "%-3llu ", (u_llong) rec_id);
+		printf("%-3llu ", (u_llong) rec_id);
 #endif
 #ifdef DUMP_CHECK_TABLE
 		if (ref_id == 0)
-			fprintf(stderr, "====== 0\n");
+			printf("====== 0\n");
 		else
-			fprintf(stderr, "in use %llu\n", (u_llong) ref_id);
+			printf("in use %llu\n", (u_llong) ref_id);
 #endif
 		rec_id++;
 	}
@@ -2026,7 +2067,7 @@
 	memset(&dic, 0, sizeof(dic));
 
 #ifdef TRACE_CREATE_TABLES
-	fprintf(stderr, "RENAME %s --> %s\n", old_name->ps_path, new_name->ps_path);
+	printf("RENAME %s --> %s\n", old_name->ps_path, new_name->ps_path);
 #endif
 	if (strlen(xt_last_name_of_path(new_name->ps_path)) > XT_TABLE_NAME_SIZE-1)
 		xt_throw_taberr(XT_CONTEXT, XT_ERR_NAME_TOO_LONG, new_name);
@@ -2100,7 +2141,7 @@
 	popr_(); // Discard tab_free_table_path(te_new_path);
 	popr_(); // Discard xt_free(te_new_name);
 
-	tab = xt_use_table_no_lock(self, db, new_name, FALSE, FALSE, &dic, NULL);
+	tab = xt_use_table_no_lock(self, db, new_name, FALSE, FALSE, &dic);
 	/* All renamed tables are considered repaired! */
 	xt_tab_table_repaired(tab);
 	xt_heap_release(self, tab);
@@ -2110,14 +2151,14 @@
 	freer_(); // xt_db_unlock_table_pool(table_pool)
 }
 
-xtPublic XTTableHPtr xt_use_table(XTThreadPtr self, XTPathStrPtr name, xtBool no_load, xtBool missing_ok, xtBool *opened)
+xtPublic XTTableHPtr xt_use_table(XTThreadPtr self, XTPathStrPtr name, xtBool no_load, xtBool missing_ok)
 {
 	XTTableHPtr		tab;
 	XTDatabaseHPtr	db = self->st_database;
 
 	xt_ht_lock(self, db->db_tables);
 	pushr_(xt_ht_unlock, db->db_tables);
-	tab = xt_use_table_no_lock(self, db, name, no_load, missing_ok, NULL, opened);
+	tab = xt_use_table_no_lock(self, db, name, no_load, missing_ok, NULL);
 	freer_();
 	return tab;
 }
@@ -2221,7 +2262,7 @@
 	xt_tab_store_header(ot, &rec_head);
 
 #ifdef TRACE_FLUSH
-	fprintf(stderr, "FLUSH rec/row %d %s\n", (int) tab->tab_bytes_to_flush, tab->tab_name->ps_path);
+	printf("FLUSH rec/row %d %s\n", (int) tab->tab_bytes_to_flush, tab->tab_name->ps_path);
 	fflush(stdout);
 #endif
 	/* Write the table header: */
@@ -2276,7 +2317,7 @@
 	xt_unlock_mutex_ns(&cp->cp_state_lock);
 
 #ifdef TRACE_FLUSH
-	fprintf(stderr, "FLUSH --end-- %s\n", tab->tab_name->ps_path);
+	printf("FLUSH --end-- %s\n", tab->tab_name->ps_path);
 	fflush(stdout);
 #endif
 	xt_unlock_mutex_ns(&tab->tab_rec_flush_lock);
@@ -2858,7 +2899,7 @@
 				/* This is a record written by this transaction. */
 				if (thread->st_is_update) {
 					/* Check that it was not written by the current update statement: */
-					if (XT_STAT_ID_MASK(thread->st_update_id) == rec_head->tr_stat_id_1) {
+					if (XT_STAT_ID_MASK(ot->ot_update_id) == rec_head->tr_stat_id_1) {
 #ifdef TRACE_VARIATIONS
 						if (len <= 450)
 							len += sprintf(t_buf+len, "MY UPDATE IN THIS STATEMENT T%d\n", (int) xn_id);
@@ -3139,7 +3180,7 @@
 		}
 		if (lw.lw_curr_lock != XT_NO_LOCK) {
 #ifdef TRACE_VARIATIONS
-			xt_ttracef(thread, "T%d WAIT FOR LOCK(%D) T%d\n", (int) thread->st_xact_data->xd_start_xn_id, (int) lock_type, (int) xn_id);
+			xt_ttracef(thread, "T%d WAIT FOR LOCK(%s) T%d\n", (int) thread->st_xact_data->xd_start_xn_id, (int) lw.lw_curr_lock == XT_TEMP_LOCK ? "temp" : "perm", (int) xn_id);
 #endif
 			if (!xt_xn_wait_for_xact(thread, NULL, &lw)) {
 #ifdef DEBUG_LOCK_QUEUE
@@ -3950,6 +3991,21 @@
 	tab_restore_exception(&e);
 }
 
+static xtBool tab_write_ext_record(XTOpenTablePtr ot, XTTabRecInfoPtr rec_info, xtTableID tab_id, 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_id);
+	XT_SET_DISK_4(rec_info->ri_log_buf->er_rec_id_4, rec_id);
+	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;
@@ -4007,26 +4063,19 @@
 		 */
 		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, 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, 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 (!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: */
+		if (!tab_write_ext_record(ot, rec_info, tab->tab_id, 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));
@@ -4062,8 +4111,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);
@@ -4369,7 +4421,7 @@
 	if (!(row_id = tab_new_row(ot, tab)))
 		goto failed_0;
 
-	rec_info.ri_fix_rec_buf->tr_stat_id_1 = self->st_update_id;
+	rec_info.ri_fix_rec_buf->tr_stat_id_1 = ot->ot_update_id;
 	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, 0);
 	XT_SET_DISK_4(rec_info.ri_fix_rec_buf->tr_xact_id_4, self->st_xact_data->xd_start_xn_id);
@@ -4458,7 +4510,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;
 	}
@@ -4471,7 +4523,7 @@
 
 	if (rec_info->ri_ext_rec) {
 		/* Determine where the overflow will go... */
-		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);
 	}
@@ -4481,11 +4533,7 @@
 
 	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 (!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))
+		if (!tab_write_ext_record(ot, rec_info, tab->tab_id, rec_id, log_id, log_offset, thread))
 			return FAILED;
 	}
 
@@ -4529,12 +4577,12 @@
 
 	if (rec_info.ri_ext_rec) {
 		/* Determine where the overflow will go... */
-		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);
 	}
 
-	rec_info.ri_fix_rec_buf->tr_stat_id_1 = self->st_update_id;
+	rec_info.ri_fix_rec_buf->tr_stat_id_1 = ot->ot_update_id;
 	XT_SET_DISK_4(rec_info.ri_fix_rec_buf->tr_row_id_4, row_id);
 	XT_COPY_DISK_4(rec_info.ri_fix_rec_buf->tr_prev_rec_id_4, prev_rec_head.tr_prev_rec_id_4);
 	XT_SET_DISK_4(rec_info.ri_fix_rec_buf->tr_xact_id_4, self->st_xact_data->xd_start_xn_id);
@@ -4555,11 +4603,7 @@
 
 	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 (!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))
+		if (!tab_write_ext_record(ot, &rec_info, tab->tab_id, rec_id, log_id, log_offset, self))
 			goto failed_1;
 	}
 
@@ -4678,7 +4722,7 @@
 	if (!myxt_store_row(ot, &rec_info, (char *) after_buf))
 		goto failed_0;
 
-	rec_info.ri_fix_rec_buf->tr_stat_id_1 = self->st_update_id;
+	rec_info.ri_fix_rec_buf->tr_stat_id_1 = ot->ot_update_id;
 	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, self->st_xact_data->xd_start_xn_id);
@@ -4688,7 +4732,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;
@@ -4714,7 +4758,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++) {
@@ -4729,7 +4773,7 @@
 			goto failed_2;
 	}
 
-	ot->ot_thread->st_statistics.st_row_update++;
+	self->st_statistics.st_row_update++;
 	return OK;
 
 	failed_2:
@@ -4737,7 +4781,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;

=== modified file 'storage/pbxt/src/table_xt.h'
--- storage/pbxt/src/table_xt.h	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/table_xt.h	2010-05-07 08:52:27 +0000
@@ -364,6 +364,9 @@
 	xtWord4					tab_rec_fnum;							/* The count of the number of free rows on the free list. */
 	xt_mutex_type			tab_rec_lock;							/* Lock for the free list. */
 
+	xt_mutex_type			tab_ind_stat_lock;						/* Aquired when calculating index statistics. */
+	time_t					tab_ind_stat_calc_time;					/* Zero means the index stats have not be calculated, otherwize this is a time. */
+
 	xt_mutex_type			tab_ind_flush_lock;						/* Required while the index file is being flushed. */
 	xtLogID					tab_ind_rec_log_id;						/* The point before which index entries have been written. */
 	xtLogOffset				tab_ind_rec_log_offset;					/* The log offset of the write point. */
@@ -372,7 +375,7 @@
 	xtIndexNodeID			tab_ind_free;							/* The start of the free page list of the index. */
 	XTIndFreeListPtr		tab_ind_free_list;						/* A cache of the free list (if exists, don't go to disk!) */
 	xt_mutex_type			tab_ind_lock;							/* Lock for reading and writing the index free list. */
-	xtWord2					tab_ind_flush_seq;
+	xtWord4					tab_ind_flush_seq;
 } XTTableHRec, *XTTableHPtr;		/* Heap pointer */
 
 /* Used for an in-memory list of the tables, ordered by ID. */
@@ -403,6 +406,8 @@
 	size_t					ot_rec_size;							/* Cached from table for quick access. */
 	
 	char					ot_error_key[XT_IDENTIFIER_NAME_SIZE];
+	struct XTOpenTable		*ot_prev_update;						/* The UPDATE statement stack! {UPDATE-STACK} */
+	u_int					ot_update_id;							/* The update statement ID. */	
 	xtBool					ot_for_update;							/* True if reading FOR UPDATE. */
 	xtBool					ot_is_modify;							/* True if UPDATE or DELETE. */
 	xtRowID					ot_temp_row_lock;						/* The temporary row lock set on this table. */
@@ -507,11 +512,11 @@
 char				*xt_tab_file_to_name(size_t size, char *tab_name, char *file_name);
 
 void				xt_create_table(struct XTThread *self, XTPathStrPtr name, XTDictionaryPtr dic);
-XTTableHPtr			xt_use_table(struct XTThread *self, XTPathStrPtr name, xtBool no_load, xtBool missing_ok, xtBool *opened);
+XTTableHPtr			xt_use_table(struct XTThread *self, XTPathStrPtr name, xtBool no_load, xtBool missing_ok);
 void				xt_sync_flush_table(struct XTThread *self, XTOpenTablePtr ot);
 xtBool				xt_flush_record_row(XTOpenTablePtr ot, off_t *bytes_flushed, xtBool have_table_loc);
 void				xt_flush_table(struct XTThread *self, XTOpenTablePtr ot);
-XTTableHPtr			xt_use_table_no_lock(XTThreadPtr self, struct XTDatabase *db, XTPathStrPtr name, xtBool no_load, xtBool missing_ok, XTDictionaryPtr dic, xtBool *opened);
+XTTableHPtr			xt_use_table_no_lock(XTThreadPtr self, struct XTDatabase *db, XTPathStrPtr name, xtBool no_load, xtBool missing_ok, XTDictionaryPtr dic);
 int					xt_use_table_by_id(struct XTThread *self, XTTableHPtr *tab, struct XTDatabase *db, xtTableID tab_id);
 XTOpenTablePtr		xt_open_table(XTTableHPtr tab);
 void				xt_close_table(XTOpenTablePtr ot, xtBool flush, xtBool have_table_lock);

=== modified file 'storage/pbxt/src/thread_xt.cc'
--- storage/pbxt/src/thread_xt.cc	2010-01-06 21:27:53 +0000
+++ storage/pbxt/src/thread_xt.cc	2010-05-07 08:52:27 +0000
@@ -96,7 +96,7 @@
 {
 	int err;
 
-	log_file = stderr;
+	log_file = stdout;
 	log_level = XT_LOG_TRACE;
 	err = xt_p_mutex_init_with_autoname(&log_mutex, NULL);
 	if (err) {
@@ -413,7 +413,8 @@
 	vsnprintf(e->e_err_msg, XT_ERR_MSG_SIZE, fmt, ap);
 
 	/* Make the first character of the message upper case: */
-	if (isalpha(e->e_err_msg[0]) && islower(e->e_err_msg[0]))
+	/* This did not work for foreign languages! */
+	if (e->e_err_msg[0] >= 'a' && e->e_err_msg[0] <= 'z')
 		e->e_err_msg[0] = (char) toupper(e->e_err_msg[0]);
 
 	if (func && *func && *func != '-')
@@ -793,11 +794,9 @@
 
 	xt_2nd_last_name_of_path(sizeof(buffer), buffer, tab_item->ps_path);
 	xt_strcat(sizeof(buffer), buffer, ".");
-	xt_strcpy(sizeof(buffer), buffer, xt_last_name_of_path(tab_item->ps_path));
-	xt_strcat(sizeof(buffer), buffer, ".");
-	xt_strcat(sizeof(buffer), buffer, item2);
+	xt_strcat(sizeof(buffer), buffer, xt_last_name_of_path(tab_item->ps_path));
 
-	xt_register_ixterr(func, file, line, xt_err, buffer);
+	xt_register_i2xterr(func, file, line, xt_err, buffer, item2);
 }
 
 xtPublic void xt_register_taberr(c_char *func, c_char *file, u_int line, int xt_err, XTPathStrPtr tab_item)
@@ -806,7 +805,7 @@
 
 	xt_2nd_last_name_of_path(sizeof(buffer), buffer, tab_item->ps_path);
 	xt_strcat(sizeof(buffer), buffer, ".");
-	xt_strcpy(sizeof(buffer), buffer, xt_last_name_of_path(tab_item->ps_path));
+	xt_strcat(sizeof(buffer), buffer, xt_last_name_of_path(tab_item->ps_path));
 
 	xt_register_ixterr(func, file, line, xt_err, buffer);
 }
@@ -1013,7 +1012,7 @@
 
 typedef void *(*ThreadMainFunc)(XTThreadPtr self);
 
-extern "C" void *thr_main_pbxt(void *data)
+extern "C" void *xt_thread_main(void *data)
 {
 	ThreadDataPtr	td = (ThreadDataPtr) data;
 	XTThreadPtr		self = td->td_thr;
@@ -1168,6 +1167,14 @@
 	/* Align the number of threads: */
 	xt_thr_maximum_threads = xt_align_size(max_threads, XT_XS_LOCK_ALIGN);
 
+#ifdef XT_TRACK_CONNECTIONS
+	if (xt_thr_maximum_threads > XT_TRACK_MAX_CONNS) {
+		xt_log_error(XT_NS_CONTEXT, XT_LOG_FATAL, XT_ERR_TOO_MANY_THREADS, 0, 
+			"XT_TRACK_CONNECTIONS is enabled and xt_thr_maximum_threads > XT_TRACK_MAX_CONNS");
+		goto failed;
+	}
+#endif
+
 #ifdef HANDLE_SIGNALS
 	if (!thr_setup_signals())
 		return NULL;
@@ -1503,10 +1510,10 @@
 		pthread_attr_t	attr = { 0, 0, 0 };
 
 		attr.priority = THREAD_PRIORITY_NORMAL;
-		err = pthread_create(&child_thread, &attr, thr_main_pbxt, &data);
+		err = pthread_create(&child_thread, &attr, xt_thread_main, &data);
 	}
 #else
-	err = pthread_create(&child_thread, NULL, thr_main_pbxt, &data);
+	err = pthread_create(&child_thread, NULL, xt_thread_main, &data);
 #endif
 	if (err) {
 		xt_free_thread(child);

=== modified file 'storage/pbxt/src/thread_xt.h'
--- storage/pbxt/src/thread_xt.h	2010-01-06 21:27:53 +0000
+++ storage/pbxt/src/thread_xt.h	2010-05-07 08:52:27 +0000
@@ -132,6 +132,7 @@
 struct XTXactLog;
 struct XTXactData;
 struct XTDatabase;
+struct XTOpenTable;
 
 typedef void (*XTThreadFreeFunc)(struct XTThread *self, void *data);
 
@@ -307,8 +308,7 @@
 	xtThreadID				*st_thread_list;
 
 	/* Used to prevent a record from being updated twice in one statement. */
-	xtBool					st_is_update;					/* TRUE if this is an UPDATE statement. */
-	u_int					st_update_id;					/* The update statement ID. */
+	struct XTOpenTable		*st_is_update;					/* TRUE if this is an UPDATE statement.  {UPDATE-STACK} */
 
 	XTRowLockListRec		st_lock_list;					/* The thread row lock list (drop locks on transaction end). */
 	XTStatisticsRec			st_statistics;					/* Accumulated statistics for this thread. */
@@ -536,7 +536,10 @@
  * Function prototypes
  */
 
-extern "C" void *thr_main_pbxt(void *data);
+/* OpenSolaris has thr_main in /usr/include/thread.h (name conflict)
+ * Thanks for the tip Monty!
+ */
+extern "C" void *xt_thread_main(void *data);
 
 void			xt_get_now(char *buffer, size_t len);
 xtBool			xt_init_logging(void);

=== modified file 'storage/pbxt/src/trace_xt.cc'
--- storage/pbxt/src/trace_xt.cc	2009-12-22 10:33:20 +0000
+++ storage/pbxt/src/trace_xt.cc	2010-05-07 08:52:27 +0000
@@ -36,6 +36,7 @@
 #ifdef DEBUG
 //#define PRINT_TRACE
 //#define RESET_AFTER_DUMP
+//#define DUMP_TO_STDOUT
 #endif
 
 static xtBool			trace_initialized = FALSE;
@@ -109,10 +110,10 @@
 		xt_lock_mutex_ns(&trace_mutex);
 		if (trace_log_end > trace_log_offset+1) {
 			trace_log_buffer[trace_log_end] = 0;
-			fprintf(stderr, "%s", trace_log_buffer + trace_log_offset + 1);
+			printf("%s", trace_log_buffer + trace_log_offset + 1);
 		}
 		trace_log_buffer[trace_log_offset] = 0;
-		fprintf(stderr, "%s", trace_log_buffer);
+		printf("%s", trace_log_buffer);
 		trace_log_offset = 0;
 		trace_log_end = 0;
 		xt_unlock_mutex_ns(&trace_mutex);
@@ -121,9 +122,18 @@
 
 xtPublic void xt_dump_trace(void)
 {
-	FILE *fp;
+	if (trace_log_offset) {
+#ifdef DUMP_TO_STDOUT
+		if (trace_log_end > trace_log_offset+1) {
+			trace_log_buffer[trace_log_end] = 0;
+			printf("%s", trace_log_buffer + trace_log_offset + 1);
+		}
+		trace_log_buffer[trace_log_offset] = 0;
+		printf("%s", trace_log_buffer);
+		printf("\n");
+#else
+		FILE *fp;
 
-	if (trace_log_offset) {
 		fp = fopen("pbxt.log", "w");
 
 		xt_lock_mutex_ns(&trace_mutex);
@@ -136,6 +146,7 @@
 			fprintf(fp, "%s", trace_log_buffer);
 			fclose(fp);
 		}
+#endif
 
 #ifdef RESET_AFTER_DUMP
 		trace_log_offset = 0;
@@ -379,9 +390,9 @@
 	ptr = conn_info;
 	for (int i=0; i<XT_TRACK_MAX_CONNS; i++) {
 		if (ptr->ci_curr_xact_id || ptr->ci_prev_xact_id) {
-			fprintf(stderr, "%3d curr=%d prev=%d prev-time=%ld\n", (int) ptr->cu_t_id, (int) ptr->ci_curr_xact_id, (int) ptr->ci_prev_xact_id, (long) ptr->ci_prev_xact_time);
+			printf("%3d curr=%d prev=%d prev-time=%ld\n", (int) ptr->cu_t_id, (int) ptr->ci_curr_xact_id, (int) ptr->ci_prev_xact_id, (long) ptr->ci_prev_xact_time);
 			if (i+1<XT_TRACK_MAX_CONNS) {
-				fprintf(stderr, "    diff=%d\n", (int) (ptr+1)->ci_curr_xact_id - (int) ptr->ci_curr_xact_id);
+				printf("    diff=%d\n", (int) (ptr+1)->ci_curr_xact_id - (int) ptr->ci_curr_xact_id);
 			}
 		}
 		ptr++;

=== modified file 'storage/pbxt/src/trace_xt.h'
--- storage/pbxt/src/trace_xt.h	2009-08-17 11:12:36 +0000
+++ storage/pbxt/src/trace_xt.h	2010-05-07 08:52:27 +0000
@@ -51,7 +51,9 @@
  * CONNECTION TRACKING
  */
 
+#ifdef DEBUG
 #define XT_TRACK_CONNECTIONS
+#endif
 
 #ifdef XT_TRACK_CONNECTIONS
 #define XT_TRACK_MAX_CONNS		500

=== modified file 'storage/pbxt/src/xaction_xt.cc'
--- storage/pbxt/src/xaction_xt.cc	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/xaction_xt.cc	2010-05-07 08:52:27 +0000
@@ -1326,7 +1326,7 @@
 			}
 
 			/* Write and flush the transaction log: */
-			if (!xt_xlog_log_data(thread, sizeof(XTXactEndEntryDRec), (XTXactLogBufferDPtr) &entry, TRUE)) {
+			if (!xt_xlog_log_data(thread, sizeof(XTXactEndEntryDRec), (XTXactLogBufferDPtr) &entry, xt_db_flush_log_at_trx_commit)) {
 				ok = FALSE;
 				status = XT_LOG_ENT_ABORT;
 				/* Make sure this is done, if we failed to log
@@ -1440,16 +1440,23 @@
 		/* 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)) {
-				xt_critical_wait();
+			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;
+					xt_critical_wait();
+				}
 			}
 #else
 			if ((db->db_sw_faster & XT_SW_TOO_FAR_BEHIND) != 0) {
@@ -1486,7 +1493,7 @@
 	entry.xt_status_1 = XT_LOG_ENT_NEW_TAB;
 	entry.xt_checksum_1 = XT_CHECKSUM_1(tab_id);
 	XT_SET_DISK_4(entry.xt_tab_id_4, tab_id);
-	return xt_xlog_log_data(self, sizeof(XTXactNewTabEntryDRec), (XTXactLogBufferDPtr) &entry, TRUE);
+	return xt_xlog_log_data(self, sizeof(XTXactNewTabEntryDRec), (XTXactLogBufferDPtr) &entry, XT_XLOG_WRITE_AND_FLUSH);
 }
 
 xtPublic int xt_xn_status(XTOpenTablePtr ot, xtXactID xn_id, xtRecordID XT_UNUSED(rec_id))
@@ -2266,6 +2273,7 @@
 				xt_log_and_clear_exception(self);
 				break;
 			}
+			
 			prev_rec_id = next_rec_id;
 			next_rec_id = XT_GET_DISK_4(prev_rec_head.tr_prev_rec_id_4);
 		}
@@ -2461,7 +2469,7 @@
 	cu.xc_checksum_1 = XT_CHECKSUM_1(XT_CHECKSUM4_XACT(xact->xd_start_xn_id));
 	XT_SET_DISK_4(cu.xc_xact_id_4, xact->xd_start_xn_id);
 
-	if (!xt_xlog_log_data(self, sizeof(XTXactCleanupEntryDRec), (XTXactLogBufferDPtr) &cu, FALSE))
+	if (!xt_xlog_log_data(self, sizeof(XTXactCleanupEntryDRec), (XTXactLogBufferDPtr) &cu, XT_XLOG_NO_WRITE_NO_FLUSH))
 		return FAILED;
 
 	ss->ss_flush_pending = TRUE;
@@ -2656,7 +2664,9 @@
 				 * we flush the log.
 				 */
 				if (now >= idle_start + 2) {
-					if (!xt_xlog_flush_log(db, self))
+					/* Don't do this if flusher is active! */
+					if (!db->db_fl_thread &&
+						!xt_xlog_flush_log(db, self))
 						xt_throw(self);
 					ss->ss_flush_pending = FALSE;
 				}

=== modified file 'storage/pbxt/src/xaction_xt.h'
--- storage/pbxt/src/xaction_xt.h	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/xaction_xt.h	2010-05-07 08:52:27 +0000
@@ -153,14 +153,14 @@
 #define XT_XACT_INIT_LOCK(s, i)			xt_spinxslock_init_with_autoname(s, i)
 #define XT_XACT_FREE_LOCK(s, i)			xt_spinxslock_free(s, i)	
 #define XT_XACT_READ_LOCK(i, s)			xt_spinxslock_slock(i)
-#define XT_XACT_WRITE_LOCK(i, s)		xt_spinxslock_xlock(i, (s)->t_id)
+#define XT_XACT_WRITE_LOCK(i, s)		xt_spinxslock_xlock(i, FALSE, (s)->t_id)
 #define XT_XACT_UNLOCK(i, s, b)			xt_spinxslock_unlock(i, b)
 #else
 #define XT_XACT_LOCK_TYPE				XTSkewRWLockRec
 #define XT_XACT_INIT_LOCK(s, i)			xt_skewrwlock_init_with_autoname(s, i)
 #define XT_XACT_FREE_LOCK(s, i)			xt_skewrwlock_free(s, i)	
 #define XT_XACT_READ_LOCK(i, s)			xt_skewrwlock_slock(i)
-#define XT_XACT_WRITE_LOCK(i, s)		xt_skewrwlock_xlock(i, (s)->t_id)
+#define XT_XACT_WRITE_LOCK(i, s)		xt_skewrwlock_xlock(i, FALSE, (s)->t_id)
 #define XT_XACT_UNLOCK(i, s, b)			xt_skewrwlock_unlock(i, b)
 #endif
 

=== modified file 'storage/pbxt/src/xactlog_xt.cc'
--- storage/pbxt/src/xactlog_xt.cc	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/xactlog_xt.cc	2010-05-07 08:52:27 +0000
@@ -719,14 +719,14 @@
 	}
 }
 
-#define WR_NO_SPACE		1
-#define WR_FLUSH		2
+#define WR_NO_SPACE		1			/* Write because there is no space, or some other reason */
+#define WR_FLUSH		2			/* Normal commit, write and flush */
 
 xtBool XTDatabaseLog::xlog_flush(XTThreadPtr thread)
 {
 	if (!xlog_flush_pending())
 		return OK;
-	return xlog_append(thread, 0, NULL, 0, NULL, TRUE, NULL, NULL);
+	return xlog_append(thread, 0, NULL, 0, NULL, XT_XLOG_WRITE_AND_FLUSH, NULL, NULL);
 }
 
 xtBool XTDatabaseLog::xlog_flush_pending()
@@ -754,7 +754,7 @@
  * This function returns the log ID and offset of
  * the data write position.
  */
-xtBool XTDatabaseLog::xlog_append(XTThreadPtr thread, size_t size1, xtWord1 *data1, size_t size2, xtWord1 *data2, xtBool commit, xtLogID *log_id, xtLogOffset *log_offset)
+xtBool XTDatabaseLog::xlog_append(XTThreadPtr thread, size_t size1, xtWord1 *data1, size_t size2, xtWord1 *data2, int flush_log_at_trx_commit, xtLogID *log_id, xtLogOffset *log_offset)
 {
 	int			write_reason = 0;
 	xtLogID		req_flush_log_id;
@@ -763,19 +763,20 @@
 	xtWord8		flush_time;
 	xtWord2		sum;
 
+	/* The first size value must be set, of the second is set! */
+	ASSERT_NS(size1 || !size2);
+
 	if (!size1) {
 		/* Just flush the buffer... */
 		xt_lck_slock(&xl_buffer_lock);
-		write_reason = WR_FLUSH;
+		write_reason = flush_log_at_trx_commit == XT_XLOG_WRITE_AND_FLUSH ? WR_FLUSH : WR_NO_SPACE;
 		req_flush_log_id = xl_append_log_id;
 		req_flush_log_offset = xl_append_log_offset + xl_append_buf_pos;
 		xt_spinlock_unlock(&xl_buffer_lock);
 		goto write_log_to_file;
 	}
-	else {
-		req_flush_log_id = 0;
-		req_flush_log_offset = 0;
-	}
+	req_flush_log_id = 0;
+	req_flush_log_offset = 0;
 
 	/*
 	 * This is a dirty read, which will send us to the
@@ -866,11 +867,17 @@
 					return OK;
 				}
 			}
-			else {
+			else if (size1) {
 				/* It may be that there is now space in the append buffer: */
 				if (xl_append_buf_pos + size1 + size2 <= xl_size_of_buffers)
 					goto copy_to_log_buffer;
 			}
+			else {
+				/* We are just writing the buffer! */
+				ASSERT_NS(write_reason == WR_NO_SPACE);
+				if (xt_comp_log_pos(req_flush_log_id, req_flush_log_offset, xl_write_log_id, xl_write_log_offset + (xl_write_done ? xl_write_buf_pos : xl_write_buf_pos_start)) <= 0)
+					return OK;
+			}
 
 			if (xt_trace_clock() >= then) {
 				xt_lock_mutex_ns(&xl_write_lock);
@@ -922,12 +929,18 @@
 					ASSERT_NS(xt_comp_log_pos(xl_write_log_id, xl_write_log_offset, xl_append_log_id, xl_append_log_offset) <= 0);
 					return OK;
 				}
-				goto write_log_to_file;
-			}
-
-			/* It may be that there is now space in the append buffer: */
-			if (xl_append_buf_pos + size1 + size2 <= xl_size_of_buffers)
-				goto copy_to_log_buffer;
+			}
+			else if (size1) {
+				/* It may be that there is now space in the append buffer: */
+				if (xl_append_buf_pos + size1 + size2 <= xl_size_of_buffers)
+					goto copy_to_log_buffer;
+			}
+			else {
+				/* We are just writing the buffer! */
+				ASSERT_NS(write_reason == WR_NO_SPACE);
+				if (xt_comp_log_pos(req_flush_log_id, req_flush_log_offset, xl_write_log_id, xl_write_log_offset + (xl_write_done ? xl_write_buf_pos : xl_write_buf_pos_start)) <= 0)
+					return OK;
+			}
 				
 			goto write_log_to_file;
 		}
@@ -952,7 +965,7 @@
 				return OK;
 			}
 			/* Not flushed, but what about written? */
-			if (xt_comp_log_pos(req_flush_log_id, req_flush_log_offset, xl_write_log_id, xl_write_log_offset + (xl_write_done ? xl_write_buf_pos : 0)) <= 0) {
+			if (xt_comp_log_pos(req_flush_log_id, req_flush_log_offset, xl_write_log_id, xl_write_log_offset + (xl_write_done ? xl_write_buf_pos : xl_write_buf_pos_start)) <= 0) {
 				/* The write position is after or equal to the required flush
 				 * position. This means that all we have to do is flush
 				 * to satisfy the writers condition.
@@ -960,7 +973,7 @@
 				xtBool ok = TRUE;
 
 				if (xl_log_id != xl_write_log_id)
-					ok = xlog_open_log(xl_write_log_id, xl_write_log_offset + (xl_write_done ? xl_write_buf_pos : 0), thread);
+					ok = xlog_open_log(xl_write_log_id, xl_write_log_offset + (xl_write_done ? xl_write_buf_pos : xl_write_buf_pos_start), thread);
 
 				if (ok) {
 					if (xl_db->db_co_busy) {
@@ -979,7 +992,7 @@
 
 						xt_lock_mutex_ns(&xl_db->db_wr_lock);
 						xl_flush_log_id = xl_write_log_id;
-						xl_flush_log_offset = xl_write_log_offset + (xl_write_done ? xl_write_buf_pos : 0);
+						xl_flush_log_offset = xl_write_log_offset + (xl_write_done ? xl_write_buf_pos : xl_write_buf_pos_start);
 						/*
 						 * We have written data to the log, wake the writer to commit
 						* the data to the database.
@@ -1000,8 +1013,11 @@
 				return ok;
 			}
 		}
-		else {
-			/* If there is space in the buffer, then we can go on
+		else if (size1) {
+			/* If the amounf of data to be written is 0, then we are just required
+			 * to write the transaction buffer.
+			 *
+			 * If there is space in the buffer, then we can go on
 			 * to copy our data into the buffer:
 			 */
 			if (xl_append_buf_pos + size1 + size2 <= xl_size_of_buffers) {
@@ -1016,6 +1032,21 @@
 				goto copy_to_log_buffer;
 			}
 		}
+		else {
+			/* We are just writing the buffer! */
+			ASSERT_NS(write_reason == WR_NO_SPACE);
+			if (xt_comp_log_pos(req_flush_log_id, req_flush_log_offset, xl_write_log_id, xl_write_log_offset + (xl_write_done ? xl_write_buf_pos : xl_write_buf_pos_start)) <= 0) {
+#ifdef XT_XLOG_WAIT_SPINS
+				xt_writing = 0;
+				if (xt_waiting)
+					xt_cond_wakeall(&xl_write_cond);
+#else
+				xt_writing = FALSE;
+				xt_cond_wakeall(&xl_write_cond);
+#endif
+				return OK;
+			}
+		}
 
 		rewrite:
 		/* If the current write buffer has been written, then
@@ -1109,7 +1140,8 @@
 			part_size = 512 - part_size;
 			xl_write_buffer[xl_write_buf_pos] = XT_LOG_ENT_END_OF_LOG;
 #ifdef HAVE_valgrind
-			memset(xl_write_buffer + xl_write_buf_pos + 1, 0x66, part_size);
+			if (part_size > 1)
+				memset(xl_write_buffer + xl_write_buf_pos + 1, 0x66, part_size - 1);
 #endif
 			if (!xt_pwrite_file(xl_log_file, xl_write_log_offset, xl_write_buf_pos+part_size, xl_write_buffer, &thread->st_statistics.st_xlog, thread))
 				goto write_failed;			
@@ -1197,9 +1229,13 @@
 		xt_writing = FALSE;
 		xt_cond_wakeall(&xl_write_cond);
 #endif
+
+		if (size1 == 0)
+			return OK;
 	}
 
 	copy_to_log_buffer:
+	ASSERT_NS(size1);
 	xt_spinlock_lock(&xl_buffer_lock);
 	/* Now we have to check again. The check above was a dirty read!
 	 */
@@ -1291,11 +1327,14 @@
 	if (log_offset)
 		*log_offset = xl_append_log_offset + xl_append_buf_pos;
 	xl_append_buf_pos += size1 + size2;
-	if (commit) {
-		write_reason = WR_FLUSH;
+	if (flush_log_at_trx_commit != XT_XLOG_NO_WRITE_NO_FLUSH) {
+		write_reason = flush_log_at_trx_commit == XT_XLOG_WRITE_AND_FLUSH ? WR_FLUSH : WR_NO_SPACE;
 		req_flush_log_id = xl_append_log_id;
 		req_flush_log_offset = xl_append_log_offset + xl_append_buf_pos;
 		xt_spinlock_unlock(&xl_buffer_lock);
+		/* We have written the data already! */
+		size1 = 0;
+		size2 = 0;
 		goto write_log_to_file;
 	}
 
@@ -1485,9 +1524,9 @@
 	return db->db_xlog.xlog_flush(thread);
 }
 
-xtPublic xtBool xt_xlog_log_data(XTThreadPtr thread, size_t size, XTXactLogBufferDPtr log_entry, xtBool commit)
+xtPublic xtBool xt_xlog_log_data(XTThreadPtr thread, size_t size, XTXactLogBufferDPtr log_entry, int flush_log_at_trx_commit)
 {
-	return thread->st_database->db_xlog.xlog_append(thread, size, (xtWord1 *) log_entry, 0, NULL, commit, NULL, NULL);
+	return thread->st_database->db_xlog.xlog_append(thread, size, (xtWord1 *) log_entry, 0, NULL, flush_log_at_trx_commit, NULL, NULL);
 }
 
 /* Allocate a record from the free list. */
@@ -1498,7 +1537,7 @@
 	xtWord4				sum = 0;
 	int					check_size = 1;
 	XTXactDataPtr		xact = NULL;
-	xtBool				commit = FALSE;
+	int					flush_log_at_trx_commit = XT_XLOG_NO_WRITE_NO_FLUSH;
 
 	switch (status) {
 		case XT_LOG_ENT_REC_MODIFIED:
@@ -1613,7 +1652,7 @@
 			XT_SET_DISK_4(log_entry.xp.xp_xact_id_4, op_seq);
 			log_entry.xp.xp_xa_len_1 = (xtWord1) size;
 			len = offsetof(XTXactPrepareEntryDRec, xp_xa_data);
-			commit = TRUE;
+			flush_log_at_trx_commit = xt_db_flush_log_at_trx_commit;
 			break;
 		default:
 			ASSERT_NS(FALSE);
@@ -1652,9 +1691,9 @@
 	xt_print_log_record(0, 0, &log_entry);
 #endif
 	if (xact)
-		return thread->st_database->db_xlog.xlog_append(thread, len, (xtWord1 *) &log_entry, size, data, commit, &xact->xd_begin_log, &xact->xd_begin_offset);
+		return thread->st_database->db_xlog.xlog_append(thread, len, (xtWord1 *) &log_entry, size, data, flush_log_at_trx_commit, &xact->xd_begin_log, &xact->xd_begin_offset);
 
-	return thread->st_database->db_xlog.xlog_append(thread, len, (xtWord1 *) &log_entry, size, data, commit, NULL, NULL);
+	return thread->st_database->db_xlog.xlog_append(thread, len, (xtWord1 *) &log_entry, size, data, flush_log_at_trx_commit, NULL, NULL);
 }
 
 /*

=== modified file 'storage/pbxt/src/xactlog_xt.h'
--- storage/pbxt/src/xactlog_xt.h	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/xactlog_xt.h	2010-05-07 08:52:27 +0000
@@ -75,6 +75,10 @@
 #define XT_DELETE_LOGS				1
 #define XT_KEEP_LOGS				2
 
+#define XT_XLOG_NO_WRITE_NO_FLUSH	0
+#define XT_XLOG_WRITE_AND_FLUSH		1
+#define XT_XLOG_WRITE_AND_NO_FLUSH	2
+
 /* LOG CACHE ---------------------------------------------------- */
 
 typedef struct XTXLogBlock {
@@ -443,7 +447,7 @@
 	void					xlog_name(size_t size, char *path, xtLogID log_id);
 	int						xlog_delete_log(xtLogID del_log_id, struct XTThread *thread);
 
-	xtBool					xlog_append(struct XTThread *thread, size_t size1, xtWord1 *data1, size_t size2, xtWord1 *data2, xtBool commit, xtLogID *log_id, xtLogOffset *log_offset);
+	xtBool					xlog_append(struct XTThread *thread, size_t size1, xtWord1 *data1, size_t size2, xtWord1 *data2, int flush_log_at_trx_commit, xtLogID *log_id, xtLogOffset *log_offset);
 	xtBool					xlog_flush(struct XTThread *thread);
 	xtBool					xlog_flush_pending();
 
@@ -464,7 +468,7 @@
 } XTDatabaseLogRec, *XTDatabaseLogPtr;
 
 xtBool			xt_xlog_flush_log(struct XTDatabase *db, struct XTThread *thread);
-xtBool			xt_xlog_log_data(struct XTThread *thread, size_t len, XTXactLogBufferDPtr log_entry, xtBool commit);
+xtBool			xt_xlog_log_data(struct XTThread *thread, size_t len, XTXactLogBufferDPtr log_entry, int flush_log_at_trx_commit);
 xtBool			xt_xlog_modify_table(xtTableID tab_id, u_int status, xtOpSeqNo op_seq, xtRecordID free_list, xtRecordID address, size_t size, xtWord1 *data, struct XTThread *thread);
 
 void			xt_xlog_init(struct XTThread *self, size_t cache_size);

=== modified file 'storage/pbxt/src/xt_defs.h'
--- storage/pbxt/src/xt_defs.h	2009-11-24 10:55:06 +0000
+++ storage/pbxt/src/xt_defs.h	2010-05-07 08:52:27 +0000
@@ -221,7 +221,7 @@
  */
 
 #ifdef DEBUG
-//#define XT_USE_GLOBAL_DEBUG_SIZES
+#define XT_USE_GLOBAL_DEBUG_SIZES
 #endif
 
 /*
@@ -392,6 +392,11 @@
 //#define XT_NO_ATOMICS
 #endif
 
+/* When pbxt_flush_log_at_trx_commit != 1, the transaction log is flushed
+ * at regular intervals. Set the interval here.
+ */
+#define XT_XLOG_FLUSH_FREQ				1000
+
 /* ----------------------------------------------------------------------
  * GLOBAL CONSTANTS
  */
@@ -457,21 +462,24 @@
 #ifdef XT_USE_GLOBAL_DEBUG_SIZES
 
 //#undef XT_ROW_RWLOCKS
-//#define XT_ROW_RWLOCKS				2
+//#define XT_ROW_RWLOCKS					2
 
 //#undef XT_TAB_MIN_VAR_REC_LENGTH
-//#define XT_TAB_MIN_VAR_REC_LENGTH		20
+//#define XT_TAB_MIN_VAR_REC_LENGTH			20
 
 //#undef XT_ROW_LOCK_COUNT