diff --git a/BUILD/check-cpu b/BUILD/check-cpu
index 9edde51402f..24b76c7198d 100755
--- a/BUILD/check-cpu
+++ b/BUILD/check-cpu
@@ -114,6 +114,10 @@ check_cpu () {
     *i386*i486*)
       cpu_arg="pentium-m";
       ;;
+    #Core 2 Duo  
+    *Intel*Core\(TM\)2*)
+      cpu_arg="nocona";
+      ;;
 
     # Intel ia64
     *Itanium*)
diff --git a/EXCEPTIONS-CLIENT b/EXCEPTIONS-CLIENT
index 19b86cab32b..c570ff7ba24 100644
--- a/EXCEPTIONS-CLIENT
+++ b/EXCEPTIONS-CLIENT
@@ -4,7 +4,7 @@ The MySQL AB Exception for Free/Libre and Open Source
 Software-only Applications Using MySQL Client Libraries (the
 "FLOSS Exception").
 
-Version 0.5, 30 August 2006
+Version 0.6, 7 March 2007
 
 Exception Intent
 
@@ -59,10 +59,12 @@ Apache Software License 1.0/1.1/2.0
 Apple Public Source License 2.0
 Artistic license From Perl 5.8.0
 BSD license "July 22 1999"
+Common Development and Distribution License (CDDL) 1.0
 Common Public License 1.0
+Eclipse Public License 1.0
 GNU Library or "Lesser" General Public License (LGPL) 2.0/2.1
 Jabber Open Source License 1.0
-MIT license ---
+MIT license (As listed in file MIT-License.txt) ---
 Mozilla Public License (MPL) 1.0/1.1
 Open Software License 2.0
 OpenSSL license (with original SSLeay license) "2003" ("1998")
diff --git a/configure.in b/configure.in
index 9581b5ac46a..99f05be35a5 100644
--- a/configure.in
+++ b/configure.in
@@ -739,8 +739,9 @@ AC_CHECK_FUNC(bind, , AC_CHECK_LIB(bind, bind))
 # Check if crypt() exists in libc or libcrypt, sets LIBS if needed
 AC_SEARCH_LIBS(crypt, crypt, AC_DEFINE(HAVE_CRYPT, 1, [crypt]))
 
-# For sem_xxx functions on Solaris 2.6
-AC_CHECK_FUNC(sem_init, , AC_CHECK_LIB(posix4, sem_init))
+# For the sched_yield() function on Solaris
+AC_CHECK_FUNC(sched_yield, , AC_CHECK_LIB(posix4, sched_yield))
+
 MYSQL_CHECK_ZLIB_WITH_COMPRESS
 
 # For large pages support
diff --git a/include/Makefile.am b/include/Makefile.am
index d40df7d8343..15f1a83c79d 100644
--- a/include/Makefile.am
+++ b/include/Makefile.am
@@ -22,7 +22,7 @@ HEADERS_ABI =		mysql.h mysql_com.h mysql_time.h \
 			my_list.h my_alloc.h typelib.h
 pkginclude_HEADERS =	$(HEADERS_ABI) my_dbug.h m_string.h my_sys.h \
 			my_xml.h mysql_embed.h \
-		  	my_semaphore.h my_pthread.h my_no_pthread.h \
+		  	my_pthread.h my_no_pthread.h \
 			errmsg.h my_global.h my_net.h \
 			my_getopt.h sslopt-longopts.h my_dir.h \
 			sslopt-vars.h sslopt-case.h sql_common.h keycache.h \
diff --git a/include/my_semaphore.h b/include/my_semaphore.h
deleted file mode 100644
index 7f182bea6bf..00000000000
--- a/include/my_semaphore.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Module: semaphore.h
- *
- * Purpose:
- *      Semaphores aren't actually part of the PThreads standard.
- *      They are defined by the POSIX Standard:
- *
- *              POSIX 1003.1b-1993      (POSIX.1b)
- *
- * Pthreads-win32 - POSIX Threads Library for Win32
- * Copyright (C) 1998
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- * MA 02111-1307, USA
- */
-
-/* This is hacked by Monty to be included in mysys library */
-
-#ifndef _my_semaphore_h_
-#define _my_semaphore_h_
-
-#ifdef THREAD
-
-C_MODE_START
-#ifdef HAVE_SEMAPHORE_H
-#include <semaphore.h>
-#elif !defined(__bsdi__)
-#ifdef __WIN__
-typedef HANDLE sem_t;
-#else
-typedef struct {
-  pthread_mutex_t mutex;
-  pthread_cond_t  cond;
-  uint            count;
-} sem_t;
-#endif /* __WIN__ */
-
-int sem_init(sem_t * sem, int pshared, unsigned int value);
-int sem_destroy(sem_t * sem);
-int sem_trywait(sem_t * sem);
-int sem_wait(sem_t * sem);
-int sem_post(sem_t * sem);
-int sem_post_multiple(sem_t * sem, unsigned int count);
-int sem_getvalue(sem_t * sem, unsigned int * sval);
-
-#endif /* !__bsdi__ */
-
-C_MODE_END
-
-#endif /* THREAD */
-
-#endif /* !_my_semaphore_h_ */
diff --git a/mysql-test/r/delayed.result b/mysql-test/r/delayed.result
index a514ffcddd2..a21b6f4f3a5 100644
--- a/mysql-test/r/delayed.result
+++ b/mysql-test/r/delayed.result
@@ -243,3 +243,10 @@ SET             @@session.auto_increment_offset=
 @bug20830_old_session_auto_increment_offset;
 SET             @@session.auto_increment_increment=
 @bug20830_old_session_auto_increment_increment;
+CREATE TABLE t1(a BIT);
+INSERT DELAYED INTO t1 VALUES(1);
+FLUSH TABLE t1;
+SELECT HEX(a) FROM t1;
+HEX(a)
+1
+DROP TABLE t1;
diff --git a/mysql-test/r/explain.result b/mysql-test/r/explain.result
index e0d9f5131b4..6f348447fbb 100644
--- a/mysql-test/r/explain.result
+++ b/mysql-test/r/explain.result
@@ -57,3 +57,33 @@ select 3 into @v1;
 explain select 3 into @v1;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	No tables used
+create table t1(f1 int, f2 int);
+insert into t1 values (1,1);
+create view v1 as select * from t1 where f1=1;
+explain extended select * from v1 where f2=1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t1	system	NULL	NULL	NULL	NULL	1	100.00	
+Warnings:
+Note	1003	select '1' AS `f1`,'1' AS `f2` from `test`.`t1` where 1
+explain extended select * from t1 where 0;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE
+Warnings:
+Note	1003	select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` where 0
+explain extended select * from t1 where 1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t1	system	NULL	NULL	NULL	NULL	1	100.00	
+Warnings:
+Note	1003	select '1' AS `f1`,'1' AS `f2` from `test`.`t1` where 1
+explain extended select * from t1 having 0;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible HAVING
+Warnings:
+Note	1003	select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` having 0
+explain extended select * from t1 having 1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
+1	SIMPLE	t1	system	NULL	NULL	NULL	NULL	1	100.00	
+Warnings:
+Note	1003	select '1' AS `f1`,'1' AS `f2` from `test`.`t1` having 1
+drop view v1;
+drop table t1;
diff --git a/mysql-test/r/func_default.result b/mysql-test/r/func_default.result
index 7f1e53b00e0..a8f59f73e88 100644
--- a/mysql-test/r/func_default.result
+++ b/mysql-test/r/func_default.result
@@ -8,7 +8,7 @@ explain extended select default(str), default(strnull), default(intg), default(r
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	SIMPLE	t1	system	NULL	NULL	NULL	NULL	1	100.00	
 Warnings:
-Note	1003	select default(`test`.`t1`.`str`) AS `default(str)`,default(`test`.`t1`.`strnull`) AS `default(strnull)`,default(`test`.`t1`.`intg`) AS `default(intg)`,default(`test`.`t1`.`rel`) AS `default(rel)` from `test`.`t1`
+Note	1003	select default('') AS `default(str)`,default('') AS `default(strnull)`,default('0') AS `default(intg)`,default('0') AS `default(rel)` from `test`.`t1`
 select * from t1 where str <> default(str);
 str	strnull	intg	rel
 		0	0
diff --git a/mysql-test/r/func_in.result b/mysql-test/r/func_in.result
index 9ec621b7f35..7a8f59c65f4 100644
--- a/mysql-test/r/func_in.result
+++ b/mysql-test/r/func_in.result
@@ -399,6 +399,84 @@ WHERE t3.a=t1.a AND t3.a=t2.a;
 3
 3
 DROP TABLE t1,t2,t3,t4;
+CREATE TABLE t1(a BIGINT UNSIGNED);
+INSERT INTO t1 VALUES (0xFFFFFFFFFFFFFFFF);
+SELECT * FROM t1 WHERE a=-1 OR a=-2 ;
+a
+SELECT * FROM t1 WHERE a IN (-1, -2);
+a
+CREATE TABLE t2 (a BIGINT UNSIGNED);
+insert into t2 values(13491727406643098568),
+(0x7fffffefffffffff),
+(0x7ffffffeffffffff),
+(0x7fffffffefffffff),
+(0x7ffffffffeffffff),
+(0x7fffffffffefffff),
+(0x7ffffffffffeffff),
+(0x7fffffffffffefff),
+(0x7ffffffffffffeff),
+(0x7fffffffffffffef),
+(0x7ffffffffffffffe),
+(0x7fffffffffffffff),
+(0x8000000000000000),
+(0x8000000000000001),
+(0x8000000000000002),
+(0x8000000000000300),
+(0x8000000000000400),
+(0x8000000000000401),
+(0x8000000000004001),
+(0x8000000000040001),
+(0x8000000000400001),
+(0x8000000004000001),
+(0x8000000040000001),
+(0x8000000400000001),
+(0x8000004000000001),
+(0x8000040000000001);
+SELECT HEX(a) FROM t2 WHERE a IN (0xBB3C3E98175D33C8, 42);
+HEX(a)
+BB3C3E98175D33C8
+SELECT HEX(a) FROM t2 WHERE a IN
+(0xBB3C3E98175D33C8,
+0x7fffffffffffffff,
+0x8000000000000000,
+0x8000000000000400,
+0x8000000000000401,
+42);
+HEX(a)
+BB3C3E98175D33C8
+7FFFFFFFFFFFFEFF
+7FFFFFFFFFFFFFEF
+7FFFFFFFFFFFFFFE
+7FFFFFFFFFFFFFFF
+8000000000000000
+8000000000000001
+8000000000000002
+8000000000000300
+8000000000000400
+8000000000000401
+SELECT HEX(a) FROM t2 WHERE a IN (0x7fffffffffffffff,0x8000000000000001);
+HEX(a)
+7FFFFFFFFFFFFFFF
+8000000000000001
+SELECT HEX(a) FROM t2 WHERE a IN (0x7ffffffffffffffe,0x7fffffffffffffff);
+HEX(a)
+7FFFFFFFFFFFFFFE
+7FFFFFFFFFFFFFFF
+SELECT HEX(a) FROM t2 WHERE a IN (0x7ffffffffffffffe,0x7fffffffffffffff,'abc');
+HEX(a)
+7FFFFFFFFFFFFFFE
+7FFFFFFFFFFFFFFF
+CREATE TABLE t3 (a BIGINT UNSIGNED);
+INSERT INTO t3 VALUES (9223372036854775551);
+SELECT HEX(a) FROM t3 WHERE a IN (9223372036854775807, 42);
+HEX(a)
+CREATE TABLE t4 (a DATE);
+INSERT INTO t4 VALUES ('1972-02-06'), ('1972-07-29');
+SELECT * FROM t4 WHERE a IN ('1972-02-06','19772-07-29');
+a
+Warnings:
+Warning	1292	Incorrect date value: '19772-07-29' for column 'a' at row 1
+DROP TABLE t1,t2,t3,t4;
 End of 5.0 tests
 create table t1(f1 char(1));
 insert into t1 values ('a'),('b'),('1');
diff --git a/mysql-test/r/func_regexp.result b/mysql-test/r/func_regexp.result
index 803f606d3dd..4e35c2a1348 100644
--- a/mysql-test/r/func_regexp.result
+++ b/mysql-test/r/func_regexp.result
@@ -40,7 +40,7 @@ explain extended select * from t1 where xxx regexp('is a test of some long text
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	SIMPLE	t1	system	NULL	NULL	NULL	NULL	1	100.00	
 Warnings:
-Note	1003	select `test`.`t1`.`xxx` AS `xxx` from `test`.`t1` where (`test`.`t1`.`xxx` regexp _latin1'is a test of some long text to')
+Note	1003	select 'this is a test of some long text to see what happens' AS `xxx` from `test`.`t1` where ('this is a test of some long text to see what happens' regexp _latin1'is a test of some long text to')
 select * from t1 where xxx regexp('is a test of some long text to ');
 xxx
 this is a test of some long text to see what happens
diff --git a/mysql-test/r/func_str.result b/mysql-test/r/func_str.result
index d6eb1ab06cf..8bc613be4c0 100644
--- a/mysql-test/r/func_str.result
+++ b/mysql-test/r/func_str.result
@@ -1309,12 +1309,12 @@ explain extended select encode(f1,'zxcv') as 'enc' from t1;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	SIMPLE	t1	system	NULL	NULL	NULL	NULL	0	0.00	const row not found
 Warnings:
-Note	1003	select encode(`test`.`t1`.`f1`,_latin1'zxcv') AS `enc` from `test`.`t1`
+Note	1003	select encode('',_latin1'zxcv') AS `enc` from `test`.`t1`
 explain extended select decode(f1,'zxcv') as 'enc' from t1;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	SIMPLE	t1	system	NULL	NULL	NULL	NULL	0	0.00	const row not found
 Warnings:
-Note	1003	select decode(`test`.`t1`.`f1`,_latin1'zxcv') AS `enc` from `test`.`t1`
+Note	1003	select decode('',_latin1'zxcv') AS `enc` from `test`.`t1`
 drop table t1;
 End of 4.1 tests
 create table t1 (d decimal default null);
@@ -1378,7 +1378,7 @@ 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	3	100.00	Using where; Using index
 Warnings:
-Note	1003	select `test`.`t1`.`code` AS `code`,`test`.`t2`.`id` AS `id` from `test`.`t1` join `test`.`t2` where ((`test`.`t1`.`code` = _latin1'a12') and (length(`test`.`t1`.`code`) = 5))
+Note	1003	select `test`.`t1`.`code` AS `code`,'a12' AS `id` from `test`.`t1` join `test`.`t2` where ((`test`.`t1`.`code` = _latin1'a12') and (length(`test`.`t1`.`code`) = 5))
 DROP TABLE t1,t2;
 select encode(NULL, NULL);
 encode(NULL, NULL)
@@ -2273,6 +2273,17 @@ abcxx
 select lpad('abc', cast(5 as unsigned integer), 'x');
 lpad('abc', cast(5 as unsigned integer), 'x')
 xxabc
+create table t1(f1 longtext);
+insert into t1 values ("123"),("456");
+select substring(f1,1,1) from t1 group by 1;
+substring(f1,1,1)
+1
+4
+create table t2(f1 varchar(3));
+insert into t1 values ("123"),("456");
+select substring(f1,4,1), substring(f1,-4,1) from t2;
+substring(f1,4,1)	substring(f1,-4,1)
+drop table t1,t2;
 DROP TABLE IF EXISTS t1;
 CREATE TABLE `t1` (
 `id` varchar(20) NOT NULL,
@@ -2287,4 +2298,22 @@ A	B	tire
 #	#	1
 ##	##	2
 DROP TABLE t1;
+SELECT UNHEX('G');
+UNHEX('G')
+NULL
+SELECT UNHEX('G') IS NULL;
+UNHEX('G') IS NULL
+1
+SELECT INSERT('abc', 3, 3, '1234');
+INSERT('abc', 3, 3, '1234')
+ab1234
+SELECT INSERT('abc', 4, 3, '1234');
+INSERT('abc', 4, 3, '1234')
+abc1234
+SELECT INSERT('abc', 5, 3, '1234');
+INSERT('abc', 5, 3, '1234')
+abc
+SELECT INSERT('abc', 6, 3, '1234');
+INSERT('abc', 6, 3, '1234')
+abc
 End of 5.0 tests
diff --git a/mysql-test/r/func_test.result b/mysql-test/r/func_test.result
index 9a5cc666ca8..a97e6869d09 100644
--- a/mysql-test/r/func_test.result
+++ b/mysql-test/r/func_test.result
@@ -79,7 +79,7 @@ explain extended select * from t1 where 1 xor 1;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE
 Warnings:
-Note	1003	select `test`.`t1`.`a` AS `a` from `test`.`t1`
+Note	1003	select `test`.`t1`.`a` AS `a` from `test`.`t1` where 0
 select - a from t1;
 - a
 -1
@@ -87,7 +87,7 @@ explain extended select - a from t1;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	SIMPLE	t1	system	NULL	NULL	NULL	NULL	1	100.00	
 Warnings:
-Note	1003	select -(`test`.`t1`.`a`) AS `- a` from `test`.`t1`
+Note	1003	select -('1') AS `- a` from `test`.`t1`
 drop table t1;
 select 5 between 0 and 10 between 0 and 1,(5 between 0 and 10) between 0 and 1;
 5 between 0 and 10 between 0 and 1	(5 between 0 and 10) between 0 and 1
diff --git a/mysql-test/r/gis-rtree.result b/mysql-test/r/gis-rtree.result
index 138360edc49..96aa8a17181 100644
--- a/mysql-test/r/gis-rtree.result
+++ b/mysql-test/r/gis-rtree.result
@@ -873,6 +873,558 @@ SELECT 1 FROM t1 WHERE foo != PointFromWKB(POINT(0,0));
 1
 1
 DROP TABLE t1;
+CREATE TABLE t1 (id bigint(12) unsigned NOT NULL auto_increment,
+c2 varchar(15) collate utf8_bin default NULL,
+c1 varchar(15) collate utf8_bin default NULL,
+c3 varchar(10) collate utf8_bin default NULL,
+spatial_point point NOT NULL,
+PRIMARY KEY(id),
+SPATIAL KEY (spatial_point(32))
+)ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
+INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES
+('y', 's', 'j', GeomFromText('POINT(167 74)')),
+('r', 'n', 'd', GeomFromText('POINT(215 118)')),
+('g', 'n', 'e', GeomFromText('POINT(203 98)')),
+('h', 'd', 'd', GeomFromText('POINT(54 193)')),
+('r', 'x', 'y', GeomFromText('POINT(47 69)')),
+('t', 'q', 'r', GeomFromText('POINT(109 42)')),
+('a', 'z', 'd', GeomFromText('POINT(0 154)')),
+('x', 'v', 'o', GeomFromText('POINT(174 131)')),
+('b', 'r', 'a', GeomFromText('POINT(114 253)')),
+('x', 'z', 'i', GeomFromText('POINT(163 21)')),
+('w', 'p', 'i', GeomFromText('POINT(42 102)')),
+('g', 'j', 'j', GeomFromText('POINT(170 133)')),
+('m', 'g', 'n', GeomFromText('POINT(28 22)')),
+('b', 'z', 'h', GeomFromText('POINT(174 28)')),
+('q', 'k', 'f', GeomFromText('POINT(233 73)')),
+('w', 'w', 'a', GeomFromText('POINT(124 200)')),
+('t', 'j', 'w', GeomFromText('POINT(252 101)')),
+('d', 'r', 'd', GeomFromText('POINT(98 18)')),
+('w', 'o', 'y', GeomFromText('POINT(165 31)')),
+('y', 'h', 't', GeomFromText('POINT(14 220)')),
+('d', 'p', 'u', GeomFromText('POINT(223 196)')),
+('g', 'y', 'g', GeomFromText('POINT(207 96)')),
+('x', 'm', 'n', GeomFromText('POINT(214 3)')),
+('g', 'v', 'e', GeomFromText('POINT(140 205)')),
+('g', 'm', 'm', GeomFromText('POINT(10 236)')),
+('i', 'r', 'j', GeomFromText('POINT(137 228)')),
+('w', 's', 'p', GeomFromText('POINT(115 6)')),
+('o', 'n', 'k', GeomFromText('POINT(158 129)')),
+('j', 'h', 'l', GeomFromText('POINT(129 72)')),
+('f', 'x', 'l', GeomFromText('POINT(139 207)')),
+('u', 'd', 'n', GeomFromText('POINT(125 109)')),
+('b', 'a', 'z', GeomFromText('POINT(30 32)')),
+('m', 'h', 'o', GeomFromText('POINT(251 251)')),
+('f', 'r', 'd', GeomFromText('POINT(243 211)')),
+('b', 'd', 'r', GeomFromText('POINT(232 80)')),
+('g', 'k', 'v', GeomFromText('POINT(15 100)')),
+('i', 'f', 'c', GeomFromText('POINT(109 66)')),
+('r', 't', 'j', GeomFromText('POINT(178 6)')),
+('y', 'n', 'f', GeomFromText('POINT(233 211)')),
+('f', 'y', 'm', GeomFromText('POINT(99 16)')),
+('z', 'q', 'l', GeomFromText('POINT(39 49)')),
+('j', 'c', 'r', GeomFromText('POINT(75 187)')),
+('c', 'y', 'y', GeomFromText('POINT(246 253)')),
+('w', 'u', 'd', GeomFromText('POINT(56 190)')),
+('n', 'q', 'm', GeomFromText('POINT(73 149)')),
+('d', 'y', 'a', GeomFromText('POINT(134 6)')),
+('z', 's', 'w', GeomFromText('POINT(216 225)')),
+('d', 'u', 'k', GeomFromText('POINT(132 70)')),
+('f', 'v', 't', GeomFromText('POINT(187 141)')),
+('r', 'r', 'a', GeomFromText('POINT(152 39)')),
+('y', 'p', 'o', GeomFromText('POINT(45 27)')),
+('p', 'n', 'm', GeomFromText('POINT(228 148)')),
+('e', 'g', 'e', GeomFromText('POINT(88 81)')),
+('m', 'a', 'h', GeomFromText('POINT(35 29)')),
+('m', 'h', 'f', GeomFromText('POINT(30 71)')),
+('h', 'k', 'i', GeomFromText('POINT(244 78)')),
+('z', 'v', 'd', GeomFromText('POINT(241 38)')),
+('q', 'l', 'j', GeomFromText('POINT(13 71)')),
+('s', 'p', 'g', GeomFromText('POINT(108 38)')),
+('q', 's', 'j', GeomFromText('POINT(92 101)')),
+('l', 'h', 'g', GeomFromText('POINT(120 78)')),
+('w', 't', 'b', GeomFromText('POINT(193 109)')),
+('b', 's', 's', GeomFromText('POINT(223 211)')),
+('w', 'w', 'y', GeomFromText('POINT(122 42)')),
+('q', 'c', 'c', GeomFromText('POINT(104 102)')),
+('w', 'g', 'n', GeomFromText('POINT(213 120)')),
+('p', 'q', 'a', GeomFromText('POINT(247 148)')),
+('c', 'z', 'e', GeomFromText('POINT(18 106)')),
+('z', 'u', 'n', GeomFromText('POINT(70 133)')),
+('j', 'n', 'x', GeomFromText('POINT(232 13)')),
+('e', 'h', 'f', GeomFromText('POINT(22 135)')),
+('w', 'l', 'f', GeomFromText('POINT(9 180)')),
+('a', 'v', 'q', GeomFromText('POINT(163 228)')),
+('i', 'z', 'o', GeomFromText('POINT(180 100)')),
+('e', 'c', 'l', GeomFromText('POINT(182 231)')),
+('c', 'k', 'o', GeomFromText('POINT(19 60)')),
+('q', 'f', 'p', GeomFromText('POINT(79 95)')),
+('m', 'd', 'r', GeomFromText('POINT(3 127)')),
+('m', 'e', 't', GeomFromText('POINT(136 154)')),
+('w', 'w', 'w', GeomFromText('POINT(102 15)')),
+('l', 'n', 'q', GeomFromText('POINT(71 196)')),
+('p', 'k', 'c', GeomFromText('POINT(47 139)')),
+('j', 'o', 'r', GeomFromText('POINT(177 128)')),
+('j', 'q', 'a', GeomFromText('POINT(170 6)')),
+('b', 'a', 'o', GeomFromText('POINT(63 211)')),
+('g', 's', 'o', GeomFromText('POINT(144 251)')),
+('w', 'u', 'w', GeomFromText('POINT(221 214)')),
+('g', 'a', 'm', GeomFromText('POINT(14 102)')),
+('u', 'q', 'z', GeomFromText('POINT(86 200)')),
+('k', 'a', 'm', GeomFromText('POINT(144 222)')),
+('j', 'u', 'r', GeomFromText('POINT(216 142)')),
+('q', 'k', 'v', GeomFromText('POINT(121 236)')),
+('p', 'o', 'r', GeomFromText('POINT(108 102)')),
+('b', 'd', 'x', GeomFromText('POINT(127 198)')),
+('k', 's', 'a', GeomFromText('POINT(2 150)')),
+('f', 'm', 'f', GeomFromText('POINT(160 191)')),
+('q', 'y', 'x', GeomFromText('POINT(98 111)')),
+('o', 'f', 'm', GeomFromText('POINT(232 218)')),
+('c', 'w', 'j', GeomFromText('POINT(156 165)')),
+('s', 'q', 'v', GeomFromText('POINT(98 161)'));
+SET @@RAND_SEED1=692635050, @@RAND_SEED2=297339954;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=159925977, @@RAND_SEED2=942570618;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=328169745, @@RAND_SEED2=410451954;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=178507359, @@RAND_SEED2=332493072;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=1034033013, @@RAND_SEED2=558966507;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+UPDATE t1 set spatial_point=GeomFromText('POINT(230 9)') where  c1 like 'y%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(95 35)') where  c1 like 'j%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(93 99)') where  c1 like 'a%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(19 81)') where  c1 like 'r%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(20 177)') where  c1 like 'h%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(221 193)') where  c1 like 'u%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(195 205)') where  c1 like 'd%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(15 213)') where  c1 like 'u%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(214 63)') where  c1 like 'n%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(243 171)') where  c1 like 'c%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(198 82)') where  c1 like 'y%';
+INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES
+('f', 'y', 'p', GeomFromText('POINT(109 235)')),
+('b', 'e', 'v', GeomFromText('POINT(20 48)')),
+('i', 'u', 'f', GeomFromText('POINT(15 55)')),
+('o', 'r', 'z', GeomFromText('POINT(105 64)')),
+('a', 'p', 'a', GeomFromText('POINT(142 236)')),
+('g', 'i', 'k', GeomFromText('POINT(10 49)')),
+('x', 'z', 'x', GeomFromText('POINT(192 200)')),
+('c', 'v', 'r', GeomFromText('POINT(94 168)')),
+('y', 'z', 'e', GeomFromText('POINT(141 51)')),
+('h', 'm', 'd', GeomFromText('POINT(35 251)')),
+('v', 'm', 'q', GeomFromText('POINT(44 90)')),
+('j', 'l', 'z', GeomFromText('POINT(67 237)')),
+('i', 'v', 'a', GeomFromText('POINT(75 14)')),
+('b', 'q', 't', GeomFromText('POINT(153 33)')),
+('e', 'm', 'a', GeomFromText('POINT(247 49)')),
+('l', 'y', 'g', GeomFromText('POINT(56 203)')),
+('v', 'o', 'r', GeomFromText('POINT(90 54)')),
+('r', 'n', 'd', GeomFromText('POINT(135 83)')),
+('j', 't', 'u', GeomFromText('POINT(174 239)')),
+('u', 'n', 'g', GeomFromText('POINT(104 191)')),
+('p', 'q', 'y', GeomFromText('POINT(63 171)')),
+('o', 'q', 'p', GeomFromText('POINT(192 103)')),
+('f', 'x', 'e', GeomFromText('POINT(244 30)')),
+('n', 'x', 'c', GeomFromText('POINT(92 103)')),
+('r', 'q', 'z', GeomFromText('POINT(166 20)')),
+('s', 'a', 'j', GeomFromText('POINT(137 205)')),
+('z', 't', 't', GeomFromText('POINT(99 134)')),
+('o', 'm', 'j', GeomFromText('POINT(217 3)')),
+('n', 'h', 'j', GeomFromText('POINT(211 17)')),
+('v', 'v', 'a', GeomFromText('POINT(41 137)')),
+('q', 'o', 'j', GeomFromText('POINT(5 92)')),
+('z', 'y', 'e', GeomFromText('POINT(175 212)')),
+('j', 'z', 'h', GeomFromText('POINT(224 194)')),
+('a', 'g', 'm', GeomFromText('POINT(31 119)')),
+('p', 'c', 'f', GeomFromText('POINT(17 221)')),
+('t', 'h', 'k', GeomFromText('POINT(26 203)')),
+('u', 'w', 'p', GeomFromText('POINT(47 185)')),
+('z', 'a', 'c', GeomFromText('POINT(61 133)')),
+('u', 'k', 'a', GeomFromText('POINT(210 115)')),
+('k', 'f', 'h', GeomFromText('POINT(125 113)')),
+('t', 'v', 'y', GeomFromText('POINT(12 239)')),
+('u', 'v', 'd', GeomFromText('POINT(90 24)')),
+('m', 'y', 'w', GeomFromText('POINT(25 243)')),
+('d', 'n', 'g', GeomFromText('POINT(122 92)')),
+('z', 'm', 'f', GeomFromText('POINT(235 110)')),
+('q', 'd', 'f', GeomFromText('POINT(233 217)')),
+('a', 'v', 'u', GeomFromText('POINT(69 59)')),
+('x', 'k', 'p', GeomFromText('POINT(240 14)')),
+('i', 'v', 'r', GeomFromText('POINT(154 42)')),
+('w', 'h', 'l', GeomFromText('POINT(178 156)')),
+('d', 'h', 'n', GeomFromText('POINT(65 157)')),
+('c', 'k', 'z', GeomFromText('POINT(62 33)')),
+('e', 'l', 'w', GeomFromText('POINT(162 1)')),
+('r', 'f', 'i', GeomFromText('POINT(127 71)')),
+('q', 'm', 'c', GeomFromText('POINT(63 118)')),
+('c', 'h', 'u', GeomFromText('POINT(205 203)')),
+('d', 't', 'p', GeomFromText('POINT(234 87)')),
+('s', 'g', 'h', GeomFromText('POINT(149 34)')),
+('o', 'b', 'q', GeomFromText('POINT(159 179)')),
+('k', 'u', 'f', GeomFromText('POINT(202 254)')),
+('u', 'f', 'g', GeomFromText('POINT(70 15)')),
+('x', 's', 'b', GeomFromText('POINT(25 181)')),
+('s', 'c', 'g', GeomFromText('POINT(252 17)')),
+('a', 'c', 'f', GeomFromText('POINT(89 67)')),
+('r', 'e', 'q', GeomFromText('POINT(55 54)')),
+('f', 'i', 'k', GeomFromText('POINT(178 230)')),
+('p', 'e', 'l', GeomFromText('POINT(198 28)')),
+('w', 'o', 'd', GeomFromText('POINT(204 189)')),
+('c', 'a', 'g', GeomFromText('POINT(230 178)')),
+('r', 'o', 'e', GeomFromText('POINT(61 116)')),
+('w', 'a', 'a', GeomFromText('POINT(178 237)')),
+('v', 'd', 'e', GeomFromText('POINT(70 85)')),
+('k', 'c', 'e', GeomFromText('POINT(147 118)')),
+('d', 'q', 't', GeomFromText('POINT(218 77)')),
+('k', 'g', 'f', GeomFromText('POINT(192 113)')),
+('w', 'n', 'e', GeomFromText('POINT(92 124)')),
+('r', 'm', 'q', GeomFromText('POINT(130 65)')),
+('o', 'r', 'r', GeomFromText('POINT(174 233)')),
+('k', 'n', 't', GeomFromText('POINT(175 147)')),
+('q', 'm', 'r', GeomFromText('POINT(18 208)')),
+('l', 'd', 'i', GeomFromText('POINT(13 104)')),
+('w', 'o', 'y', GeomFromText('POINT(207 39)')),
+('p', 'u', 'o', GeomFromText('POINT(114 31)')),
+('y', 'a', 'p', GeomFromText('POINT(106 59)')),
+('a', 'x', 'z', GeomFromText('POINT(17 57)')),
+('v', 'h', 'x', GeomFromText('POINT(170 13)')),
+('t', 's', 'u', GeomFromText('POINT(84 18)')),
+('z', 'z', 'f', GeomFromText('POINT(250 197)')),
+('l', 'z', 't', GeomFromText('POINT(59 80)')),
+('j', 'g', 's', GeomFromText('POINT(54 26)')),
+('g', 'v', 'm', GeomFromText('POINT(89 98)')),
+('q', 'v', 'b', GeomFromText('POINT(39 240)')),
+('x', 'k', 'v', GeomFromText('POINT(246 207)')),
+('k', 'u', 'i', GeomFromText('POINT(105 111)')),
+('w', 'z', 's', GeomFromText('POINT(235 8)')),
+('d', 'd', 'd', GeomFromText('POINT(105 4)')),
+('c', 'z', 'q', GeomFromText('POINT(13 140)')),
+('m', 'k', 'i', GeomFromText('POINT(208 120)')),
+('g', 'a', 'g', GeomFromText('POINT(9 182)')),
+('z', 'j', 'r', GeomFromText('POINT(149 153)')),
+('h', 'f', 'g', GeomFromText('POINT(81 236)')),
+('m', 'e', 'q', GeomFromText('POINT(209 215)')),
+('c', 'h', 'y', GeomFromText('POINT(235 70)')),
+('i', 'e', 'g', GeomFromText('POINT(138 26)')),
+('m', 't', 'u', GeomFromText('POINT(119 237)')),
+('o', 'w', 's', GeomFromText('POINT(193 166)')),
+('f', 'm', 'q', GeomFromText('POINT(85 96)')),
+('x', 'l', 'x', GeomFromText('POINT(58 115)')),
+('x', 'q', 'u', GeomFromText('POINT(108 210)')),
+('b', 'h', 'i', GeomFromText('POINT(250 139)')),
+('y', 'd', 'x', GeomFromText('POINT(199 135)')),
+('w', 'h', 'p', GeomFromText('POINT(247 233)')),
+('p', 'z', 't', GeomFromText('POINT(148 249)')),
+('q', 'a', 'u', GeomFromText('POINT(174 78)')),
+('v', 't', 'm', GeomFromText('POINT(70 228)')),
+('t', 'n', 'f', GeomFromText('POINT(123 2)')),
+('x', 't', 'b', GeomFromText('POINT(35 50)')),
+('r', 'j', 'f', GeomFromText('POINT(200 51)')),
+('s', 'q', 'o', GeomFromText('POINT(23 184)')),
+('u', 'v', 'z', GeomFromText('POINT(7 113)')),
+('v', 'u', 'l', GeomFromText('POINT(145 190)')),
+('o', 'k', 'i', GeomFromText('POINT(161 122)')),
+('l', 'y', 'e', GeomFromText('POINT(17 232)')),
+('t', 'b', 'e', GeomFromText('POINT(120 50)')),
+('e', 's', 'u', GeomFromText('POINT(254 1)')),
+('d', 'd', 'u', GeomFromText('POINT(167 140)')),
+('o', 'b', 'x', GeomFromText('POINT(186 237)')),
+('m', 's', 's', GeomFromText('POINT(172 149)')),
+('t', 'y', 'a', GeomFromText('POINT(149 85)')),
+('x', 't', 'r', GeomFromText('POINT(10 165)')),
+('g', 'c', 'e', GeomFromText('POINT(95 165)')),
+('e', 'e', 'z', GeomFromText('POINT(98 65)')),
+('f', 'v', 'i', GeomFromText('POINT(149 144)')),
+('o', 'p', 'm', GeomFromText('POINT(233 67)')),
+('t', 'u', 'b', GeomFromText('POINT(109 215)')),
+('o', 'o', 'b', GeomFromText('POINT(130 48)')),
+('e', 'm', 'h', GeomFromText('POINT(88 189)')),
+('e', 'v', 'y', GeomFromText('POINT(55 29)')),
+('e', 't', 'm', GeomFromText('POINT(129 55)')),
+('p', 'p', 'i', GeomFromText('POINT(126 222)')),
+('c', 'i', 'c', GeomFromText('POINT(19 158)')),
+('c', 'b', 's', GeomFromText('POINT(13 19)')),
+('u', 'y', 'a', GeomFromText('POINT(114 5)')),
+('a', 'o', 'f', GeomFromText('POINT(227 232)')),
+('t', 'c', 'z', GeomFromText('POINT(63 62)')),
+('d', 'o', 'k', GeomFromText('POINT(48 228)')),
+('x', 'c', 'e', GeomFromText('POINT(204 2)')),
+('e', 'e', 'g', GeomFromText('POINT(125 43)')),
+('o', 'r', 'f', GeomFromText('POINT(171 140)'));
+UPDATE t1 set spatial_point=GeomFromText('POINT(163 157)') where  c1 like 'w%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(53 151)') where  c1 like 'd%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(96 183)') where  c1 like 'r%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(57 91)') where  c1 like 'q%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(202 110)') where  c1 like 'c%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(120 137)') where  c1 like 'w%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(207 147)') where  c1 like 'c%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(31 125)') where  c1 like 'e%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(27 36)') where  c1 like 'r%';
+INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES
+('b', 'c', 'e', GeomFromText('POINT(41 137)')),
+('p', 'y', 'k', GeomFromText('POINT(50 22)')),
+('s', 'c', 'h', GeomFromText('POINT(208 173)')),
+('x', 'u', 'l', GeomFromText('POINT(199 175)')),
+('s', 'r', 'h', GeomFromText('POINT(85 192)')),
+('j', 'k', 'u', GeomFromText('POINT(18 25)')),
+('p', 'w', 'h', GeomFromText('POINT(152 197)')),
+('e', 'd', 'c', GeomFromText('POINT(229 3)')),
+('o', 'x', 'k', GeomFromText('POINT(187 155)')),
+('o', 'b', 'k', GeomFromText('POINT(208 150)')),
+('d', 'a', 'j', GeomFromText('POINT(70 87)')),
+('f', 'e', 'k', GeomFromText('POINT(156 96)')),
+('u', 'y', 'p', GeomFromText('POINT(239 193)')),
+('n', 'v', 'p', GeomFromText('POINT(223 98)')),
+('z', 'j', 'r', GeomFromText('POINT(87 89)')),
+('h', 'x', 'x', GeomFromText('POINT(92 0)')),
+('r', 'v', 'r', GeomFromText('POINT(159 139)')),
+('v', 'g', 'g', GeomFromText('POINT(16 229)')),
+('z', 'k', 'u', GeomFromText('POINT(99 52)')),
+('p', 'p', 'o', GeomFromText('POINT(105 125)')),
+('w', 'h', 'y', GeomFromText('POINT(105 154)')),
+('v', 'y', 'z', GeomFromText('POINT(134 238)')),
+('x', 'o', 'o', GeomFromText('POINT(178 88)')),
+('z', 'w', 'd', GeomFromText('POINT(123 60)')),
+('q', 'f', 'u', GeomFromText('POINT(64 90)')),
+('s', 'n', 't', GeomFromText('POINT(50 138)')),
+('v', 'p', 't', GeomFromText('POINT(114 91)')),
+('a', 'o', 'n', GeomFromText('POINT(78 43)')),
+('k', 'u', 'd', GeomFromText('POINT(185 161)')),
+('w', 'd', 'n', GeomFromText('POINT(25 92)')),
+('k', 'w', 'a', GeomFromText('POINT(59 238)')),
+('t', 'c', 'f', GeomFromText('POINT(65 87)')),
+('g', 's', 'p', GeomFromText('POINT(238 126)')),
+('d', 'n', 'y', GeomFromText('POINT(107 173)')),
+('l', 'a', 'w', GeomFromText('POINT(125 152)')),
+('m', 'd', 'j', GeomFromText('POINT(146 53)')),
+('q', 'm', 'c', GeomFromText('POINT(217 187)')),
+('i', 'r', 'r', GeomFromText('POINT(6 113)')),
+('e', 'j', 'b', GeomFromText('POINT(37 83)')),
+('w', 'w', 'h', GeomFromText('POINT(83 199)')),
+('k', 'b', 's', GeomFromText('POINT(170 64)')),
+('s', 'b', 'c', GeomFromText('POINT(163 130)')),
+('c', 'h', 'a', GeomFromText('POINT(141 3)')),
+('k', 'j', 'u', GeomFromText('POINT(143 76)')),
+('r', 'h', 'o', GeomFromText('POINT(243 92)')),
+('i', 'd', 'b', GeomFromText('POINT(205 13)')),
+('r', 'y', 'q', GeomFromText('POINT(138 8)')),
+('m', 'o', 'i', GeomFromText('POINT(36 45)')),
+('v', 'g', 'm', GeomFromText('POINT(0 40)')),
+('f', 'e', 'i', GeomFromText('POINT(76 6)')),
+('c', 'q', 'q', GeomFromText('POINT(115 248)')),
+('x', 'c', 'i', GeomFromText('POINT(29 74)')),
+('l', 's', 't', GeomFromText('POINT(83 18)')),
+('t', 't', 'a', GeomFromText('POINT(26 168)')),
+('u', 'n', 'x', GeomFromText('POINT(200 110)')),
+('j', 'b', 'd', GeomFromText('POINT(216 136)')),
+('s', 'p', 'w', GeomFromText('POINT(38 156)')),
+('f', 'b', 'v', GeomFromText('POINT(29 186)')),
+('v', 'e', 'r', GeomFromText('POINT(149 40)')),
+('v', 't', 'm', GeomFromText('POINT(184 24)')),
+('y', 'g', 'a', GeomFromText('POINT(219 105)')),
+('s', 'f', 'i', GeomFromText('POINT(114 130)')),
+('e', 'q', 'h', GeomFromText('POINT(203 135)')),
+('h', 'g', 'b', GeomFromText('POINT(9 208)')),
+('o', 'l', 'r', GeomFromText('POINT(245 79)')),
+('s', 's', 'v', GeomFromText('POINT(238 198)')),
+('w', 'w', 'z', GeomFromText('POINT(209 232)')),
+('v', 'd', 'n', GeomFromText('POINT(30 193)')),
+('q', 'w', 'k', GeomFromText('POINT(133 18)')),
+('o', 'h', 'o', GeomFromText('POINT(42 140)')),
+('f', 'f', 'h', GeomFromText('POINT(145 1)')),
+('u', 's', 'r', GeomFromText('POINT(70 62)')),
+('x', 'n', 'q', GeomFromText('POINT(33 86)')),
+('u', 'p', 'v', GeomFromText('POINT(232 220)')),
+('z', 'e', 'a', GeomFromText('POINT(130 69)')),
+('r', 'u', 'z', GeomFromText('POINT(243 241)')),
+('b', 'n', 't', GeomFromText('POINT(120 12)')),
+('u', 'f', 's', GeomFromText('POINT(190 212)')),
+('a', 'd', 'q', GeomFromText('POINT(235 191)')),
+('f', 'q', 'm', GeomFromText('POINT(176 2)')),
+('n', 'c', 's', GeomFromText('POINT(218 163)')),
+('e', 'm', 'h', GeomFromText('POINT(163 108)')),
+('c', 'f', 'l', GeomFromText('POINT(220 115)')),
+('c', 'v', 'q', GeomFromText('POINT(66 45)')),
+('w', 'v', 'x', GeomFromText('POINT(251 220)')),
+('f', 'w', 'z', GeomFromText('POINT(146 149)')),
+('h', 'n', 'h', GeomFromText('POINT(148 128)')),
+('y', 'k', 'v', GeomFromText('POINT(28 110)')),
+('c', 'x', 'q', GeomFromText('POINT(13 13)')),
+('e', 'd', 's', GeomFromText('POINT(91 190)')),
+('c', 'w', 'c', GeomFromText('POINT(10 231)')),
+('u', 'j', 'n', GeomFromText('POINT(250 21)')),
+('w', 'n', 'x', GeomFromText('POINT(141 69)')),
+('f', 'p', 'y', GeomFromText('POINT(228 246)')),
+('d', 'q', 'f', GeomFromText('POINT(194 22)')),
+('d', 'z', 'l', GeomFromText('POINT(233 181)')),
+('c', 'a', 'q', GeomFromText('POINT(183 96)')),
+('m', 'i', 'd', GeomFromText('POINT(117 226)')),
+('z', 'y', 'y', GeomFromText('POINT(62 81)')),
+('g', 'v', 'm', GeomFromText('POINT(66 158)'));
+SET @@RAND_SEED1=481064922, @@RAND_SEED2=438133497;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=280535103, @@RAND_SEED2=444518646;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=1072017234, @@RAND_SEED2=484203885;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=358851897, @@RAND_SEED2=358495224;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=509031459, @@RAND_SEED2=675962925;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+UPDATE t1 set spatial_point=GeomFromText('POINT(61 203)') where  c1 like 'y%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(202 194)') where  c1 like 'f%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(228 18)') where  c1 like 'h%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(88 18)') where  c1 like 'l%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(176 94)') where  c1 like 'e%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(44 47)') where  c1 like 'g%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(95 191)') where  c1 like 'b%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(179 218)') where  c1 like 'y%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(239 40)') where  c1 like 'g%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(248 41)') where  c1 like 'q%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(167 82)') where  c1 like 't%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(13 104)') where  c1 like 'u%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(139 84)') where  c1 like 'a%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(145 108)') where  c1 like 'p%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(147 57)') where  c1 like 't%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(217 144)') where  c1 like 'n%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(160 224)') where  c1 like 'w%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(38 28)') where  c1 like 'j%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(104 114)') where  c1 like 'q%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(88 19)') where  c1 like 'c%';
+INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES
+('f', 'x', 'p', GeomFromText('POINT(92 181)')),
+('s', 'i', 'c', GeomFromText('POINT(49 60)')),
+('c', 'c', 'i', GeomFromText('POINT(7 57)')),
+('n', 'g', 'k', GeomFromText('POINT(252 105)')),
+('g', 'b', 'm', GeomFromText('POINT(180 11)')),
+('u', 'l', 'r', GeomFromText('POINT(32 90)')),
+('c', 'x', 'e', GeomFromText('POINT(143 24)')),
+('x', 'u', 'a', GeomFromText('POINT(123 92)')),
+('s', 'b', 'h', GeomFromText('POINT(190 108)')),
+('c', 'x', 'b', GeomFromText('POINT(104 100)')),
+('i', 'd', 't', GeomFromText('POINT(214 104)')),
+('r', 'w', 'g', GeomFromText('POINT(29 67)')),
+('b', 'f', 'g', GeomFromText('POINT(149 46)')),
+('r', 'r', 'd', GeomFromText('POINT(242 196)')),
+('j', 'l', 'a', GeomFromText('POINT(90 196)')),
+('e', 't', 'b', GeomFromText('POINT(190 64)')),
+('l', 'x', 'w', GeomFromText('POINT(250 73)')),
+('q', 'y', 'r', GeomFromText('POINT(120 182)')),
+('s', 'j', 'a', GeomFromText('POINT(180 175)')),
+('n', 'i', 'y', GeomFromText('POINT(124 136)')),
+('s', 'x', 's', GeomFromText('POINT(176 209)')),
+('u', 'f', 's', GeomFromText('POINT(215 173)')),
+('m', 'j', 'x', GeomFromText('POINT(44 140)')),
+('v', 'g', 'x', GeomFromText('POINT(177 233)')),
+('u', 't', 'b', GeomFromText('POINT(136 197)')),
+('f', 'g', 'b', GeomFromText('POINT(10 8)')),
+('v', 'c', 'j', GeomFromText('POINT(13 81)')),
+('d', 's', 'q', GeomFromText('POINT(200 100)')),
+('a', 'p', 'j', GeomFromText('POINT(33 40)')),
+('i', 'c', 'g', GeomFromText('POINT(168 204)')),
+('k', 'h', 'i', GeomFromText('POINT(93 243)')),
+('s', 'b', 's', GeomFromText('POINT(157 13)')),
+('v', 'l', 'l', GeomFromText('POINT(103 6)')),
+('r', 'b', 'k', GeomFromText('POINT(244 137)')),
+('l', 'd', 'r', GeomFromText('POINT(162 254)')),
+('q', 'b', 'z', GeomFromText('POINT(136 246)')),
+('x', 'x', 'p', GeomFromText('POINT(120 37)')),
+('m', 'e', 'z', GeomFromText('POINT(203 167)')),
+('q', 'n', 'p', GeomFromText('POINT(94 119)')),
+('b', 'g', 'u', GeomFromText('POINT(93 248)')),
+('r', 'v', 'v', GeomFromText('POINT(53 88)')),
+('y', 'a', 'i', GeomFromText('POINT(98 219)')),
+('a', 's', 'g', GeomFromText('POINT(173 138)')),
+('c', 'a', 't', GeomFromText('POINT(235 135)')),
+('q', 'm', 'd', GeomFromText('POINT(224 208)')),
+('e', 'p', 'k', GeomFromText('POINT(161 238)')),
+('n', 'g', 'q', GeomFromText('POINT(35 204)')),
+('t', 't', 'x', GeomFromText('POINT(230 178)')),
+('w', 'f', 'a', GeomFromText('POINT(150 221)')),
+('z', 'm', 'z', GeomFromText('POINT(119 42)')),
+('l', 'j', 's', GeomFromText('POINT(97 96)')),
+('f', 'z', 'x', GeomFromText('POINT(208 65)')),
+('i', 'v', 'c', GeomFromText('POINT(145 79)')),
+('l', 'f', 'k', GeomFromText('POINT(83 234)')),
+('u', 'a', 's', GeomFromText('POINT(250 49)')),
+('o', 'k', 'p', GeomFromText('POINT(46 50)')),
+('d', 'e', 'z', GeomFromText('POINT(30 198)')),
+('r', 'r', 'l', GeomFromText('POINT(78 189)')),
+('y', 'l', 'f', GeomFromText('POINT(188 132)')),
+('d', 'q', 'm', GeomFromText('POINT(247 107)')),
+('p', 'j', 'n', GeomFromText('POINT(148 227)')),
+('b', 'o', 'i', GeomFromText('POINT(172 25)')),
+('e', 'v', 'd', GeomFromText('POINT(94 248)')),
+('q', 'd', 'f', GeomFromText('POINT(15 29)')),
+('w', 'b', 'b', GeomFromText('POINT(74 111)')),
+('g', 'q', 'f', GeomFromText('POINT(107 215)')),
+('o', 'h', 'r', GeomFromText('POINT(25 168)')),
+('u', 't', 'w', GeomFromText('POINT(251 188)')),
+('h', 's', 'w', GeomFromText('POINT(254 247)')),
+('f', 'f', 'b', GeomFromText('POINT(166 103)'));
+SET @@RAND_SEED1=866613816, @@RAND_SEED2=92289615;
+INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES
+('l', 'c', 'l', GeomFromText('POINT(202 98)')),
+('k', 'c', 'b', GeomFromText('POINT(46 206)')),
+('r', 'y', 'm', GeomFromText('POINT(74 140)')),
+('y', 'z', 'd', GeomFromText('POINT(200 160)')),
+('s', 'y', 's', GeomFromText('POINT(156 205)')),
+('u', 'v', 'p', GeomFromText('POINT(86 82)')),
+('j', 's', 's', GeomFromText('POINT(91 233)')),
+('x', 'j', 'f', GeomFromText('POINT(3 14)')),
+('l', 'z', 'v', GeomFromText('POINT(123 156)')),
+('h', 'i', 'o', GeomFromText('POINT(145 229)')),
+('o', 'r', 'd', GeomFromText('POINT(15 22)')),
+('f', 'x', 't', GeomFromText('POINT(21 60)')),
+('t', 'g', 'h', GeomFromText('POINT(50 153)')),
+('g', 'u', 'b', GeomFromText('POINT(82 85)')),
+('v', 'a', 'p', GeomFromText('POINT(231 178)')),
+('n', 'v', 'o', GeomFromText('POINT(183 25)')),
+('j', 'n', 'm', GeomFromText('POINT(50 144)')),
+('e', 'f', 'i', GeomFromText('POINT(46 16)')),
+('d', 'w', 'a', GeomFromText('POINT(66 6)')),
+('f', 'x', 'a', GeomFromText('POINT(107 197)')),
+('m', 'o', 'a', GeomFromText('POINT(142 80)')),
+('q', 'l', 'g', GeomFromText('POINT(251 23)')),
+('c', 's', 's', GeomFromText('POINT(158 43)')),
+('y', 'd', 'o', GeomFromText('POINT(196 228)')),
+('d', 'p', 'l', GeomFromText('POINT(107 5)')),
+('h', 'a', 'b', GeomFromText('POINT(183 166)')),
+('m', 'w', 'p', GeomFromText('POINT(19 59)')),
+('b', 'y', 'o', GeomFromText('POINT(178 30)')),
+('x', 'w', 'i', GeomFromText('POINT(168 94)')),
+('t', 'k', 'z', GeomFromText('POINT(171 5)')),
+('r', 'm', 'a', GeomFromText('POINT(222 19)')),
+('u', 'v', 'e', GeomFromText('POINT(224 80)')),
+('q', 'r', 'k', GeomFromText('POINT(212 218)')),
+('d', 'p', 'j', GeomFromText('POINT(169 7)')),
+('d', 'r', 'v', GeomFromText('POINT(193 23)')),
+('n', 'y', 'y', GeomFromText('POINT(130 178)')),
+('m', 'z', 'r', GeomFromText('POINT(81 200)')),
+('j', 'e', 'w', GeomFromText('POINT(145 239)')),
+('v', 'h', 'x', GeomFromText('POINT(24 105)')),
+('z', 'm', 'a', GeomFromText('POINT(175 129)')),
+('b', 'c', 'v', GeomFromText('POINT(213 10)')),
+('t', 't', 'u', GeomFromText('POINT(2 129)')),
+('r', 's', 'v', GeomFromText('POINT(209 192)')),
+('x', 'p', 'g', GeomFromText('POINT(43 63)')),
+('t', 'e', 'u', GeomFromText('POINT(139 210)')),
+('l', 'e', 't', GeomFromText('POINT(245 148)')),
+('a', 'i', 'k', GeomFromText('POINT(167 195)')),
+('m', 'o', 'h', GeomFromText('POINT(206 120)')),
+('g', 'z', 's', GeomFromText('POINT(169 240)')),
+('z', 'u', 's', GeomFromText('POINT(202 120)')),
+('i', 'b', 'a', GeomFromText('POINT(216 18)')),
+('w', 'y', 'g', GeomFromText('POINT(119 236)')),
+('h', 'y', 'p', GeomFromText('POINT(161 24)'));
+UPDATE t1 set spatial_point=GeomFromText('POINT(33 100)') where  c1 like 't%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(41 46)') where  c1 like 'f%';
+CHECK TABLE t1 EXTENDED;
+Table	Op	Msg_type	Msg_text
+test.t1	check	status	OK
+DROP TABLE t1;
 CREATE TABLE t1(foo GEOMETRY NOT NULL, SPATIAL INDEX(foo) );
 INSERT INTO t1(foo) VALUES (NULL);
 ERROR 23000: Column 'foo' cannot be null
diff --git a/mysql-test/r/having.result b/mysql-test/r/having.result
index 721d17c97a4..149391396b6 100644
--- a/mysql-test/r/having.result
+++ b/mysql-test/r/having.result
@@ -12,7 +12,7 @@ explain extended select count(a) as b from t1 where a=0 having b >=0;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE noticed after reading const tables
 Warnings:
-Note	1003	select count(`test`.`t1`.`a`) AS `b` from `test`.`t1` where 0 having (`b` >= 0)
+Note	1003	select count('0') AS `b` from `test`.`t1` where 0 having (`b` >= 0)
 drop table t1;
 CREATE TABLE t1 (
 raw_id int(10) NOT NULL default '0',
diff --git a/mysql-test/r/heap.result b/mysql-test/r/heap.result
index 29bdfcbef7a..ddf675e2f73 100644
--- a/mysql-test/r/heap.result
+++ b/mysql-test/r/heap.result
@@ -731,3 +731,10 @@ SELECT COUNT(*) FROM t1 WHERE c=REPEAT('a',256);
 COUNT(*)
 2
 DROP TABLE t1;
+CREATE TABLE t1(c1 VARCHAR(100), c2 INT) ENGINE=MEMORY;
+INSERT INTO t1 VALUES('', 0);
+ALTER TABLE t1 MODIFY c1 VARCHAR(101);
+SELECT c2 FROM t1;
+c2
+0
+DROP TABLE t1;
diff --git a/mysql-test/r/merge.result b/mysql-test/r/merge.result
index c654392f6e1..34f1b76ba05 100644
--- a/mysql-test/r/merge.result
+++ b/mysql-test/r/merge.result
@@ -806,6 +806,24 @@ CREATE TABLE tm1(a SMALLINT, b SMALLINT, KEY(a)) ENGINE=MERGE UNION=(t1);
 SELECT * FROM tm1;
 ERROR HY000: Unable to open underlying table which is differently defined or of non-MyISAM type or doesn't exist
 DROP TABLE t1, tm1;
+CREATE TABLE t1(c1 INT) ENGINE=MyISAM;
+CREATE TABLE t2(c1 INT) ENGINE=MERGE UNION=(t1);
+INSERT DELAYED INTO t2 VALUES(1);
+ERROR HY000: Table storage engine for 't2' doesn't have this option
+DROP TABLE t1, t2;
+CREATE TABLE t1(c1 VARCHAR(1));
+CREATE TABLE m1 LIKE t1;
+ALTER TABLE m1 ENGINE=MERGE UNION=(t1);
+SELECT * FROM m1;
+c1
+DROP TABLE t1, m1;
+CREATE TABLE t1(c1 VARCHAR(4), c2 TINYINT, c3 TINYINT, c4 TINYINT,
+c5 TINYINT, c6 TINYINT, c7 TINYINT, c8 TINYINT, c9 TINYINT);
+CREATE TABLE m1 LIKE t1;
+ALTER TABLE m1 ENGINE=MERGE UNION=(t1);
+SELECT * FROM m1;
+c1	c2	c3	c4	c5	c6	c7	c8	c9
+DROP TABLE t1, m1;
 create table t1 (b bit(1));
 create table t2 (b bit(1));
 create table tm (b bit(1)) engine = merge union = (t1,t2);
diff --git a/mysql-test/r/ndb_single_user.result b/mysql-test/r/ndb_single_user.result
index 711d343fffb..771a02ecc84 100644
--- a/mysql-test/r/ndb_single_user.result
+++ b/mysql-test/r/ndb_single_user.result
@@ -1,7 +1,7 @@
 use test;
 drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9,t10;
 create table t1 (a int key, b int unique, c int) engine ndb;
-ERROR HY000: Can't create table './test/t1.frm' (errno: 155)
+ERROR HY000: Can't create table 'test.t1' (errno: 4007)
 create table t1 (a int key, b int unique, c int) engine ndb;
 insert into t1 values (1,1,0),(2,2,0),(3,3,0),(4,4,0),(5,5,0),(6,6,0),(7,7,0),(8,8,0),(9,9,0),(10,10,0);
 create table t2 as select * from t1;
diff --git a/mysql-test/r/olap.result b/mysql-test/r/olap.result
index fd657c93bd7..66499946b63 100644
--- a/mysql-test/r/olap.result
+++ b/mysql-test/r/olap.result
@@ -645,3 +645,12 @@ a	LENGTH(a)	COUNT(*)
 NULL	NULL	2
 DROP VIEW v1;
 DROP TABLE t1;
+CREATE TABLE t1 (a int, KEY (a));
+INSERT INTO t1 VALUES (3), (1), (4), (1), (3), (1), (1);
+SELECT * FROM (SELECT a, SUM(a) FROM t1 GROUP BY a WITH ROLLUP) as t;
+a	SUM(a)
+1	4
+3	6
+4	4
+NULL	14
+DROP TABLE t1;
diff --git a/mysql-test/r/order_by.result b/mysql-test/r/order_by.result
index b48e87de38e..8a19cfcded2 100644
--- a/mysql-test/r/order_by.result
+++ b/mysql-test/r/order_by.result
@@ -950,6 +950,14 @@ NULL
 2
 3
 DROP TABLE t1,t2,t3,t4;
+create table t1 (a int, b int, c int);
+insert into t1 values (1,2,3), (9,8,3), (19,4,3), (1,4,9);
+select a,(sum(b)/sum(c)) as ratio from t1 group by a order by sum(b)/sum(c) asc;
+a	ratio
+1	0.5000
+19	1.3333
+9	2.6667
+drop table t1;
 CREATE TABLE t1 (a INT, b INT, PRIMARY KEY (a), UNIQUE KEY b (b));
 INSERT INTO t1 VALUES (1,1),(2,2);
 CREATE TABLE t2 (a INT, b INT, KEY a (a,b));
diff --git a/mysql-test/r/sp.result b/mysql-test/r/sp.result
index c73a44042c3..c46558fb08f 100644
--- a/mysql-test/r/sp.result
+++ b/mysql-test/r/sp.result
@@ -5857,4 +5857,17 @@ func_8407_b()
 1500
 drop function func_8407_a|
 drop function func_8407_b|
+DROP FUNCTION IF EXISTS bug25373|
+CREATE FUNCTION bug25373(p1 INTEGER) RETURNS INTEGER
+LANGUAGE SQL DETERMINISTIC
+RETURN p1;|
+CREATE TABLE t3 (f1 INT, f2 FLOAT)|
+INSERT INTO t3 VALUES (1, 3.4), (1, 2), (1, 0.9), (2, 8), (2, 7)|
+SELECT SUM(f2), bug25373(f1) FROM t3 GROUP BY bug25373(f1) WITH ROLLUP|
+SUM(f2)	bug25373(f1)
+6.3000000715256	1
+15	2
+21.300000071526	NULL
+DROP FUNCTION bug25373|
+DROP TABLE t3|
 drop table t1,t2;
diff --git a/mysql-test/r/subselect.result b/mysql-test/r/subselect.result
index 30e6d073d9a..2afdd045203 100644
--- a/mysql-test/r/subselect.result
+++ b/mysql-test/r/subselect.result
@@ -50,7 +50,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 Warnings:
 Note	1276	Field or reference 'a' of SELECT #3 was resolved in SELECT #1
 Note	1276	Field or reference 'b.a' of SELECT #3 was resolved in SELECT #1
-Note	1003	select 1 AS `1` from (select 1 AS `a`) `b` having ((select `b`.`a` AS `a`) = 1)
+Note	1003	select 1 AS `1` from (select 1 AS `a`) `b` having ((select '1' AS `a`) = 1)
 SELECT 1 FROM (SELECT 1 as a) as b HAVING (SELECT a)=1;
 1
 1
@@ -204,7 +204,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 3	DERIVED	t2	ALL	NULL	NULL	NULL	NULL	2	100.00	Using where
 2	SUBQUERY	t3	ALL	NULL	NULL	NULL	NULL	3	100.00	Using where; Using filesort
 Warnings:
-Note	1003	select (select `test`.`t3`.`a` AS `a` from `test`.`t3` where (`test`.`t3`.`a` < 8) order by 1 desc limit 1) AS `(select t3.a from t3 where a<8 order by 1 desc limit 1)`,`tt`.`a` AS `a` from (select `test`.`t2`.`a` AS `a`,`test`.`t2`.`b` AS `b` from `test`.`t2` where (`test`.`t2`.`a` > 1)) `tt`
+Note	1003	select (select `test`.`t3`.`a` AS `a` from `test`.`t3` where (`test`.`t3`.`a` < 8) order by 1 desc limit 1) AS `(select t3.a from t3 where a<8 order by 1 desc limit 1)`,'2' AS `a` from (select `test`.`t2`.`a` AS `a`,`test`.`t2`.`b` AS `b` from `test`.`t2` where (`test`.`t2`.`a` > 1)) `tt`
 select * from t1 where t1.a=(select t2.a from t2 where t2.b=(select max(a) from t3) order by 1 desc limit 1);
 a
 2
@@ -315,7 +315,7 @@ NULL	UNION RESULT	<union2,3>	ALL	NULL	NULL	NULL	NULL	NULL	NULL
 Warnings:
 Note	1276	Field or reference 'test.t2.a' of SELECT #2 was resolved in SELECT #1
 Note	1276	Field or reference 'test.t2.a' of SELECT #3 was resolved in SELECT #1
-Note	1003	select (select `test`.`t1`.`a` AS `a` from `test`.`t1` where (`test`.`t1`.`a` = `test`.`t2`.`a`) union select `test`.`t5`.`a` AS `a` from `test`.`t5` where (`test`.`t5`.`a` = `test`.`t2`.`a`)) AS `(select a from t1 where t1.a=t2.a union select a from t5 where t5.a=t2.a)`,`test`.`t2`.`a` AS `a` from `test`.`t2`
+Note	1003	select (select '2' AS `a` from `test`.`t1` where ('2' = `test`.`t2`.`a`) union select `test`.`t5`.`a` AS `a` from `test`.`t5` where (`test`.`t5`.`a` = `test`.`t2`.`a`)) AS `(select a from t1 where t1.a=t2.a union select a from t5 where t5.a=t2.a)`,`test`.`t2`.`a` AS `a` from `test`.`t2`
 select (select a from t1 where t1.a=t2.a union all select a from t5 where t5.a=t2.a), a from t2;
 ERROR 21000: Subquery returns more than 1 row
 create table t6 (patient_uq int, clinic_uq int, index i1 (clinic_uq));
@@ -368,7 +368,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 2	SUBQUERY	t8	const	PRIMARY	PRIMARY	37	const	1	100.00	
 3	SUBQUERY	t8	const	PRIMARY	PRIMARY	37		1	100.00	Using index
 Warnings:
-Note	1003	select `test`.`t8`.`pseudo` AS `pseudo`,(select `test`.`t8`.`email` AS `email` from `test`.`t8` where 1) AS `(SELECT email FROM t8 WHERE pseudo=(SELECT pseudo FROM t8 WHERE pseudo='joce'))` from `test`.`t8` where 1
+Note	1003	select 'joce' AS `pseudo`,(select 'test' AS `email` from `test`.`t8` where 1) AS `(SELECT email FROM t8 WHERE pseudo=(SELECT pseudo FROM t8 WHERE pseudo='joce'))` from `test`.`t8` where 1
 SELECT pseudo FROM t8 WHERE pseudo=(SELECT pseudo,email FROM
 t8 WHERE pseudo='joce');
 ERROR 21000: Operand should contain 1 column(s)
@@ -421,7 +421,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 3	UNION	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	No tables used
 NULL	UNION RESULT	<union2,3>	ALL	NULL	NULL	NULL	NULL	NULL	NULL	
 Warnings:
-Note	1003	select 1 AS `1` from `test`.`t1`
+Note	1003	select 1 AS `1` from `test`.`t1` where 1
 drop table t1;
 CREATE TABLE `t1` (
 `numeropost` mediumint(8) unsigned NOT NULL auto_increment,
@@ -547,7 +547,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	PRIMARY	t1	const	PRIMARY,numreponse	PRIMARY	7	const,const	1	100.00	Using index
 2	SUBQUERY	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Select tables optimized away
 Warnings:
-Note	1003	select `test`.`t1`.`numreponse` AS `numreponse` from `test`.`t1` where ((`test`.`t1`.`numeropost` = _latin1'1'))
+Note	1003	select '3' AS `numreponse` from `test`.`t1` where (('1' = _latin1'1'))
 drop table t1;
 CREATE TABLE t1 (a int(1));
 INSERT INTO t1 VALUES (1);
@@ -1180,7 +1180,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	PRIMARY	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	No tables used
 2	DEPENDENT SUBQUERY	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE
 Warnings:
-Note	1003	select <in_optimizer>(0,<exists>(select 1 AS `Not_used` from `test`.`t1` `a`)) AS `0 IN (SELECT 1 FROM t1 a)`
+Note	1003	select <in_optimizer>(0,<exists>(select 1 AS `Not_used` from `test`.`t1` `a` where 0)) AS `0 IN (SELECT 1 FROM t1 a)`
 INSERT INTO t1 (pseudo) VALUES ('test1');
 SELECT 0 IN (SELECT 1 FROM t1 a);
 0 IN (SELECT 1 FROM t1 a)
@@ -1190,7 +1190,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	PRIMARY	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	No tables used
 2	DEPENDENT SUBQUERY	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE
 Warnings:
-Note	1003	select <in_optimizer>(0,<exists>(select 1 AS `Not_used` from `test`.`t1` `a`)) AS `0 IN (SELECT 1 FROM t1 a)`
+Note	1003	select <in_optimizer>(0,<exists>(select 1 AS `Not_used` from `test`.`t1` `a` where 0)) AS `0 IN (SELECT 1 FROM t1 a)`
 drop table t1;
 CREATE TABLE `t1` (
 `i` int(11) NOT NULL default '0',
@@ -1430,7 +1430,7 @@ explain extended (select * from t1);
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	SIMPLE	t1	system	NULL	NULL	NULL	NULL	1	100.00	
 Warnings:
-Note	1003	(select `test`.`t1`.`s1` AS `s1` from `test`.`t1`)
+Note	1003	(select 'tttt' AS `s1` from `test`.`t1`)
 (select * from t1);
 s1
 tttt
@@ -1497,7 +1497,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	PRIMARY	t3	ALL	NULL	NULL	NULL	NULL	3	100.00	Using where
 2	SUBQUERY	t2	system	NULL	NULL	NULL	NULL	0	0.00	const row not found
 Warnings:
-Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3` where <not>((`test`.`t3`.`a` < (select max(`test`.`t2`.`b`) from `test`.`t2`)))
+Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3` where <not>((`test`.`t3`.`a` < (select max('0') from `test`.`t2`)))
 select * from t3 where a >= some (select b from t2);
 a
 explain extended select * from t3 where a >= some (select b from t2);
@@ -1505,7 +1505,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	PRIMARY	t3	ALL	NULL	NULL	NULL	NULL	3	100.00	Using where
 2	SUBQUERY	t2	system	NULL	NULL	NULL	NULL	0	0.00	const row not found
 Warnings:
-Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3` where <nop>((`test`.`t3`.`a` >= (select min(`test`.`t2`.`b`) from `test`.`t2`)))
+Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3` where <nop>((`test`.`t3`.`a` >= (select min('0') from `test`.`t2`)))
 select * from t3 where a >= all (select b from t2 group by 1);
 a
 6
@@ -1516,7 +1516,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	PRIMARY	t3	ALL	NULL	NULL	NULL	NULL	3	100.00	Using where
 2	SUBQUERY	t2	system	NULL	NULL	NULL	NULL	0	0.00	const row not found
 Warnings:
-Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3` where <not>((`test`.`t3`.`a` < <max>(select `test`.`t2`.`b` AS `b` from `test`.`t2` group by 1)))
+Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3` where <not>((`test`.`t3`.`a` < <max>(select '0' AS `b` from `test`.`t2` group by 1)))
 select * from t3 where a >= some (select b from t2 group by 1);
 a
 explain extended select * from t3 where a >= some (select b from t2 group by 1);
@@ -1524,7 +1524,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	PRIMARY	t3	ALL	NULL	NULL	NULL	NULL	3	100.00	Using where
 2	SUBQUERY	t2	system	NULL	NULL	NULL	NULL	0	0.00	const row not found
 Warnings:
-Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3` where <nop>((`test`.`t3`.`a` >= <min>(select `test`.`t2`.`b` AS `b` from `test`.`t2` group by 1)))
+Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3` where <nop>((`test`.`t3`.`a` >= <min>(select '0' AS `b` from `test`.`t2` group by 1)))
 select * from t3 where NULL >= any (select b from t2);
 a
 explain extended select * from t3 where NULL >= any (select b from t2);
@@ -1532,7 +1532,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	PRIMARY	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE
 2	SUBQUERY	t2	system	NULL	NULL	NULL	NULL	0	0.00	const row not found
 Warnings:
-Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3`
+Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3` where 0
 select * from t3 where NULL >= any (select b from t2 group by 1);
 a
 explain extended select * from t3 where NULL >= any (select b from t2 group by 1);
@@ -1540,7 +1540,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	PRIMARY	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE
 2	SUBQUERY	t2	system	NULL	NULL	NULL	NULL	0	0.00	const row not found
 Warnings:
-Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3`
+Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3` where 0
 select * from t3 where NULL >= some (select b from t2);
 a
 explain extended select * from t3 where NULL >= some (select b from t2);
@@ -1548,7 +1548,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	PRIMARY	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE
 2	SUBQUERY	t2	system	NULL	NULL	NULL	NULL	0	0.00	const row not found
 Warnings:
-Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3`
+Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3` where 0
 select * from t3 where NULL >= some (select b from t2 group by 1);
 a
 explain extended select * from t3 where NULL >= some (select b from t2 group by 1);
@@ -1556,7 +1556,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	PRIMARY	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE
 2	SUBQUERY	t2	system	NULL	NULL	NULL	NULL	0	0.00	const row not found
 Warnings:
-Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3`
+Note	1003	select `test`.`t3`.`a` AS `a` from `test`.`t3` where 0
 insert into t2 values (2,2), (2,1), (3,3), (3,1);
 select * from t3 where a > all (select max(b) from t2 group by a);
 a
@@ -1618,7 +1618,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 3	UNION	t1	system	NULL	NULL	NULL	NULL	1	100.00	
 NULL	UNION RESULT	<union2,3>	ALL	NULL	NULL	NULL	NULL	NULL	NULL	
 Warnings:
-Note	1003	select `test`.`t1`.`s1` AS `s1` from `test`.`t1`
+Note	1003	select 'e' AS `s1` from `test`.`t1` where 1
 drop table t1;
 CREATE TABLE t1 (number char(11) NOT NULL default '') ENGINE=MyISAM CHARSET=latin1;
 INSERT INTO t1 VALUES ('69294728265'),('18621828126'),('89356874041'),('95895001874');
diff --git a/mysql-test/r/union.result b/mysql-test/r/union.result
index 9805b788a73..2c33ffc08d7 100644
--- a/mysql-test/r/union.result
+++ b/mysql-test/r/union.result
@@ -480,7 +480,7 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 2	UNION	t2	const	PRIMARY	PRIMARY	4	const	1	100.00	
 NULL	UNION RESULT	<union1,2>	ALL	NULL	NULL	NULL	NULL	NULL	NULL	
 Warnings:
-Note	1003	(select `test`.`t1`.`a` AS `a`,`test`.`t1`.`b` AS `b` from `test`.`t1` where (`test`.`t1`.`a` = 1)) union (select `test`.`t2`.`a` AS `a`,`test`.`t2`.`b` AS `b` from `test`.`t2` where (`test`.`t2`.`a` = 1))
+Note	1003	(select '1' AS `a`,'1' AS `b` from `test`.`t1` where ('1' = 1)) union (select '1' AS `a`,'10' AS `b` from `test`.`t2` where ('1' = 1))
 (select * from t1 where a=5) union (select * from t2 where a=1);
 a	b
 1	10
@@ -1426,4 +1426,15 @@ select _utf8'12' union select _latin1'12345';
 12
 12
 12345
+CREATE TABLE t1 (a int);
+INSERT INTO t1 VALUES (3),(1),(2),(4),(1);
+SELECT a FROM (SELECT a FROM t1 UNION SELECT a FROM t1 ORDER BY a) AS test;
+a
+1
+2
+3
+4
+SELECT a FROM (SELECT a FROM t1 UNION SELECT a FROM t1 ORDER BY c) AS test;
+ERROR 42S22: Unknown column 'c' in 'order clause'
+DROP TABLE t1;
 End of 5.0 tests
diff --git a/mysql-test/r/update.result b/mysql-test/r/update.result
index a40d3451a62..94b62625c3f 100644
--- a/mysql-test/r/update.result
+++ b/mysql-test/r/update.result
@@ -377,6 +377,10 @@ create table t1(f1 int, `*f2` int);
 insert into t1 values (1,1);
 update t1 set `*f2`=1;
 drop table t1;
+create table t1(f1 int);
+update t1 set f2=1 order by f2;
+ERROR 42S22: Unknown column 'f2' in 'order clause'
+drop table t1;
 CREATE TABLE t1 (
 request_id int unsigned NOT NULL auto_increment,
 user_id varchar(12) default NULL,
diff --git a/mysql-test/r/varbinary.result b/mysql-test/r/varbinary.result
index 583d3046ea7..f30af2ea1a3 100644
--- a/mysql-test/r/varbinary.result
+++ b/mysql-test/r/varbinary.result
@@ -15,7 +15,7 @@ explain extended select * from t1 where UNIQ=0x38afba1d73e6a18a;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
 1	SIMPLE	t1	const	UNIQ	UNIQ	8	const	1	100.00	
 Warnings:
-Note	1003	select `test`.`t1`.`ID` AS `ID`,`test`.`t1`.`UNIQ` AS `UNIQ` from `test`.`t1` where 1
+Note	1003	select '00000001' AS `ID`,'004084688022709641610' AS `UNIQ` from `test`.`t1` where 1
 drop table t1;
 select x'hello';
 ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'x'hello'' at line 1
diff --git a/mysql-test/r/view.result b/mysql-test/r/view.result
index 30043e066db..bc0906b07f3 100644
--- a/mysql-test/r/view.result
+++ b/mysql-test/r/view.result
@@ -3263,6 +3263,43 @@ a IS TRUE	old_istrue	a IS NOT TRUE	old_isnottrue	a IS FALSE	old_isfalse	a IS NOT
 drop view view_24532_a;
 drop view view_24532_b;
 drop table table_24532;
+CREATE TABLE t1 (
+lid int NOT NULL PRIMARY KEY,
+name char(10) NOT NULL
+);
+INSERT INTO t1 (lid, name) VALUES
+(1, 'YES'), (2, 'NO');
+CREATE TABLE t2 (
+id int NOT NULL PRIMARY KEY, 
+gid int NOT NULL,
+lid int NOT NULL,
+dt date
+);
+INSERT INTO t2 (id, gid, lid, dt) VALUES
+(1, 1, 1, '2007-01-01'),(2, 1, 2, '2007-01-02'),
+(3, 2, 2, '2007-02-01'),(4, 2, 1, '2007-02-02');
+SELECT DISTINCT t2.gid AS lgid,
+(SELECT t1.name FROM t1, t2
+WHERE t1.lid  = t2.lid AND t2.gid = lgid
+ORDER BY t2.dt DESC LIMIT 1
+) as clid
+FROM t2;
+lgid	clid
+1	NO
+2	YES
+CREATE VIEW v1 AS
+SELECT DISTINCT t2.gid AS lgid,
+(SELECT t1.name FROM t1, t2
+WHERE t1.lid  = t2.lid AND t2.gid = lgid
+ORDER BY t2.dt DESC LIMIT 1
+) as clid
+FROM t2;
+SELECT * FROM v1;
+lgid	clid
+1	NO
+2	YES
+DROP VIEW v1;
+DROP table t1,t2;
 End of 5.0 tests.
 DROP DATABASE IF EXISTS `d-1`;
 CREATE DATABASE `d-1`;
diff --git a/mysql-test/t/delayed.test b/mysql-test/t/delayed.test
index 3ccee525d10..6f161581287 100644
--- a/mysql-test/t/delayed.test
+++ b/mysql-test/t/delayed.test
@@ -234,3 +234,11 @@ SET             @@session.auto_increment_offset=
 SET             @@session.auto_increment_increment=
     @bug20830_old_session_auto_increment_increment;
 
+#
+# BUG#26238 - inserted delayed always inserts 0 for BIT columns
+#
+CREATE TABLE t1(a BIT);
+INSERT DELAYED INTO t1 VALUES(1);
+FLUSH TABLE t1;
+SELECT HEX(a) FROM t1;
+DROP TABLE t1;
diff --git a/mysql-test/t/disabled.def b/mysql-test/t/disabled.def
index 769c9ab1512..913fe8e62ee 100644
--- a/mysql-test/t/disabled.def
+++ b/mysql-test/t/disabled.def
@@ -38,3 +38,4 @@ synchronization          : Bug#24529  	Test 'synchronization' fails on Mac pushb
 plugin                   : Bug#25659 memory leak via "plugins" test
 rpl_ndb_dd_advance	 : Bug#25913 rpl_ndb_dd_advance fails randomly
 ndb_alter_table		 : Bug##25774 ndb_alter_table.test fails in DBUG_ASSERT() on Linux x64
+ndb_single_user          : Bug#27021 Error codes in mysqld in single user mode varies
diff --git a/mysql-test/t/explain.test b/mysql-test/t/explain.test
index efce0cdf3b5..04cf37f457a 100644
--- a/mysql-test/t/explain.test
+++ b/mysql-test/t/explain.test
@@ -51,4 +51,19 @@ set names latin1;
 select 3 into @v1;
 explain select 3 into @v1;
 
+#
+# Bug#22331: Wrong WHERE in EXPLAIN EXTENDED when all expressions were
+#            optimized away.
+#
+create table t1(f1 int, f2 int);
+insert into t1 values (1,1);
+create view v1 as select * from t1 where f1=1;
+explain extended select * from v1 where f2=1;
+explain extended select * from t1 where 0;
+explain extended select * from t1 where 1;
+explain extended select * from t1 having 0;
+explain extended select * from t1 having 1;
+drop view v1;
+drop table t1;
+
 # End of 5.0 tests.
diff --git a/mysql-test/t/func_in.test b/mysql-test/t/func_in.test
index c4274034889..31352e4c639 100644
--- a/mysql-test/t/func_in.test
+++ b/mysql-test/t/func_in.test
@@ -299,6 +299,68 @@ SELECT STRAIGHT_JOIN
 
 DROP TABLE t1,t2,t3,t4;  
 
+#
+# BUG#19342: IN works incorrectly for BIGINT UNSIGNED values
+#
+CREATE TABLE t1(a BIGINT UNSIGNED);
+INSERT INTO t1 VALUES (0xFFFFFFFFFFFFFFFF);
+
+SELECT * FROM t1 WHERE a=-1 OR a=-2 ;
+SELECT * FROM t1 WHERE a IN (-1, -2);
+
+CREATE TABLE t2 (a BIGINT UNSIGNED);
+insert into t2 values(13491727406643098568),
+       (0x7fffffefffffffff),
+       (0x7ffffffeffffffff),
+       (0x7fffffffefffffff),
+       (0x7ffffffffeffffff),
+       (0x7fffffffffefffff),
+       (0x7ffffffffffeffff),
+       (0x7fffffffffffefff),
+       (0x7ffffffffffffeff),
+       (0x7fffffffffffffef),
+       (0x7ffffffffffffffe),
+       (0x7fffffffffffffff),
+       (0x8000000000000000),
+       (0x8000000000000001),
+       (0x8000000000000002),
+       (0x8000000000000300),
+       (0x8000000000000400),
+       (0x8000000000000401),
+       (0x8000000000004001),
+       (0x8000000000040001),
+       (0x8000000000400001),
+       (0x8000000004000001),
+       (0x8000000040000001),
+       (0x8000000400000001),
+       (0x8000004000000001),
+       (0x8000040000000001);
+
+SELECT HEX(a) FROM t2 WHERE a IN (0xBB3C3E98175D33C8, 42);
+
+SELECT HEX(a) FROM t2 WHERE a IN
+(0xBB3C3E98175D33C8,
+ 0x7fffffffffffffff,
+ 0x8000000000000000,
+ 0x8000000000000400,
+ 0x8000000000000401,
+ 42);
+
+SELECT HEX(a) FROM t2 WHERE a IN (0x7fffffffffffffff,0x8000000000000001);
+SELECT HEX(a) FROM t2 WHERE a IN (0x7ffffffffffffffe,0x7fffffffffffffff);
+SELECT HEX(a) FROM t2 WHERE a IN (0x7ffffffffffffffe,0x7fffffffffffffff,'abc');
+
+CREATE TABLE t3 (a BIGINT UNSIGNED);
+INSERT INTO t3 VALUES (9223372036854775551);
+
+SELECT HEX(a) FROM t3 WHERE a IN (9223372036854775807, 42);
+
+CREATE TABLE t4 (a DATE);
+INSERT INTO t4 VALUES ('1972-02-06'), ('1972-07-29');
+SELECT * FROM t4 WHERE a IN ('1972-02-06','19772-07-29');
+
+DROP TABLE t1,t2,t3,t4;
+
 --echo End of 5.0 tests
 
 
diff --git a/mysql-test/t/func_str.test b/mysql-test/t/func_str.test
index ddab3d03454..849d39cfc32 100644
--- a/mysql-test/t/func_str.test
+++ b/mysql-test/t/func_str.test
@@ -1115,6 +1115,16 @@ select repeat('a', cast(2 as unsigned int));
 select rpad('abc', cast(5 as unsigned integer), 'x');
 select lpad('abc', cast(5 as unsigned integer), 'x');
 
+#
+# Bug#15757: Wrong SUBSTRING() result when a tmp table was employed.
+#
+create table t1(f1 longtext);
+insert into t1 values ("123"),("456");
+select substring(f1,1,1) from t1 group by 1;
+create table t2(f1 varchar(3));
+insert into t1 values ("123"),("456");
+select substring(f1,4,1), substring(f1,-4,1) from t2;
+drop table t1,t2;
 
 #
 # Bug #25197 :repeat function returns null when using table field directly as count
@@ -1137,4 +1147,18 @@ SELECT REPEAT( '#', tire ) AS A,
 
 DROP TABLE t1;
 
+#
+# Bug #26537: UNHEX() IS NULL comparison fails
+#
+SELECT UNHEX('G');
+SELECT UNHEX('G') IS NULL;
+
+#
+# Bug #26281: INSERT() function mishandles NUL on boundary condition
+#
+SELECT INSERT('abc', 3, 3, '1234');
+SELECT INSERT('abc', 4, 3, '1234');
+SELECT INSERT('abc', 5, 3, '1234');
+SELECT INSERT('abc', 6, 3, '1234');
+
 --echo End of 5.0 tests
diff --git a/mysql-test/t/gis-rtree.test b/mysql-test/t/gis-rtree.test
index 1704fe7dc80..3368aea9741 100644
--- a/mysql-test/t/gis-rtree.test
+++ b/mysql-test/t/gis-rtree.test
@@ -241,6 +241,562 @@ INSERT INTO t1 (foo) VALUES (PointFromWKB(POINT(0,1)));
 INSERT INTO t1 (foo) VALUES (PointFromWKB(POINT(0,0)));
 SELECT 1 FROM t1 WHERE foo != PointFromWKB(POINT(0,0));
 DROP TABLE t1;
+
+#
+# Bug#25673 - spatial index corruption, error 126 incorrect key file for table
+#
+CREATE TABLE t1 (id bigint(12) unsigned NOT NULL auto_increment,
+  c2 varchar(15) collate utf8_bin default NULL,
+  c1 varchar(15) collate utf8_bin default NULL,
+  c3 varchar(10) collate utf8_bin default NULL,
+  spatial_point point NOT NULL,
+  PRIMARY KEY(id),
+  SPATIAL KEY (spatial_point(32))
+  )ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
+#
+INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES
+  ('y', 's', 'j', GeomFromText('POINT(167 74)')),
+  ('r', 'n', 'd', GeomFromText('POINT(215 118)')),
+  ('g', 'n', 'e', GeomFromText('POINT(203 98)')),
+  ('h', 'd', 'd', GeomFromText('POINT(54 193)')),
+  ('r', 'x', 'y', GeomFromText('POINT(47 69)')),
+  ('t', 'q', 'r', GeomFromText('POINT(109 42)')),
+  ('a', 'z', 'd', GeomFromText('POINT(0 154)')),
+  ('x', 'v', 'o', GeomFromText('POINT(174 131)')),
+  ('b', 'r', 'a', GeomFromText('POINT(114 253)')),
+  ('x', 'z', 'i', GeomFromText('POINT(163 21)')),
+  ('w', 'p', 'i', GeomFromText('POINT(42 102)')),
+  ('g', 'j', 'j', GeomFromText('POINT(170 133)')),
+  ('m', 'g', 'n', GeomFromText('POINT(28 22)')),
+  ('b', 'z', 'h', GeomFromText('POINT(174 28)')),
+  ('q', 'k', 'f', GeomFromText('POINT(233 73)')),
+  ('w', 'w', 'a', GeomFromText('POINT(124 200)')),
+  ('t', 'j', 'w', GeomFromText('POINT(252 101)')),
+  ('d', 'r', 'd', GeomFromText('POINT(98 18)')),
+  ('w', 'o', 'y', GeomFromText('POINT(165 31)')),
+  ('y', 'h', 't', GeomFromText('POINT(14 220)')),
+  ('d', 'p', 'u', GeomFromText('POINT(223 196)')),
+  ('g', 'y', 'g', GeomFromText('POINT(207 96)')),
+  ('x', 'm', 'n', GeomFromText('POINT(214 3)')),
+  ('g', 'v', 'e', GeomFromText('POINT(140 205)')),
+  ('g', 'm', 'm', GeomFromText('POINT(10 236)')),
+  ('i', 'r', 'j', GeomFromText('POINT(137 228)')),
+  ('w', 's', 'p', GeomFromText('POINT(115 6)')),
+  ('o', 'n', 'k', GeomFromText('POINT(158 129)')),
+  ('j', 'h', 'l', GeomFromText('POINT(129 72)')),
+  ('f', 'x', 'l', GeomFromText('POINT(139 207)')),
+  ('u', 'd', 'n', GeomFromText('POINT(125 109)')),
+  ('b', 'a', 'z', GeomFromText('POINT(30 32)')),
+  ('m', 'h', 'o', GeomFromText('POINT(251 251)')),
+  ('f', 'r', 'd', GeomFromText('POINT(243 211)')),
+  ('b', 'd', 'r', GeomFromText('POINT(232 80)')),
+  ('g', 'k', 'v', GeomFromText('POINT(15 100)')),
+  ('i', 'f', 'c', GeomFromText('POINT(109 66)')),
+  ('r', 't', 'j', GeomFromText('POINT(178 6)')),
+  ('y', 'n', 'f', GeomFromText('POINT(233 211)')),
+  ('f', 'y', 'm', GeomFromText('POINT(99 16)')),
+  ('z', 'q', 'l', GeomFromText('POINT(39 49)')),
+  ('j', 'c', 'r', GeomFromText('POINT(75 187)')),
+  ('c', 'y', 'y', GeomFromText('POINT(246 253)')),
+  ('w', 'u', 'd', GeomFromText('POINT(56 190)')),
+  ('n', 'q', 'm', GeomFromText('POINT(73 149)')),
+  ('d', 'y', 'a', GeomFromText('POINT(134 6)')),
+  ('z', 's', 'w', GeomFromText('POINT(216 225)')),
+  ('d', 'u', 'k', GeomFromText('POINT(132 70)')),
+  ('f', 'v', 't', GeomFromText('POINT(187 141)')),
+  ('r', 'r', 'a', GeomFromText('POINT(152 39)')),
+  ('y', 'p', 'o', GeomFromText('POINT(45 27)')),
+  ('p', 'n', 'm', GeomFromText('POINT(228 148)')),
+  ('e', 'g', 'e', GeomFromText('POINT(88 81)')),
+  ('m', 'a', 'h', GeomFromText('POINT(35 29)')),
+  ('m', 'h', 'f', GeomFromText('POINT(30 71)')),
+  ('h', 'k', 'i', GeomFromText('POINT(244 78)')),
+  ('z', 'v', 'd', GeomFromText('POINT(241 38)')),
+  ('q', 'l', 'j', GeomFromText('POINT(13 71)')),
+  ('s', 'p', 'g', GeomFromText('POINT(108 38)')),
+  ('q', 's', 'j', GeomFromText('POINT(92 101)')),
+  ('l', 'h', 'g', GeomFromText('POINT(120 78)')),
+  ('w', 't', 'b', GeomFromText('POINT(193 109)')),
+  ('b', 's', 's', GeomFromText('POINT(223 211)')),
+  ('w', 'w', 'y', GeomFromText('POINT(122 42)')),
+  ('q', 'c', 'c', GeomFromText('POINT(104 102)')),
+  ('w', 'g', 'n', GeomFromText('POINT(213 120)')),
+  ('p', 'q', 'a', GeomFromText('POINT(247 148)')),
+  ('c', 'z', 'e', GeomFromText('POINT(18 106)')),
+  ('z', 'u', 'n', GeomFromText('POINT(70 133)')),
+  ('j', 'n', 'x', GeomFromText('POINT(232 13)')),
+  ('e', 'h', 'f', GeomFromText('POINT(22 135)')),
+  ('w', 'l', 'f', GeomFromText('POINT(9 180)')),
+  ('a', 'v', 'q', GeomFromText('POINT(163 228)')),
+  ('i', 'z', 'o', GeomFromText('POINT(180 100)')),
+  ('e', 'c', 'l', GeomFromText('POINT(182 231)')),
+  ('c', 'k', 'o', GeomFromText('POINT(19 60)')),
+  ('q', 'f', 'p', GeomFromText('POINT(79 95)')),
+  ('m', 'd', 'r', GeomFromText('POINT(3 127)')),
+  ('m', 'e', 't', GeomFromText('POINT(136 154)')),
+  ('w', 'w', 'w', GeomFromText('POINT(102 15)')),
+  ('l', 'n', 'q', GeomFromText('POINT(71 196)')),
+  ('p', 'k', 'c', GeomFromText('POINT(47 139)')),
+  ('j', 'o', 'r', GeomFromText('POINT(177 128)')),
+  ('j', 'q', 'a', GeomFromText('POINT(170 6)')),
+  ('b', 'a', 'o', GeomFromText('POINT(63 211)')),
+  ('g', 's', 'o', GeomFromText('POINT(144 251)')),
+  ('w', 'u', 'w', GeomFromText('POINT(221 214)')),
+  ('g', 'a', 'm', GeomFromText('POINT(14 102)')),
+  ('u', 'q', 'z', GeomFromText('POINT(86 200)')),
+  ('k', 'a', 'm', GeomFromText('POINT(144 222)')),
+  ('j', 'u', 'r', GeomFromText('POINT(216 142)')),
+  ('q', 'k', 'v', GeomFromText('POINT(121 236)')),
+  ('p', 'o', 'r', GeomFromText('POINT(108 102)')),
+  ('b', 'd', 'x', GeomFromText('POINT(127 198)')),
+  ('k', 's', 'a', GeomFromText('POINT(2 150)')),
+  ('f', 'm', 'f', GeomFromText('POINT(160 191)')),
+  ('q', 'y', 'x', GeomFromText('POINT(98 111)')),
+  ('o', 'f', 'm', GeomFromText('POINT(232 218)')),
+  ('c', 'w', 'j', GeomFromText('POINT(156 165)')),
+  ('s', 'q', 'v', GeomFromText('POINT(98 161)'));
+SET @@RAND_SEED1=692635050, @@RAND_SEED2=297339954;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=159925977, @@RAND_SEED2=942570618;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=328169745, @@RAND_SEED2=410451954;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=178507359, @@RAND_SEED2=332493072;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=1034033013, @@RAND_SEED2=558966507;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+UPDATE t1 set spatial_point=GeomFromText('POINT(230 9)') where  c1 like 'y%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(95 35)') where  c1 like 'j%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(93 99)') where  c1 like 'a%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(19 81)') where  c1 like 'r%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(20 177)') where  c1 like 'h%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(221 193)') where  c1 like 'u%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(195 205)') where  c1 like 'd%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(15 213)') where  c1 like 'u%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(214 63)') where  c1 like 'n%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(243 171)') where  c1 like 'c%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(198 82)') where  c1 like 'y%';
+INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES
+  ('f', 'y', 'p', GeomFromText('POINT(109 235)')),
+  ('b', 'e', 'v', GeomFromText('POINT(20 48)')),
+  ('i', 'u', 'f', GeomFromText('POINT(15 55)')),
+  ('o', 'r', 'z', GeomFromText('POINT(105 64)')),
+  ('a', 'p', 'a', GeomFromText('POINT(142 236)')),
+  ('g', 'i', 'k', GeomFromText('POINT(10 49)')),
+  ('x', 'z', 'x', GeomFromText('POINT(192 200)')),
+  ('c', 'v', 'r', GeomFromText('POINT(94 168)')),
+  ('y', 'z', 'e', GeomFromText('POINT(141 51)')),
+  ('h', 'm', 'd', GeomFromText('POINT(35 251)')),
+  ('v', 'm', 'q', GeomFromText('POINT(44 90)')),
+  ('j', 'l', 'z', GeomFromText('POINT(67 237)')),
+  ('i', 'v', 'a', GeomFromText('POINT(75 14)')),
+  ('b', 'q', 't', GeomFromText('POINT(153 33)')),
+  ('e', 'm', 'a', GeomFromText('POINT(247 49)')),
+  ('l', 'y', 'g', GeomFromText('POINT(56 203)')),
+  ('v', 'o', 'r', GeomFromText('POINT(90 54)')),
+  ('r', 'n', 'd', GeomFromText('POINT(135 83)')),
+  ('j', 't', 'u', GeomFromText('POINT(174 239)')),
+  ('u', 'n', 'g', GeomFromText('POINT(104 191)')),
+  ('p', 'q', 'y', GeomFromText('POINT(63 171)')),
+  ('o', 'q', 'p', GeomFromText('POINT(192 103)')),
+  ('f', 'x', 'e', GeomFromText('POINT(244 30)')),
+  ('n', 'x', 'c', GeomFromText('POINT(92 103)')),
+  ('r', 'q', 'z', GeomFromText('POINT(166 20)')),
+  ('s', 'a', 'j', GeomFromText('POINT(137 205)')),
+  ('z', 't', 't', GeomFromText('POINT(99 134)')),
+  ('o', 'm', 'j', GeomFromText('POINT(217 3)')),
+  ('n', 'h', 'j', GeomFromText('POINT(211 17)')),
+  ('v', 'v', 'a', GeomFromText('POINT(41 137)')),
+  ('q', 'o', 'j', GeomFromText('POINT(5 92)')),
+  ('z', 'y', 'e', GeomFromText('POINT(175 212)')),
+  ('j', 'z', 'h', GeomFromText('POINT(224 194)')),
+  ('a', 'g', 'm', GeomFromText('POINT(31 119)')),
+  ('p', 'c', 'f', GeomFromText('POINT(17 221)')),
+  ('t', 'h', 'k', GeomFromText('POINT(26 203)')),
+  ('u', 'w', 'p', GeomFromText('POINT(47 185)')),
+  ('z', 'a', 'c', GeomFromText('POINT(61 133)')),
+  ('u', 'k', 'a', GeomFromText('POINT(210 115)')),
+  ('k', 'f', 'h', GeomFromText('POINT(125 113)')),
+  ('t', 'v', 'y', GeomFromText('POINT(12 239)')),
+  ('u', 'v', 'd', GeomFromText('POINT(90 24)')),
+  ('m', 'y', 'w', GeomFromText('POINT(25 243)')),
+  ('d', 'n', 'g', GeomFromText('POINT(122 92)')),
+  ('z', 'm', 'f', GeomFromText('POINT(235 110)')),
+  ('q', 'd', 'f', GeomFromText('POINT(233 217)')),
+  ('a', 'v', 'u', GeomFromText('POINT(69 59)')),
+  ('x', 'k', 'p', GeomFromText('POINT(240 14)')),
+  ('i', 'v', 'r', GeomFromText('POINT(154 42)')),
+  ('w', 'h', 'l', GeomFromText('POINT(178 156)')),
+  ('d', 'h', 'n', GeomFromText('POINT(65 157)')),
+  ('c', 'k', 'z', GeomFromText('POINT(62 33)')),
+  ('e', 'l', 'w', GeomFromText('POINT(162 1)')),
+  ('r', 'f', 'i', GeomFromText('POINT(127 71)')),
+  ('q', 'm', 'c', GeomFromText('POINT(63 118)')),
+  ('c', 'h', 'u', GeomFromText('POINT(205 203)')),
+  ('d', 't', 'p', GeomFromText('POINT(234 87)')),
+  ('s', 'g', 'h', GeomFromText('POINT(149 34)')),
+  ('o', 'b', 'q', GeomFromText('POINT(159 179)')),
+  ('k', 'u', 'f', GeomFromText('POINT(202 254)')),
+  ('u', 'f', 'g', GeomFromText('POINT(70 15)')),
+  ('x', 's', 'b', GeomFromText('POINT(25 181)')),
+  ('s', 'c', 'g', GeomFromText('POINT(252 17)')),
+  ('a', 'c', 'f', GeomFromText('POINT(89 67)')),
+  ('r', 'e', 'q', GeomFromText('POINT(55 54)')),
+  ('f', 'i', 'k', GeomFromText('POINT(178 230)')),
+  ('p', 'e', 'l', GeomFromText('POINT(198 28)')),
+  ('w', 'o', 'd', GeomFromText('POINT(204 189)')),
+  ('c', 'a', 'g', GeomFromText('POINT(230 178)')),
+  ('r', 'o', 'e', GeomFromText('POINT(61 116)')),
+  ('w', 'a', 'a', GeomFromText('POINT(178 237)')),
+  ('v', 'd', 'e', GeomFromText('POINT(70 85)')),
+  ('k', 'c', 'e', GeomFromText('POINT(147 118)')),
+  ('d', 'q', 't', GeomFromText('POINT(218 77)')),
+  ('k', 'g', 'f', GeomFromText('POINT(192 113)')),
+  ('w', 'n', 'e', GeomFromText('POINT(92 124)')),
+  ('r', 'm', 'q', GeomFromText('POINT(130 65)')),
+  ('o', 'r', 'r', GeomFromText('POINT(174 233)')),
+  ('k', 'n', 't', GeomFromText('POINT(175 147)')),
+  ('q', 'm', 'r', GeomFromText('POINT(18 208)')),
+  ('l', 'd', 'i', GeomFromText('POINT(13 104)')),
+  ('w', 'o', 'y', GeomFromText('POINT(207 39)')),
+  ('p', 'u', 'o', GeomFromText('POINT(114 31)')),
+  ('y', 'a', 'p', GeomFromText('POINT(106 59)')),
+  ('a', 'x', 'z', GeomFromText('POINT(17 57)')),
+  ('v', 'h', 'x', GeomFromText('POINT(170 13)')),
+  ('t', 's', 'u', GeomFromText('POINT(84 18)')),
+  ('z', 'z', 'f', GeomFromText('POINT(250 197)')),
+  ('l', 'z', 't', GeomFromText('POINT(59 80)')),
+  ('j', 'g', 's', GeomFromText('POINT(54 26)')),
+  ('g', 'v', 'm', GeomFromText('POINT(89 98)')),
+  ('q', 'v', 'b', GeomFromText('POINT(39 240)')),
+  ('x', 'k', 'v', GeomFromText('POINT(246 207)')),
+  ('k', 'u', 'i', GeomFromText('POINT(105 111)')),
+  ('w', 'z', 's', GeomFromText('POINT(235 8)')),
+  ('d', 'd', 'd', GeomFromText('POINT(105 4)')),
+  ('c', 'z', 'q', GeomFromText('POINT(13 140)')),
+  ('m', 'k', 'i', GeomFromText('POINT(208 120)')),
+  ('g', 'a', 'g', GeomFromText('POINT(9 182)')),
+  ('z', 'j', 'r', GeomFromText('POINT(149 153)')),
+  ('h', 'f', 'g', GeomFromText('POINT(81 236)')),
+  ('m', 'e', 'q', GeomFromText('POINT(209 215)')),
+  ('c', 'h', 'y', GeomFromText('POINT(235 70)')),
+  ('i', 'e', 'g', GeomFromText('POINT(138 26)')),
+  ('m', 't', 'u', GeomFromText('POINT(119 237)')),
+  ('o', 'w', 's', GeomFromText('POINT(193 166)')),
+  ('f', 'm', 'q', GeomFromText('POINT(85 96)')),
+  ('x', 'l', 'x', GeomFromText('POINT(58 115)')),
+  ('x', 'q', 'u', GeomFromText('POINT(108 210)')),
+  ('b', 'h', 'i', GeomFromText('POINT(250 139)')),
+  ('y', 'd', 'x', GeomFromText('POINT(199 135)')),
+  ('w', 'h', 'p', GeomFromText('POINT(247 233)')),
+  ('p', 'z', 't', GeomFromText('POINT(148 249)')),
+  ('q', 'a', 'u', GeomFromText('POINT(174 78)')),
+  ('v', 't', 'm', GeomFromText('POINT(70 228)')),
+  ('t', 'n', 'f', GeomFromText('POINT(123 2)')),
+  ('x', 't', 'b', GeomFromText('POINT(35 50)')),
+  ('r', 'j', 'f', GeomFromText('POINT(200 51)')),
+  ('s', 'q', 'o', GeomFromText('POINT(23 184)')),
+  ('u', 'v', 'z', GeomFromText('POINT(7 113)')),
+  ('v', 'u', 'l', GeomFromText('POINT(145 190)')),
+  ('o', 'k', 'i', GeomFromText('POINT(161 122)')),
+  ('l', 'y', 'e', GeomFromText('POINT(17 232)')),
+  ('t', 'b', 'e', GeomFromText('POINT(120 50)')),
+  ('e', 's', 'u', GeomFromText('POINT(254 1)')),
+  ('d', 'd', 'u', GeomFromText('POINT(167 140)')),
+  ('o', 'b', 'x', GeomFromText('POINT(186 237)')),
+  ('m', 's', 's', GeomFromText('POINT(172 149)')),
+  ('t', 'y', 'a', GeomFromText('POINT(149 85)')),
+  ('x', 't', 'r', GeomFromText('POINT(10 165)')),
+  ('g', 'c', 'e', GeomFromText('POINT(95 165)')),
+  ('e', 'e', 'z', GeomFromText('POINT(98 65)')),
+  ('f', 'v', 'i', GeomFromText('POINT(149 144)')),
+  ('o', 'p', 'm', GeomFromText('POINT(233 67)')),
+  ('t', 'u', 'b', GeomFromText('POINT(109 215)')),
+  ('o', 'o', 'b', GeomFromText('POINT(130 48)')),
+  ('e', 'm', 'h', GeomFromText('POINT(88 189)')),
+  ('e', 'v', 'y', GeomFromText('POINT(55 29)')),
+  ('e', 't', 'm', GeomFromText('POINT(129 55)')),
+  ('p', 'p', 'i', GeomFromText('POINT(126 222)')),
+  ('c', 'i', 'c', GeomFromText('POINT(19 158)')),
+  ('c', 'b', 's', GeomFromText('POINT(13 19)')),
+  ('u', 'y', 'a', GeomFromText('POINT(114 5)')),
+  ('a', 'o', 'f', GeomFromText('POINT(227 232)')),
+  ('t', 'c', 'z', GeomFromText('POINT(63 62)')),
+  ('d', 'o', 'k', GeomFromText('POINT(48 228)')),
+  ('x', 'c', 'e', GeomFromText('POINT(204 2)')),
+  ('e', 'e', 'g', GeomFromText('POINT(125 43)')),
+  ('o', 'r', 'f', GeomFromText('POINT(171 140)'));
+UPDATE t1 set spatial_point=GeomFromText('POINT(163 157)') where  c1 like 'w%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(53 151)') where  c1 like 'd%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(96 183)') where  c1 like 'r%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(57 91)') where  c1 like 'q%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(202 110)') where  c1 like 'c%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(120 137)') where  c1 like 'w%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(207 147)') where  c1 like 'c%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(31 125)') where  c1 like 'e%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(27 36)') where  c1 like 'r%';
+INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES
+  ('b', 'c', 'e', GeomFromText('POINT(41 137)')),
+  ('p', 'y', 'k', GeomFromText('POINT(50 22)')),
+  ('s', 'c', 'h', GeomFromText('POINT(208 173)')),
+  ('x', 'u', 'l', GeomFromText('POINT(199 175)')),
+  ('s', 'r', 'h', GeomFromText('POINT(85 192)')),
+  ('j', 'k', 'u', GeomFromText('POINT(18 25)')),
+  ('p', 'w', 'h', GeomFromText('POINT(152 197)')),
+  ('e', 'd', 'c', GeomFromText('POINT(229 3)')),
+  ('o', 'x', 'k', GeomFromText('POINT(187 155)')),
+  ('o', 'b', 'k', GeomFromText('POINT(208 150)')),
+  ('d', 'a', 'j', GeomFromText('POINT(70 87)')),
+  ('f', 'e', 'k', GeomFromText('POINT(156 96)')),
+  ('u', 'y', 'p', GeomFromText('POINT(239 193)')),
+  ('n', 'v', 'p', GeomFromText('POINT(223 98)')),
+  ('z', 'j', 'r', GeomFromText('POINT(87 89)')),
+  ('h', 'x', 'x', GeomFromText('POINT(92 0)')),
+  ('r', 'v', 'r', GeomFromText('POINT(159 139)')),
+  ('v', 'g', 'g', GeomFromText('POINT(16 229)')),
+  ('z', 'k', 'u', GeomFromText('POINT(99 52)')),
+  ('p', 'p', 'o', GeomFromText('POINT(105 125)')),
+  ('w', 'h', 'y', GeomFromText('POINT(105 154)')),
+  ('v', 'y', 'z', GeomFromText('POINT(134 238)')),
+  ('x', 'o', 'o', GeomFromText('POINT(178 88)')),
+  ('z', 'w', 'd', GeomFromText('POINT(123 60)')),
+  ('q', 'f', 'u', GeomFromText('POINT(64 90)')),
+  ('s', 'n', 't', GeomFromText('POINT(50 138)')),
+  ('v', 'p', 't', GeomFromText('POINT(114 91)')),
+  ('a', 'o', 'n', GeomFromText('POINT(78 43)')),
+  ('k', 'u', 'd', GeomFromText('POINT(185 161)')),
+  ('w', 'd', 'n', GeomFromText('POINT(25 92)')),
+  ('k', 'w', 'a', GeomFromText('POINT(59 238)')),
+  ('t', 'c', 'f', GeomFromText('POINT(65 87)')),
+  ('g', 's', 'p', GeomFromText('POINT(238 126)')),
+  ('d', 'n', 'y', GeomFromText('POINT(107 173)')),
+  ('l', 'a', 'w', GeomFromText('POINT(125 152)')),
+  ('m', 'd', 'j', GeomFromText('POINT(146 53)')),
+  ('q', 'm', 'c', GeomFromText('POINT(217 187)')),
+  ('i', 'r', 'r', GeomFromText('POINT(6 113)')),
+  ('e', 'j', 'b', GeomFromText('POINT(37 83)')),
+  ('w', 'w', 'h', GeomFromText('POINT(83 199)')),
+  ('k', 'b', 's', GeomFromText('POINT(170 64)')),
+  ('s', 'b', 'c', GeomFromText('POINT(163 130)')),
+  ('c', 'h', 'a', GeomFromText('POINT(141 3)')),
+  ('k', 'j', 'u', GeomFromText('POINT(143 76)')),
+  ('r', 'h', 'o', GeomFromText('POINT(243 92)')),
+  ('i', 'd', 'b', GeomFromText('POINT(205 13)')),
+  ('r', 'y', 'q', GeomFromText('POINT(138 8)')),
+  ('m', 'o', 'i', GeomFromText('POINT(36 45)')),
+  ('v', 'g', 'm', GeomFromText('POINT(0 40)')),
+  ('f', 'e', 'i', GeomFromText('POINT(76 6)')),
+  ('c', 'q', 'q', GeomFromText('POINT(115 248)')),
+  ('x', 'c', 'i', GeomFromText('POINT(29 74)')),
+  ('l', 's', 't', GeomFromText('POINT(83 18)')),
+  ('t', 't', 'a', GeomFromText('POINT(26 168)')),
+  ('u', 'n', 'x', GeomFromText('POINT(200 110)')),
+  ('j', 'b', 'd', GeomFromText('POINT(216 136)')),
+  ('s', 'p', 'w', GeomFromText('POINT(38 156)')),
+  ('f', 'b', 'v', GeomFromText('POINT(29 186)')),
+  ('v', 'e', 'r', GeomFromText('POINT(149 40)')),
+  ('v', 't', 'm', GeomFromText('POINT(184 24)')),
+  ('y', 'g', 'a', GeomFromText('POINT(219 105)')),
+  ('s', 'f', 'i', GeomFromText('POINT(114 130)')),
+  ('e', 'q', 'h', GeomFromText('POINT(203 135)')),
+  ('h', 'g', 'b', GeomFromText('POINT(9 208)')),
+  ('o', 'l', 'r', GeomFromText('POINT(245 79)')),
+  ('s', 's', 'v', GeomFromText('POINT(238 198)')),
+  ('w', 'w', 'z', GeomFromText('POINT(209 232)')),
+  ('v', 'd', 'n', GeomFromText('POINT(30 193)')),
+  ('q', 'w', 'k', GeomFromText('POINT(133 18)')),
+  ('o', 'h', 'o', GeomFromText('POINT(42 140)')),
+  ('f', 'f', 'h', GeomFromText('POINT(145 1)')),
+  ('u', 's', 'r', GeomFromText('POINT(70 62)')),
+  ('x', 'n', 'q', GeomFromText('POINT(33 86)')),
+  ('u', 'p', 'v', GeomFromText('POINT(232 220)')),
+  ('z', 'e', 'a', GeomFromText('POINT(130 69)')),
+  ('r', 'u', 'z', GeomFromText('POINT(243 241)')),
+  ('b', 'n', 't', GeomFromText('POINT(120 12)')),
+  ('u', 'f', 's', GeomFromText('POINT(190 212)')),
+  ('a', 'd', 'q', GeomFromText('POINT(235 191)')),
+  ('f', 'q', 'm', GeomFromText('POINT(176 2)')),
+  ('n', 'c', 's', GeomFromText('POINT(218 163)')),
+  ('e', 'm', 'h', GeomFromText('POINT(163 108)')),
+  ('c', 'f', 'l', GeomFromText('POINT(220 115)')),
+  ('c', 'v', 'q', GeomFromText('POINT(66 45)')),
+  ('w', 'v', 'x', GeomFromText('POINT(251 220)')),
+  ('f', 'w', 'z', GeomFromText('POINT(146 149)')),
+  ('h', 'n', 'h', GeomFromText('POINT(148 128)')),
+  ('y', 'k', 'v', GeomFromText('POINT(28 110)')),
+  ('c', 'x', 'q', GeomFromText('POINT(13 13)')),
+  ('e', 'd', 's', GeomFromText('POINT(91 190)')),
+  ('c', 'w', 'c', GeomFromText('POINT(10 231)')),
+  ('u', 'j', 'n', GeomFromText('POINT(250 21)')),
+  ('w', 'n', 'x', GeomFromText('POINT(141 69)')),
+  ('f', 'p', 'y', GeomFromText('POINT(228 246)')),
+  ('d', 'q', 'f', GeomFromText('POINT(194 22)')),
+  ('d', 'z', 'l', GeomFromText('POINT(233 181)')),
+  ('c', 'a', 'q', GeomFromText('POINT(183 96)')),
+  ('m', 'i', 'd', GeomFromText('POINT(117 226)')),
+  ('z', 'y', 'y', GeomFromText('POINT(62 81)')),
+  ('g', 'v', 'm', GeomFromText('POINT(66 158)'));
+SET @@RAND_SEED1=481064922, @@RAND_SEED2=438133497;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=280535103, @@RAND_SEED2=444518646;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=1072017234, @@RAND_SEED2=484203885;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=358851897, @@RAND_SEED2=358495224;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+SET @@RAND_SEED1=509031459, @@RAND_SEED2=675962925;
+DELETE FROM t1 ORDER BY RAND() LIMIT 10;
+UPDATE t1 set spatial_point=GeomFromText('POINT(61 203)') where  c1 like 'y%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(202 194)') where  c1 like 'f%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(228 18)') where  c1 like 'h%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(88 18)') where  c1 like 'l%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(176 94)') where  c1 like 'e%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(44 47)') where  c1 like 'g%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(95 191)') where  c1 like 'b%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(179 218)') where  c1 like 'y%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(239 40)') where  c1 like 'g%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(248 41)') where  c1 like 'q%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(167 82)') where  c1 like 't%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(13 104)') where  c1 like 'u%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(139 84)') where  c1 like 'a%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(145 108)') where  c1 like 'p%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(147 57)') where  c1 like 't%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(217 144)') where  c1 like 'n%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(160 224)') where  c1 like 'w%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(38 28)') where  c1 like 'j%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(104 114)') where  c1 like 'q%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(88 19)') where  c1 like 'c%';
+INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES
+  ('f', 'x', 'p', GeomFromText('POINT(92 181)')),
+  ('s', 'i', 'c', GeomFromText('POINT(49 60)')),
+  ('c', 'c', 'i', GeomFromText('POINT(7 57)')),
+  ('n', 'g', 'k', GeomFromText('POINT(252 105)')),
+  ('g', 'b', 'm', GeomFromText('POINT(180 11)')),
+  ('u', 'l', 'r', GeomFromText('POINT(32 90)')),
+  ('c', 'x', 'e', GeomFromText('POINT(143 24)')),
+  ('x', 'u', 'a', GeomFromText('POINT(123 92)')),
+  ('s', 'b', 'h', GeomFromText('POINT(190 108)')),
+  ('c', 'x', 'b', GeomFromText('POINT(104 100)')),
+  ('i', 'd', 't', GeomFromText('POINT(214 104)')),
+  ('r', 'w', 'g', GeomFromText('POINT(29 67)')),
+  ('b', 'f', 'g', GeomFromText('POINT(149 46)')),
+  ('r', 'r', 'd', GeomFromText('POINT(242 196)')),
+  ('j', 'l', 'a', GeomFromText('POINT(90 196)')),
+  ('e', 't', 'b', GeomFromText('POINT(190 64)')),
+  ('l', 'x', 'w', GeomFromText('POINT(250 73)')),
+  ('q', 'y', 'r', GeomFromText('POINT(120 182)')),
+  ('s', 'j', 'a', GeomFromText('POINT(180 175)')),
+  ('n', 'i', 'y', GeomFromText('POINT(124 136)')),
+  ('s', 'x', 's', GeomFromText('POINT(176 209)')),
+  ('u', 'f', 's', GeomFromText('POINT(215 173)')),
+  ('m', 'j', 'x', GeomFromText('POINT(44 140)')),
+  ('v', 'g', 'x', GeomFromText('POINT(177 233)')),
+  ('u', 't', 'b', GeomFromText('POINT(136 197)')),
+  ('f', 'g', 'b', GeomFromText('POINT(10 8)')),
+  ('v', 'c', 'j', GeomFromText('POINT(13 81)')),
+  ('d', 's', 'q', GeomFromText('POINT(200 100)')),
+  ('a', 'p', 'j', GeomFromText('POINT(33 40)')),
+  ('i', 'c', 'g', GeomFromText('POINT(168 204)')),
+  ('k', 'h', 'i', GeomFromText('POINT(93 243)')),
+  ('s', 'b', 's', GeomFromText('POINT(157 13)')),
+  ('v', 'l', 'l', GeomFromText('POINT(103 6)')),
+  ('r', 'b', 'k', GeomFromText('POINT(244 137)')),
+  ('l', 'd', 'r', GeomFromText('POINT(162 254)')),
+  ('q', 'b', 'z', GeomFromText('POINT(136 246)')),
+  ('x', 'x', 'p', GeomFromText('POINT(120 37)')),
+  ('m', 'e', 'z', GeomFromText('POINT(203 167)')),
+  ('q', 'n', 'p', GeomFromText('POINT(94 119)')),
+  ('b', 'g', 'u', GeomFromText('POINT(93 248)')),
+  ('r', 'v', 'v', GeomFromText('POINT(53 88)')),
+  ('y', 'a', 'i', GeomFromText('POINT(98 219)')),
+  ('a', 's', 'g', GeomFromText('POINT(173 138)')),
+  ('c', 'a', 't', GeomFromText('POINT(235 135)')),
+  ('q', 'm', 'd', GeomFromText('POINT(224 208)')),
+  ('e', 'p', 'k', GeomFromText('POINT(161 238)')),
+  ('n', 'g', 'q', GeomFromText('POINT(35 204)')),
+  ('t', 't', 'x', GeomFromText('POINT(230 178)')),
+  ('w', 'f', 'a', GeomFromText('POINT(150 221)')),
+  ('z', 'm', 'z', GeomFromText('POINT(119 42)')),
+  ('l', 'j', 's', GeomFromText('POINT(97 96)')),
+  ('f', 'z', 'x', GeomFromText('POINT(208 65)')),
+  ('i', 'v', 'c', GeomFromText('POINT(145 79)')),
+  ('l', 'f', 'k', GeomFromText('POINT(83 234)')),
+  ('u', 'a', 's', GeomFromText('POINT(250 49)')),
+  ('o', 'k', 'p', GeomFromText('POINT(46 50)')),
+  ('d', 'e', 'z', GeomFromText('POINT(30 198)')),
+  ('r', 'r', 'l', GeomFromText('POINT(78 189)')),
+  ('y', 'l', 'f', GeomFromText('POINT(188 132)')),
+  ('d', 'q', 'm', GeomFromText('POINT(247 107)')),
+  ('p', 'j', 'n', GeomFromText('POINT(148 227)')),
+  ('b', 'o', 'i', GeomFromText('POINT(172 25)')),
+  ('e', 'v', 'd', GeomFromText('POINT(94 248)')),
+  ('q', 'd', 'f', GeomFromText('POINT(15 29)')),
+  ('w', 'b', 'b', GeomFromText('POINT(74 111)')),
+  ('g', 'q', 'f', GeomFromText('POINT(107 215)')),
+  ('o', 'h', 'r', GeomFromText('POINT(25 168)')),
+  ('u', 't', 'w', GeomFromText('POINT(251 188)')),
+  ('h', 's', 'w', GeomFromText('POINT(254 247)')),
+  ('f', 'f', 'b', GeomFromText('POINT(166 103)'));
+SET @@RAND_SEED1=866613816, @@RAND_SEED2=92289615;
+INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES
+  ('l', 'c', 'l', GeomFromText('POINT(202 98)')),
+  ('k', 'c', 'b', GeomFromText('POINT(46 206)')),
+  ('r', 'y', 'm', GeomFromText('POINT(74 140)')),
+  ('y', 'z', 'd', GeomFromText('POINT(200 160)')),
+  ('s', 'y', 's', GeomFromText('POINT(156 205)')),
+  ('u', 'v', 'p', GeomFromText('POINT(86 82)')),
+  ('j', 's', 's', GeomFromText('POINT(91 233)')),
+  ('x', 'j', 'f', GeomFromText('POINT(3 14)')),
+  ('l', 'z', 'v', GeomFromText('POINT(123 156)')),
+  ('h', 'i', 'o', GeomFromText('POINT(145 229)')),
+  ('o', 'r', 'd', GeomFromText('POINT(15 22)')),
+  ('f', 'x', 't', GeomFromText('POINT(21 60)')),
+  ('t', 'g', 'h', GeomFromText('POINT(50 153)')),
+  ('g', 'u', 'b', GeomFromText('POINT(82 85)')),
+  ('v', 'a', 'p', GeomFromText('POINT(231 178)')),
+  ('n', 'v', 'o', GeomFromText('POINT(183 25)')),
+  ('j', 'n', 'm', GeomFromText('POINT(50 144)')),
+  ('e', 'f', 'i', GeomFromText('POINT(46 16)')),
+  ('d', 'w', 'a', GeomFromText('POINT(66 6)')),
+  ('f', 'x', 'a', GeomFromText('POINT(107 197)')),
+  ('m', 'o', 'a', GeomFromText('POINT(142 80)')),
+  ('q', 'l', 'g', GeomFromText('POINT(251 23)')),
+  ('c', 's', 's', GeomFromText('POINT(158 43)')),
+  ('y', 'd', 'o', GeomFromText('POINT(196 228)')),
+  ('d', 'p', 'l', GeomFromText('POINT(107 5)')),
+  ('h', 'a', 'b', GeomFromText('POINT(183 166)')),
+  ('m', 'w', 'p', GeomFromText('POINT(19 59)')),
+  ('b', 'y', 'o', GeomFromText('POINT(178 30)')),
+  ('x', 'w', 'i', GeomFromText('POINT(168 94)')),
+  ('t', 'k', 'z', GeomFromText('POINT(171 5)')),
+  ('r', 'm', 'a', GeomFromText('POINT(222 19)')),
+  ('u', 'v', 'e', GeomFromText('POINT(224 80)')),
+  ('q', 'r', 'k', GeomFromText('POINT(212 218)')),
+  ('d', 'p', 'j', GeomFromText('POINT(169 7)')),
+  ('d', 'r', 'v', GeomFromText('POINT(193 23)')),
+  ('n', 'y', 'y', GeomFromText('POINT(130 178)')),
+  ('m', 'z', 'r', GeomFromText('POINT(81 200)')),
+  ('j', 'e', 'w', GeomFromText('POINT(145 239)')),
+  ('v', 'h', 'x', GeomFromText('POINT(24 105)')),
+  ('z', 'm', 'a', GeomFromText('POINT(175 129)')),
+  ('b', 'c', 'v', GeomFromText('POINT(213 10)')),
+  ('t', 't', 'u', GeomFromText('POINT(2 129)')),
+  ('r', 's', 'v', GeomFromText('POINT(209 192)')),
+  ('x', 'p', 'g', GeomFromText('POINT(43 63)')),
+  ('t', 'e', 'u', GeomFromText('POINT(139 210)')),
+  ('l', 'e', 't', GeomFromText('POINT(245 148)')),
+  ('a', 'i', 'k', GeomFromText('POINT(167 195)')),
+  ('m', 'o', 'h', GeomFromText('POINT(206 120)')),
+  ('g', 'z', 's', GeomFromText('POINT(169 240)')),
+  ('z', 'u', 's', GeomFromText('POINT(202 120)')),
+  ('i', 'b', 'a', GeomFromText('POINT(216 18)')),
+  ('w', 'y', 'g', GeomFromText('POINT(119 236)')),
+  ('h', 'y', 'p', GeomFromText('POINT(161 24)'));
+UPDATE t1 set spatial_point=GeomFromText('POINT(33 100)') where  c1 like 't%';
+UPDATE t1 set spatial_point=GeomFromText('POINT(41 46)') where  c1 like 'f%';
+CHECK TABLE t1 EXTENDED;
+DROP TABLE t1;
+
 # End of 4.1 tests
 
 #
diff --git a/mysql-test/t/heap.test b/mysql-test/t/heap.test
index 624597cd8d7..b47a5fc2033 100644
--- a/mysql-test/t/heap.test
+++ b/mysql-test/t/heap.test
@@ -471,3 +471,12 @@ SELECT COUNT(*) FROM t1 WHERE c=REPEAT('a',256);
 DROP TABLE t1;
 
 # End of 5.0 tests
+
+#
+# BUG#26080 - Memory Storage engine not working properly
+#
+CREATE TABLE t1(c1 VARCHAR(100), c2 INT) ENGINE=MEMORY;
+INSERT INTO t1 VALUES('', 0);
+ALTER TABLE t1 MODIFY c1 VARCHAR(101);
+SELECT c2 FROM t1;
+DROP TABLE t1;
diff --git a/mysql-test/t/merge.test b/mysql-test/t/merge.test
index d3639b07bdb..e132c33ab7f 100644
--- a/mysql-test/t/merge.test
+++ b/mysql-test/t/merge.test
@@ -434,6 +434,32 @@ CREATE TABLE tm1(a SMALLINT, b SMALLINT, KEY(a)) ENGINE=MERGE UNION=(t1);
 SELECT * FROM tm1;
 DROP TABLE t1, tm1;
 
+#
+# Bug#26464 - insert delayed + update + merge = corruption
+#
+CREATE TABLE t1(c1 INT) ENGINE=MyISAM;
+CREATE TABLE t2(c1 INT) ENGINE=MERGE UNION=(t1);
+--error 1031
+INSERT DELAYED INTO t2 VALUES(1);
+DROP TABLE t1, t2;
+
+#
+# BUG#26881 - Large MERGE tables report incorrect specification when no
+#             differences in tables
+#
+CREATE TABLE t1(c1 VARCHAR(1));
+CREATE TABLE m1 LIKE t1;
+ALTER TABLE m1 ENGINE=MERGE UNION=(t1);
+SELECT * FROM m1;
+DROP TABLE t1, m1;
+
+CREATE TABLE t1(c1 VARCHAR(4), c2 TINYINT, c3 TINYINT, c4 TINYINT,
+                c5 TINYINT, c6 TINYINT, c7 TINYINT, c8 TINYINT, c9 TINYINT);
+CREATE TABLE m1 LIKE t1;
+ALTER TABLE m1 ENGINE=MERGE UNION=(t1);
+SELECT * FROM m1;
+DROP TABLE t1, m1;
+
 # End of 4.1 tests
 
 #
diff --git a/mysql-test/t/olap.test b/mysql-test/t/olap.test
index 4e5e7b72fc8..e6cbfe3166c 100644
--- a/mysql-test/t/olap.test
+++ b/mysql-test/t/olap.test
@@ -327,3 +327,18 @@ SELECT * FROM v1;
 
 DROP VIEW v1;
 DROP TABLE t1;
+
+#
+# Bug #26830: derived table with ROLLUP 
+#
+
+CREATE TABLE t1 (a int, KEY (a));
+INSERT INTO t1 VALUES (3), (1), (4), (1), (3), (1), (1);
+
+SELECT * FROM (SELECT a, SUM(a) FROM t1 GROUP BY a WITH ROLLUP) as t;
+
+DROP TABLE t1;
+
+
+
+
diff --git a/mysql-test/t/order_by.test b/mysql-test/t/order_by.test
index f2da8e44843..c9ae0964e17 100644
--- a/mysql-test/t/order_by.test
+++ b/mysql-test/t/order_by.test
@@ -670,6 +670,14 @@ ON (t1.a=t2.a AND t1.b=t3.b) order by t2.b;
 
 DROP TABLE t1,t2,t3,t4;
 
+#
+# Bug#25376: Incomplete setup of ORDER BY clause results in a wrong result.
+#
+create table t1 (a int, b int, c int);
+insert into t1 values (1,2,3), (9,8,3), (19,4,3), (1,4,9);
+select a,(sum(b)/sum(c)) as ratio from t1 group by a order by sum(b)/sum(c) asc;
+drop table t1;
+
 #
 # BUG#16590: Optimized does not do right "const" table pre-read
 #
diff --git a/mysql-test/t/sp.test b/mysql-test/t/sp.test
index 76b94198161..884519801e2 100644
--- a/mysql-test/t/sp.test
+++ b/mysql-test/t/sp.test
@@ -6827,6 +6827,21 @@ select func_8407_b()|
 drop function func_8407_a|
 drop function func_8407_b|
 
+#
+# Bug#25373: Stored functions wasn't compared correctly which leads to a wrong
+#            result.
+#
+--disable_warnings
+DROP FUNCTION IF EXISTS bug25373|
+--disable_warnings
+CREATE FUNCTION bug25373(p1 INTEGER) RETURNS INTEGER
+LANGUAGE SQL DETERMINISTIC
+RETURN p1;|
+CREATE TABLE t3 (f1 INT, f2 FLOAT)|
+INSERT INTO t3 VALUES (1, 3.4), (1, 2), (1, 0.9), (2, 8), (2, 7)|
+SELECT SUM(f2), bug25373(f1) FROM t3 GROUP BY bug25373(f1) WITH ROLLUP|
+DROP FUNCTION bug25373|
+DROP TABLE t3|
 #
 # NOTE: The delimiter is `|`, and not `;`. It is changed to `;`
 #       at the end of the file!
diff --git a/mysql-test/t/union.test b/mysql-test/t/union.test
index 2bdf8420d6d..cc93fbd715a 100644
--- a/mysql-test/t/union.test
+++ b/mysql-test/t/union.test
@@ -900,4 +900,17 @@ drop table t1, t2;
 #
 select _utf8'12' union select _latin1'12345';
 
+#
+# Bug #26661: UNION with ORDER BY undefined column in FROM list
+#
+
+CREATE TABLE t1 (a int);
+INSERT INTO t1 VALUES (3),(1),(2),(4),(1);
+
+SELECT a FROM (SELECT a FROM t1 UNION SELECT a FROM t1 ORDER BY a) AS test;
+--error 1054 
+SELECT a FROM (SELECT a FROM t1 UNION SELECT a FROM t1 ORDER BY c) AS test;
+
+DROP TABLE t1;
+
 --echo End of 5.0 tests
diff --git a/mysql-test/t/update.test b/mysql-test/t/update.test
index 23ee75d61ea..6cec940d286 100644
--- a/mysql-test/t/update.test
+++ b/mysql-test/t/update.test
@@ -306,6 +306,14 @@ create table t1(f1 int, `*f2` int);
 insert into t1 values (1,1);
 update t1 set `*f2`=1;
 drop table t1;
+
+#
+# Bug#25126: Wrongly resolved field leads to a crash
+#
+create table t1(f1 int);
+--error 1054
+update t1 set f2=1 order by f2;
+drop table t1;
 # End of 4.1 tests
 
 #
diff --git a/mysql-test/t/view.test b/mysql-test/t/view.test
index 520babafb7e..9771c5bc96e 100644
--- a/mysql-test/t/view.test
+++ b/mysql-test/t/view.test
@@ -3154,6 +3154,45 @@ drop view view_24532_a;
 drop view view_24532_b;
 drop table table_24532;
 
+#
+# Bug#26560: view using subquery with a reference to an outer alias 
+#
+
+CREATE TABLE t1 (
+  lid int NOT NULL PRIMARY KEY,
+  name char(10) NOT NULL
+);
+INSERT INTO t1 (lid, name) VALUES
+  (1, 'YES'), (2, 'NO');
+
+CREATE TABLE t2 (
+  id int NOT NULL PRIMARY KEY, 
+  gid int NOT NULL,
+  lid int NOT NULL,
+  dt date
+);
+INSERT INTO t2 (id, gid, lid, dt) VALUES
+ (1, 1, 1, '2007-01-01'),(2, 1, 2, '2007-01-02'),
+ (3, 2, 2, '2007-02-01'),(4, 2, 1, '2007-02-02');
+
+SELECT DISTINCT t2.gid AS lgid,
+                (SELECT t1.name FROM t1, t2
+                   WHERE t1.lid  = t2.lid AND t2.gid = lgid
+                     ORDER BY t2.dt DESC LIMIT 1
+                ) as clid
+  FROM t2;
+
+CREATE VIEW v1 AS
+SELECT DISTINCT t2.gid AS lgid,
+                (SELECT t1.name FROM t1, t2
+                   WHERE t1.lid  = t2.lid AND t2.gid = lgid
+                     ORDER BY t2.dt DESC LIMIT 1
+                ) as clid
+  FROM t2;
+SELECT * FROM v1;
+
+DROP VIEW v1;
+DROP table t1,t2;
 
 --echo End of 5.0 tests.
 
diff --git a/mysys/CMakeLists.txt b/mysys/CMakeLists.txt
index c4d67f1e552..1ae625c4c03 100644
--- a/mysys/CMakeLists.txt
+++ b/mysys/CMakeLists.txt
@@ -39,6 +39,6 @@ ADD_LIBRARY(mysys array.c charset-def.c charset.c checksum.c default.c default_m
 				my_mkdir.c my_mmap.c my_net.c my_once.c my_open.c my_pread.c my_pthread.c 
 				my_quick.c my_read.c my_realloc.c my_redel.c my_rename.c my_seek.c my_sleep.c
 				my_static.c my_symlink.c my_symlink2.c my_sync.c my_thr_init.c my_wincond.c
-				my_windac.c my_winsem.c my_winthread.c my_write.c ptr_cmp.c queues.c
+				my_windac.c my_winthread.c my_write.c ptr_cmp.c queues.c
 				rijndael.c safemalloc.c sha1.c string.c thr_alarm.c thr_lock.c thr_mutex.c
 				thr_rwlock.c tree.c typelib.c my_vle.c base64.c my_memmem.c my_getpagesize.c)
diff --git a/mysys/Makefile.am b/mysys/Makefile.am
index fd6a0f76332..fca13ab52b8 100644
--- a/mysys/Makefile.am
+++ b/mysys/Makefile.am
@@ -47,7 +47,7 @@ libmysys_a_SOURCES =    my_init.c my_getwd.c mf_getdate.c my_mmap.c \
 			my_sync.c my_getopt.c my_mkdir.c \
 			default_modify.c default.c \
                         my_compress.c checksum.c \
-			my_net.c my_semaphore.c my_port.c my_sleep.c \
+			my_net.c my_port.c my_sleep.c \
 			charset.c charset-def.c my_bitmap.c my_bit.c md5.c \
 			my_gethostbyname.c rijndael.c my_aes.c sha1.c \
 			my_handler.c my_netware.c my_largepage.c \
@@ -56,7 +56,7 @@ libmysys_a_SOURCES =    my_init.c my_getwd.c mf_getdate.c my_mmap.c \
 EXTRA_DIST =		thr_alarm.c thr_lock.c my_pthread.c my_thr_init.c \
 			thr_mutex.c thr_rwlock.c \
 			CMakeLists.txt mf_soundex.c \
-			my_conio.c my_wincond.c my_winsem.c my_winthread.c
+			my_conio.c my_wincond.c my_winthread.c
 libmysys_a_LIBADD =	@THREAD_LOBJECTS@
 # test_dir_DEPENDENCIES=	$(LIBRARIES)
 # testhash_DEPENDENCIES=	$(LIBRARIES)
diff --git a/mysys/my_semaphore.c b/mysys/my_semaphore.c
deleted file mode 100644
index efabd4b42d9..00000000000
--- a/mysys/my_semaphore.c
+++ /dev/null
@@ -1,103 +0,0 @@
-/* Copyright (C) 2002-2003 MySQL AB
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; version 2 of the License.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
-
-/*
-  Simple implementation of semaphores, needed to compile MySQL on systems
-  that doesn't support semaphores.
-*/
-
-#include <my_global.h>
-#include <my_semaphore.h>
-#include <errno.h>
-
-#if !defined(__WIN__) && !defined(HAVE_SEMAPHORE_H) && defined(THREAD)
-
-int sem_init(sem_t * sem, int pshared, uint value)
-{
-  sem->count=value;
-  pthread_cond_init(&sem->cond, 0);
-  pthread_mutex_init(&sem->mutex, 0);
-  return 0;
-}
-
-int sem_destroy(sem_t * sem)
-{
-  int err1,err2;
-  err1=pthread_cond_destroy(&sem->cond);
-  err2=pthread_mutex_destroy(&sem->mutex);
-  if (err1 || err2)
-  {
-    errno=err1 ? err1 : err2;
-    return -1;
-  }
-  return 0;
-}
-
-int sem_wait(sem_t * sem)
-{
-  if ((errno=pthread_mutex_lock(&sem->mutex)))
-    return -1;
-  while (!sem->count)
-    pthread_cond_wait(&sem->cond, &sem->mutex);
-  if (errno)
-    return -1;
-  sem->count--; /* mutex is locked here */
-  pthread_mutex_unlock(&sem->mutex);
-  return 0;
-}
-
-int sem_trywait(sem_t * sem)
-{
-  if ((errno=pthread_mutex_lock(&sem->mutex)))
-    return -1;
-  if (sem->count)
-    sem->count--;
-  else
-    errno=EAGAIN;
-  pthread_mutex_unlock(&sem->mutex);
-  return errno ? -1 : 0;
-}
-
-
-int sem_post(sem_t * sem)
-{
-  if ((errno=pthread_mutex_lock(&sem->mutex)))
-    return -1;
-  sem->count++;
-  pthread_mutex_unlock(&sem->mutex);    /* does it really matter what to do */
-  pthread_cond_signal(&sem->cond);      /* first: x_unlock or x_signal ?    */
-  return 0;
-}
-
-int sem_post_multiple(sem_t * sem, uint count)
-{
-  if ((errno=pthread_mutex_lock(&sem->mutex)))
-    return -1;
-  sem->count+=count;
-  pthread_mutex_unlock(&sem->mutex);    /* does it really matter what to do */
-  pthread_cond_broadcast(&sem->cond);   /* first: x_unlock or x_broadcast ? */
-  return 0;
-}
-
-int sem_getvalue(sem_t * sem, uint *sval)
-{
-  if ((errno=pthread_mutex_lock(&sem->mutex)))
-    return -1;
-  *sval=sem->count;
-  pthread_mutex_unlock(&sem->mutex);
-  return 0;
-}
-
-#endif /* !defined(__WIN__) && !defined(HAVE_SEMAPHORE_H) && defined(THREAD) */
diff --git a/mysys/my_winsem.c b/mysys/my_winsem.c
deleted file mode 100644
index e2713d189b2..00000000000
--- a/mysys/my_winsem.c
+++ /dev/null
@@ -1,406 +0,0 @@
-/*
- * -------------------------------------------------------------
- *
- * Module: my_semaphore.c  (Original: semaphore.c from pthreads library)
- *
- * Purpose:
- *	Semaphores aren't actually part of the PThreads standard.
- *	They are defined by the POSIX Standard:
- *
- *		POSIX 1003.1b-1993	(POSIX.1b)
- *
- * -------------------------------------------------------------
- *
- * Pthreads-win32 - POSIX Threads Library for Win32
- * Copyright (C) 1998
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- * MA 02111-1307, USA
- */
-
-/*
-  NEED_SEM is not used in MySQL and should only be needed under
-  Windows CE.
-
-  The big changes compared to the original version was to not allocate
-  any additional memory in sem_init() but to instead store everthing
-  we need in sem_t.
-
-  TODO:
-  To get HAVE_CREATESEMAPHORE we have to define the struct
-  in my_semaphore.h
-*/
-
-#include "mysys_priv.h"
-#ifdef __WIN__
-#include "my_semaphore.h"
-#include <errno.h>
-
-/*
- DOCPUBLIC
-      This function initializes an unnamed semaphore. the
-      initial value of the semaphore is 'value'
-
- PARAMETERS
-      sem	Pointer to an instance of sem_t
-
-      pshared	If zero, this semaphore may only be shared between
-		threads in the same process.
-		If nonzero, the semaphore can be shared between
-		processes
-
-      value	Initial value of the semaphore counter
-
- RESULTS
-      0		Successfully created semaphore,
-     -1		Failed, error in errno
-
- ERRNO
-      EINVAL	'sem' is not a valid semaphore,
-      ENOSPC	A required resource has been exhausted,
-      ENOSYS	Semaphores are not supported,
-      EPERM	The process lacks appropriate privilege
-
-*/
-
-int
-sem_init (sem_t *sem, int pshared, unsigned int value)
-{
-  int result = 0;
-
-  if (pshared != 0)
-  {
-    /*
-      We don't support creating a semaphore that can be shared between
-      processes
-     */
-    result = EPERM;
-  }
-  else
-  {
-#ifndef HAVE_CREATESEMAPHORE
-    sem->value = value;
-    sem->event = CreateEvent(NULL,
-			     FALSE,	/* manual reset */
-			     FALSE,	/* initial state */
-			     NULL);
-    if (!sem->event)
-      result = ENOSPC;
-    else
-    {
-      if (value)
-	SetEvent(sem->event);
-      InitializeCriticalSection(&sem->sem_lock_cs);
-    }
-#else /* HAVE_CREATESEMAPHORE */
-    *sem = CreateSemaphore (NULL,	 /* Always NULL */
-			    value,	 /* Initial value */
-			    0x7FFFFFFFL, /* Maximum value */
-			    NULL);	 /* Name */
-    if (!*sem)
-      result = ENOSPC;
-#endif /* HAVE_CREATESEMAPHORE */
-  }
-  if (result != 0)
-  {
-    errno = result;
-    return -1;
-  }
-  return 0;
-} /* sem_init */
-
-
-/*
-  DOCPUBLIC
-       This function destroys an unnamed semaphore.
-
-  PARAMETERS
-       sem	Pointer to an instance of sem_t
-
- RESULTS
-       0	Successfully destroyed semaphore,
-       -1	Failed, error in errno
- ERRNO
-       EINVAL	'sem' is not a valid semaphore,
-       ENOSYS	Semaphores are not supported,
-       EBUSY	Threads (or processes) are currently blocked on 'sem'
-*/
-
-int
-sem_destroy (sem_t * sem)
-{
-  int result = 0;
-
-#ifdef EXTRA_DEBUG
-  if (sem == NULL || *sem == NULL)
-  {
-    errno=EINVAL;
-    return;
-  }
-#endif /* EXTRA_DEBUG */
-
-#ifndef HAVE_CREATESEMAPHORE
-  if (! CloseHandle(sem->event))
-    result = EINVAL;
-  else
-    DeleteCriticalSection(&sem->sem_lock_cs);
-#else /* HAVE_CREATESEMAPHORE */
-  if (!CloseHandle(*sem))
-    result = EINVAL;
-#endif /* HAVE_CREATESEMAPHORE */
-  if (result)
-  {
-    errno = result;
-    return -1;
-  }
-  *sem=0;					/* Safety */
-  return 0;
-} /* sem_destroy */
-
-
-/*
- DOCPUBLIC
-      This function tries to wait on a semaphore. If the
-      semaphore value is greater than zero, it decreases
-      its value by one. If the semaphore value is zero, then
-      this function returns immediately with the error EAGAIN
-
- PARAMETERS
-      sem	Pointer to an instance of sem_t
-
- RESULTS
-      0		Successfully decreased semaphore,
-      -1	Failed, error in errno
-
- ERRNO
-      EAGAIN	The semaphore was already locked,
-      EINVAL	'sem' is not a valid semaphore,
-      ENOSYS	Semaphores are not supported,
-      EINTR	The function was interrupted by a signal,
-      EDEADLK	A deadlock condition was detected.
-*/
-
-int
-sem_trywait(sem_t * sem)
-{
-#ifndef HAVE_CREATESEMAPHORE
-  /* not yet implemented! */
-  int errno = EINVAL;
-  return -1;
-#else /* HAVE_CREATESEMAPHORE */
-#ifdef EXTRA_DEBUG
-  if (sem == NULL || *sem == NULL)
-  {
-    errno=EINVAL;
-    return -1;
-  }
-#endif /* EXTRA_DEBUG */
-  if (WaitForSingleObject (*sem, 0) == WAIT_TIMEOUT)
-  {
-    errno= EAGAIN;
-    return -1;
-  }
-  return 0;
-#endif /* HAVE_CREATESEMAPHORE */
-
-}				/* sem_trywait */
-
-
-#ifndef HAVE_CREATESEMAPHORE
-
-static void
-ptw32_decrease_semaphore(sem_t * sem)
-{
-  EnterCriticalSection(&sem->sem_lock_cs);
-  DBUG_ASSERT(sem->value != 0);
-  sem->value--;
-  if (sem->value != 0)
-    SetEvent(sem->event);
-  LeaveCriticalSection(&sem->sem_lock_cs);
-}
-
-static BOOL
-ptw32_increase_semaphore(sem_t * sem, unsigned int n)
-{
-  BOOL result=FALSE;
-
-  EnterCriticalSection(&sem->sem_lock_cs);
-  if (sem->value + n > sem->value)
-  {
-    sem->value += n;
-    SetEvent(sem->event);
-    result = TRUE;
-  }
-  LeaveCriticalSection(&sem->sem_lock_cs);
-  return result;
-}
-
-#endif /* HAVE_CREATESEMAPHORE */
-
-
-/*
- ------------------------------------------------------
- DOCPUBLIC
-      This function waits on a semaphore. If the
-      semaphore value is greater than zero, it decreases
-      its value by one. If the semaphore value is zero, then
-      the calling thread (or process) is blocked until it can
-      successfully decrease the value or until interrupted by
-      a signal.
-
- PARAMETERS
-      sem	Pointer to an instance of sem_t
-
- RESULTS
-      0		Successfully decreased semaphore,
-     -1		Failed, error in errno
-
- ERRNO
-      EINVAL	'Sem' is not a valid semaphore,
-      ENOSYS	Semaphores are not supported,
-      EINTR	The function was interrupted by a signal,
-      EDEADLK	A deadlock condition was detected.
-*/
-
-int
-sem_wait(sem_t *sem)
-{
-  int result;
-
-#ifdef EXTRA_DEBUG
-  if (sem == NULL || *sem == NULL)
-  {
-    errno=EINVAL;
-    return -1;
-  }
-#endif /* EXTRA_DEBUG */
-
-#ifndef HAVE_CREATESEMAPHORE
-  result=WaitForSingleObject(sem->event, INFINITE);
-#else
-  result=WaitForSingleObject(*sem, INFINITE);
-#endif
-  if (result == WAIT_FAILED || result == WAIT_ABANDONED_0)
-    result = EINVAL;
-  else if (result == WAIT_TIMEOUT)
-    result = ETIMEDOUT;
-  else
-    result=0;
-  if (result)
-  {
-    errno = result;
-    return -1;
-  }
-#ifndef HAVE_CREATESEMAPHORE
-  ptw32_decrease_semaphore(sem);
-#endif /* HAVE_CREATESEMAPHORE */
-  return 0;
-}
-
-
-/*
- ------------------------------------------------------
- DOCPUBLIC
-      This function posts a wakeup to a semaphore. If there
-      are waiting threads (or processes), one is awakened;
-      otherwise, the semaphore value is incremented by one.
-
- PARAMETERS
-      sem		Pointer to an instance of sem_t
-
- RESULTS
-      0			Successfully posted semaphore,
-      -1		Failed, error in errno
-
- ERRNO
-      EINVAL		'sem' is not a valid semaphore,
-      ENOSYS		Semaphores are not supported,
-
-*/
-
-int
-sem_post (sem_t * sem)
-{
-#ifdef EXTRA_DEBUG
-  if (sem == NULL || *sem == NULL)
-  {
-    errno=EINVAL;
-    return -1;
-  }
-#endif /* EXTRA_DEBUG */
-
-#ifndef HAVE_CREATESEMAPHORE
-  if (! ptw32_increase_semaphore(sem, 1))
-#else /* HAVE_CREATESEMAPHORE */
-  if (! ReleaseSemaphore(*sem, 1, 0))
-#endif /* HAVE_CREATESEMAPHORE */
-  {
-    errno=EINVAL;
-    return -1;
-  }
-  return 0;
-}
-
-
-/*
- ------------------------------------------------------
- DOCPUBLIC
-      This function posts multiple wakeups to a semaphore. If there
-      are waiting threads (or processes), n <= count are awakened;
-      the semaphore value is incremented by count - n.
-
- PARAMETERS
-      sem		Pointer to an instance of sem_t
-      count		Counter, must be greater than zero.
-
- RESULTS
-      0			Successfully posted semaphore,
-      -1		Failed, error in errno
-
- ERRNO
-      EINVAL		'sem' is not a valid semaphore or count is less
-			than or equal to zero.
-*/
-
-int
-sem_post_multiple (sem_t * sem, unsigned int count)
-{
-#ifdef EXTRA_DEBUG
-  if (sem == NULL || *sem == NULL || count <= 0)
-  {
-    errno=EINVAL;
-    return -1;
-  }
-#endif /* EXTRA_DEBUG */
-#ifndef HAVE_CREATESEMAPHORE
-  if (! ptw32_increase_semaphore (sem, count))
-#else /* HAVE_CREATESEMAPHORE */
-  if (! ReleaseSemaphore(*sem, count, 0))
-#endif /* HAVE_CREATESEMAPHORE */
-  {
-    errno = EINVAL;
-    return -1;
-  }
-  return 0;
-}
-
-int
-sem_getvalue (sem_t *sem, unsigned int *sval)
-{
-  errno = ENOSYS;
-  return -1;
-}				/* sem_getvalue */
-
-#endif /* __WIN__ */
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
index 872d97a6fa8..1def6f221f7 100644
--- a/sql/ha_ndbcluster.cc
+++ b/sql/ha_ndbcluster.cc
@@ -4835,7 +4835,8 @@ int ha_ndbcluster::create(const char *name,
     if ((my_errno= create_ndb_column(col, field, create_info)))
       DBUG_RETURN(my_errno);
  
-    if (create_info->storage_media == HA_SM_DISK)
+    if (create_info->storage_media == HA_SM_DISK ||
+        create_info->tablespace)
       col.setStorageType(NdbDictionary::Column::StorageTypeDisk);
     else
       col.setStorageType(NdbDictionary::Column::StorageTypeMemory);
@@ -6156,9 +6157,16 @@ int ndbcluster_discover(handlerton *hton, THD* thd, const char *db,
     {
       const NdbError err= dict->getNdbError();
       if (err.code == 709 || err.code == 723)
+      {
         error= -1;
+        DBUG_PRINT("info", ("ndb_error.code: %u", ndb_error.code));
+      }
       else
+      {
+        error= -1;
         ndb_error= err;
+        DBUG_PRINT("info", ("ndb_error.code: %u", ndb_error.code));
+      }
       goto err;
     }
     DBUG_PRINT("info", ("Found table %s", tab->getName()));
@@ -10620,10 +10628,23 @@ bool ha_ndbcluster::check_if_incompatible_data(HA_CREATE_INFO *create_info,
 
   int pk= 0;
   int ai= 0;
+
+  if (create_info->tablespace)
+    create_info->storage_media = HA_SM_DISK;
+  else
+    create_info->storage_media = HA_SM_MEMORY;
+
   for (i= 0; i < table->s->fields; i++) 
   {
     Field *field= table->field[i];
     const NDBCOL *col= tab->getColumn(i);
+    if (col->getStorageType() == NDB_STORAGETYPE_MEMORY && create_info->storage_media != HA_SM_MEMORY ||
+        col->getStorageType() == NDB_STORAGETYPE_DISK && create_info->storage_media != HA_SM_DISK)
+    {
+      DBUG_PRINT("info", ("Column storage media is changed"));
+      DBUG_RETURN(COMPATIBLE_DATA_NO);
+    }
+    
     if (field->flags & FIELD_IS_RENAMED)
     {
       DBUG_PRINT("info", ("Field has been renamed, copy table"));
diff --git a/sql/item.cc b/sql/item.cc
index 43f182307f1..72cbc91b91e 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -1791,9 +1791,10 @@ void Item_ident::print(String *str)
     }
   }
 
-  if (!table_name || !field_name)
+  if (!table_name || !field_name || !field_name[0])
   {
-    const char *nm= field_name ? field_name : name ? name : "tmp_field";
+    const char *nm= (field_name && field_name[0]) ?
+                      field_name : name ? name : "tmp_field";
     append_identifier(thd, str, nm, (uint) strlen(nm));
     return;
   }
@@ -3354,7 +3355,7 @@ resolve_ref_in_select_and_group(THD *thd, Item_ident *ref, SELECT_LEX *select)
   ORDER *group_list= (ORDER*) select->group_list.first;
   bool ambiguous_fields= FALSE;
   uint counter;
-  bool not_used;
+  enum_resolution_type resolution;
 
   /*
     Search for a column or derived column named as 'ref' in the SELECT
@@ -3362,8 +3363,10 @@ resolve_ref_in_select_and_group(THD *thd, Item_ident *ref, SELECT_LEX *select)
   */
   if (!(select_ref= find_item_in_list(ref, *(select->get_item_list()),
                                       &counter, REPORT_EXCEPT_NOT_FOUND,
-                                      &not_used)))
+                                      &resolution)))
     return NULL; /* Some error occurred. */
+  if (resolution == RESOLVED_AGAINST_ALIAS)
+    ref->alias_name_used= TRUE;
 
   /* If this is a non-aggregated field inside HAVING, search in GROUP BY. */
   if (select->having_fix_field && !ref->with_sum_func && group_list)
@@ -3473,7 +3476,12 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
   */
   Name_resolution_context *last_checked_context= context;
   Item **ref= (Item **) not_found_item;
-  Name_resolution_context *outer_context= context->outer_context;
+  SELECT_LEX *current_sel= (SELECT_LEX *) thd->lex->current_select;
+  Name_resolution_context *outer_context= 0;
+  /* Currently derived tables cannot be correlated */
+  if (current_sel->master_unit()->first_select()->linkage !=
+      DERIVED_TABLE_TYPE)
+    outer_context= context->outer_context;
   for (;
        outer_context;
        outer_context= outer_context->outer_context)
@@ -3664,9 +3672,9 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
     *ref= NULL;                             // Don't call set_properties()
     rf= (place == IN_HAVING ?
          new Item_ref(context, ref, (char*) table_name,
-                      (char*) field_name) :
+                      (char*) field_name, alias_name_used) :
          new Item_direct_ref(context, ref, (char*) table_name,
-                             (char*) field_name));
+                             (char*) field_name, alias_name_used));
     *ref= save;
     if (!rf)
       return -1;
@@ -3784,12 +3792,14 @@ bool Item_field::fix_fields(THD *thd, Item **reference)
       if (thd->lex->current_select->is_item_list_lookup)
       {
         uint counter;
-        bool not_used;
+        enum_resolution_type resolution;
         Item** res= find_item_in_list(this, thd->lex->current_select->item_list,
                                       &counter, REPORT_EXCEPT_NOT_FOUND,
-                                      &not_used);
+                                      &resolution);
         if (!res)
           return 1;
+        if (resolution == RESOLVED_AGAINST_ALIAS)
+          alias_name_used= TRUE;
         if (res != (Item **)not_found_item)
         {
           if ((*res)->type() == Item::FIELD_ITEM)
@@ -4993,12 +5003,30 @@ Item *Item_field::update_value_transformer(byte *select_arg)
 }
 
 
+void Item_field::print(String *str)
+{
+  if (field && field->table->const_table)
+  {
+    char buff[MAX_FIELD_WIDTH];
+    String tmp(buff,sizeof(buff),str->charset());
+    field->val_str(&tmp);
+    str->append('\'');
+    str->append(tmp);
+    str->append('\'');
+    return;
+  }
+  Item_ident::print(str);
+}
+
+
 Item_ref::Item_ref(Name_resolution_context *context_arg,
                    Item **item, const char *table_name_arg,
-                   const char *field_name_arg)
+                   const char *field_name_arg,
+                   bool alias_name_used_arg)
   :Item_ident(context_arg, NullS, table_name_arg, field_name_arg),
    result_field(0), ref(item)
 {
+  alias_name_used= alias_name_used_arg;
   /*
     This constructor used to create some internals references over fixed items
   */
@@ -5281,11 +5309,13 @@ void Item_ref::set_properties()
   */
   with_sum_func= (*ref)->with_sum_func;
   unsigned_flag= (*ref)->unsigned_flag;
+  fixed= 1;
+  if (alias_name_used)
+    return;
   if ((*ref)->type() == FIELD_ITEM)
     alias_name_used= ((Item_ident *) (*ref))->alias_name_used;
   else
     alias_name_used= TRUE; // it is not field, so it is was resolved by alias
-  fixed= 1;
 }
 
 
@@ -5303,7 +5333,7 @@ void Item_ref::print(String *str)
   if (ref)
   {
     if ((*ref)->type() != Item::CACHE_ITEM && ref_type() != VIEW_REF &&
-        ref_type() != OUTER_REF && name && alias_name_used)
+        !table_name && name && alias_name_used)
     {
       THD *thd= current_thd;
       append_identifier(thd, str, name, (uint) strlen(name));
diff --git a/sql/item.h b/sql/item.h
index be4636db91e..dfe8842dfbb 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -1398,6 +1398,7 @@ public:
   Item *safe_charset_converter(CHARSET_INFO *tocs);
   int fix_outer_field(THD *thd, Field **field, Item **reference);
   virtual Item *update_value_transformer(byte *select_arg);
+  void print(String *str);
   friend class Item_default_value;
   friend class Item_insert_value;
   friend class st_select_lex_unit;
@@ -1876,7 +1877,10 @@ public:
   Item_hex_string(const char *str,uint str_length);
   enum Type type() const { return VARBIN_ITEM; }
   double val_real()
-    { DBUG_ASSERT(fixed == 1); return (double) Item_hex_string::val_int(); }
+  { 
+    DBUG_ASSERT(fixed == 1); 
+    return (double) (ulonglong) Item_hex_string::val_int();
+  }
   longlong val_int();
   bool basic_const_item() const { return 1; }
   String *val_str(String*) { DBUG_ASSERT(fixed == 1); return &str_value; }
@@ -1951,7 +1955,8 @@ public:
          with Bar, and if we have a more broader set of problems like this.
   */
   Item_ref(Name_resolution_context *context_arg, Item **item,
-           const char *table_name_arg, const char *field_name_arg);
+           const char *table_name_arg, const char *field_name_arg,
+           bool alias_name_used_arg= FALSE);
 
   /* Constructor need to process subselect with temporary tables (see Item) */
   Item_ref(THD *thd, Item_ref *item)
@@ -2026,8 +2031,11 @@ class Item_direct_ref :public Item_ref
 public:
   Item_direct_ref(Name_resolution_context *context_arg, Item **item,
                   const char *table_name_arg,
-                  const char *field_name_arg)
-    :Item_ref(context_arg, item, table_name_arg, field_name_arg) {}
+                  const char *field_name_arg,
+                  bool alias_name_used_arg= FALSE)
+    :Item_ref(context_arg, item, table_name_arg,
+              field_name_arg, alias_name_used_arg)
+  {}
   /* Constructor need to process subselect with temporary tables (see Item) */
   Item_direct_ref(THD *thd, Item_direct_ref *item) : Item_ref(thd, item) {}
 
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index e78550598f5..7e5df8fdbbf 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -2190,9 +2190,100 @@ void Item_func_coalesce::fix_length_and_dec()
  Classes and function for the IN operator
 ****************************************************************************/
 
-static int cmp_longlong(void *cmp_arg, longlong *a,longlong *b)
+/*
+  Determine which of the signed longlong arguments is bigger
+
+  SYNOPSIS
+    cmp_longs()
+      a_val     left argument
+      b_val     right argument
+
+  DESCRIPTION
+    This function will compare two signed longlong arguments
+    and will return -1, 0, or 1 if left argument is smaller than,
+    equal to or greater than the right argument.
+
+  RETURN VALUE
+    -1          left argument is smaller than the right argument.
+    0           left argument is equal to the right argument.
+    1           left argument is greater than the right argument.
+*/
+static inline int cmp_longs (longlong a_val, longlong b_val)
 {
-  return *a < *b ? -1 : *a == *b ? 0 : 1;
+  return a_val < b_val ? -1 : a_val == b_val ? 0 : 1;
+}
+
+
+/*
+  Determine which of the unsigned longlong arguments is bigger
+
+  SYNOPSIS
+    cmp_ulongs()
+      a_val     left argument
+      b_val     right argument
+
+  DESCRIPTION
+    This function will compare two unsigned longlong arguments
+    and will return -1, 0, or 1 if left argument is smaller than,
+    equal to or greater than the right argument.
+
+  RETURN VALUE
+    -1          left argument is smaller than the right argument.
+    0           left argument is equal to the right argument.
+    1           left argument is greater than the right argument.
+*/
+static inline int cmp_ulongs (ulonglong a_val, ulonglong b_val)
+{
+  return a_val < b_val ? -1 : a_val == b_val ? 0 : 1;
+}
+
+
+/*
+  Compare two integers in IN value list format (packed_longlong) 
+
+  SYNOPSIS
+    cmp_longlong()
+      cmp_arg   an argument passed to the calling function (qsort2)
+      a         left argument
+      b         right argument
+
+  DESCRIPTION
+    This function will compare two integer arguments in the IN value list
+    format and will return -1, 0, or 1 if left argument is smaller than,
+    equal to or greater than the right argument.
+    It's used in sorting the IN values list and finding an element in it.
+    Depending on the signedness of the arguments cmp_longlong() will
+    compare them as either signed (using cmp_longs()) or unsigned (using
+    cmp_ulongs()).
+
+  RETURN VALUE
+    -1          left argument is smaller than the right argument.
+    0           left argument is equal to the right argument.
+    1           left argument is greater than the right argument.
+*/
+int cmp_longlong(void *cmp_arg, 
+                 in_longlong::packed_longlong *a,
+                 in_longlong::packed_longlong *b)
+{
+  if (a->unsigned_flag != b->unsigned_flag)
+  { 
+    /* 
+      One of the args is unsigned and is too big to fit into the 
+      positive signed range. Report no match.
+    */  
+    if (a->unsigned_flag && ((ulonglong) a->val) > LONGLONG_MAX ||
+        b->unsigned_flag && ((ulonglong) b->val) > LONGLONG_MAX)
+      return a->unsigned_flag ? 1 : -1;
+    /*
+      Although the signedness differs both args can fit into the signed 
+      positive range. Make them signed and compare as usual.
+    */  
+    return cmp_longs (a->val, b->val);
+  }
+  if (a->unsigned_flag)
+    return cmp_ulongs ((ulonglong) a->val, (ulonglong) b->val);
+  else
+    return cmp_longs (a->val, b->val);
 }
 
 static int cmp_double(void *cmp_arg, double *a,double *b)
@@ -2317,19 +2408,23 @@ void in_row::set(uint pos, Item *item)
 }
 
 in_longlong::in_longlong(uint elements)
-  :in_vector(elements,sizeof(longlong),(qsort2_cmp) cmp_longlong, 0)
+  :in_vector(elements,sizeof(packed_longlong),(qsort2_cmp) cmp_longlong, 0)
 {}
 
 void in_longlong::set(uint pos,Item *item)
 {
-  ((longlong*) base)[pos]=item->val_int();
+  struct packed_longlong *buff= &((packed_longlong*) base)[pos];
+  
+  buff->val= item->val_int();
+  buff->unsigned_flag= item->unsigned_flag;
 }
 
 byte *in_longlong::get_value(Item *item)
 {
-  tmp= item->val_int();
+  tmp.val= item->val_int();
   if (item->null_value)
     return 0;
+  tmp.unsigned_flag= item->unsigned_flag;
   return (byte*) &tmp;
 }
 
@@ -2665,6 +2760,31 @@ void Item_func_in::fix_length_and_dec()
   */
   if (type_cnt == 1 && const_itm && !nulls_in_row())
   {
+    /*
+      IN must compare INT/DATE/DATETIME/TIMESTAMP columns and constants
+      as int values (the same way as equality does).
+      So we must check here if the column on the left and all the constant 
+      values on the right can be compared as integers and adjust the 
+      comparison type accordingly.
+    */  
+    if (args[0]->real_item()->type() == FIELD_ITEM &&
+        thd->lex->sql_command != SQLCOM_CREATE_VIEW &&
+        thd->lex->sql_command != SQLCOM_SHOW_CREATE &&
+        cmp_type != INT_RESULT)
+    {
+      Field *field= ((Item_field*) (args[0]->real_item()))->field;
+      if (field->can_be_compared_as_longlong())
+      {
+        bool all_converted= TRUE;
+        for (arg=args+1, arg_end=args+arg_count; arg != arg_end ; arg++)
+        {
+          if (!convert_constant_item (thd, field, &arg[0]))
+            all_converted= FALSE;
+        }
+        if (all_converted)
+          cmp_type= INT_RESULT;
+      }
+    }
     switch (cmp_type) {
     case STRING_RESULT:
       array=new in_string(arg_count - 1,(qsort2_cmp) srtcmp_in,
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h
index 3b08036368c..edc905d50ff 100644
--- a/sql/item_cmpfunc.h
+++ b/sql/item_cmpfunc.h
@@ -785,7 +785,16 @@ public:
 
 class in_longlong :public in_vector
 {
-  longlong tmp;
+  /*
+    Here we declare a temporary variable (tmp) of the same type as the
+    elements of this vector. tmp is used in finding if a given value is in 
+    the list. 
+  */
+  struct packed_longlong 
+  {
+    longlong val;
+    longlong unsigned_flag;  // Use longlong, not bool, to preserve alignment
+  } tmp;
 public:
   in_longlong(uint elements);
   void set(uint pos,Item *item);
@@ -801,9 +810,13 @@ public:
   }
   void value_to_item(uint pos, Item *item)
   {
-    ((Item_int*)item)->value= ((longlong*)base)[pos];
+    ((Item_int*) item)->value= ((packed_longlong*) base)[pos].val;
+    ((Item_int*) item)->unsigned_flag= (my_bool)
+      ((packed_longlong*) base)[pos].unsigned_flag;
   }
   Item_result result_type() { return INT_RESULT; }
+
+  friend int cmp_longlong(void *cmp_arg, packed_longlong *a,packed_longlong *b);
 };
 
 class in_double :public in_vector
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 55888f6b16a..c823575b240 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -413,8 +413,13 @@ bool Item_func::eq(const Item *item, bool binary_cmp) const
   if (item->type() != FUNC_ITEM)
     return 0;
   Item_func *item_func=(Item_func*) item;
-  if (arg_count != item_func->arg_count ||
-      func_name() != item_func->func_name())
+  Item_func::Functype func_type;
+  if ((func_type= functype()) != item_func->functype() ||
+      arg_count != item_func->arg_count ||
+      (func_type != Item_func::FUNC_SP &&
+       func_name() != item_func->func_name()) ||
+      (func_type == Item_func::FUNC_SP &&
+       my_strcasecmp(system_charset_info, func_name(), item_func->func_name())))
     return 0;
   for (uint i=0; i < arg_count ; i++)
     if (!args[i]->eq(item_func->args[i], binary_cmp))
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index b96567cf1ff..a011a2884c8 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -964,18 +964,18 @@ String *Item_func_insert::val_str(String *str)
       args[3]->null_value)
     goto null; /* purecov: inspected */
 
-  if ((start < 0) || (start > res->length() + 1))
+  if ((start < 0) || (start > res->length()))
     return res;                                 // Wrong param; skip insert
-  if ((length < 0) || (length > res->length() + 1))
-    length= res->length() + 1;
+  if ((length < 0) || (length > res->length()))
+    length= res->length();
 
   /* start and length are now sufficiently valid to pass to charpos function */
    start= res->charpos((int) start);
    length= res->charpos((int) length, (uint32) start);
 
   /* Re-testing with corrected params */
-  if (start > res->length() + 1)
-    return res;                                 // Wrong param; skip insert
+  if (start > res->length())
+    return res; /* purecov: inspected */        // Wrong param; skip insert
   if (length > res->length() - start)
     length= res->length() - start;
 
@@ -1181,11 +1181,10 @@ void Item_func_substr::fix_length_and_dec()
   if (args[1]->const_item())
   {
     int32 start= (int32) args[1]->val_int();
-    start= (int32)((start < 0) ? max_length + start : start - 1);
-    if (start < 0 || start >= (int32) max_length)
-      max_length=0; /* purecov: inspected */
+    if (start < 0)
+      max_length= ((uint)(-start) > max_length) ? 0 : (uint)(-start);
     else
-      max_length-= (uint) start;
+      max_length-= min((uint)(start - 1), max_length);
   }
   if (arg_count == 3 && args[2]->const_item())
   {
diff --git a/sql/item_strfunc.h b/sql/item_strfunc.h
index ae11e001551..628b51a70d7 100644
--- a/sql/item_strfunc.h
+++ b/sql/item_strfunc.h
@@ -601,7 +601,11 @@ class Item_func_unhex :public Item_str_func
 {
   String tmp_value;
 public:
-  Item_func_unhex(Item *a) :Item_str_func(a) {}
+  Item_func_unhex(Item *a) :Item_str_func(a) 
+  { 
+    /* there can be bad hex strings */
+    maybe_null= 1; 
+  }
   const char *func_name() const { return "unhex"; }
   String *val_str(String *);
   void fix_length_and_dec()
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index a1a7c20fc50..efcbdf968bf 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -1188,9 +1188,29 @@ SQL_SELECT *make_select(TABLE *head, table_map const_tables,
 			table_map read_tables, COND *conds,
                         bool allow_null_cond,  int *error);
 extern Item **not_found_item;
+
+/*
+  This enumeration type is used only by the function find_item_in_list
+  to return the info on how an item has been resolved against a list
+  of possibly aliased items.
+  The item can be resolved: 
+   - against an alias name of the list's element (RESOLVED_AGAINST_ALIAS)
+   - against non-aliased field name of the list  (RESOLVED_WITH_NO_ALIAS)
+   - against an aliased field name of the list   (RESOLVED_BEHIND_ALIAS)
+   - ignoring the alias name in cases when SQL requires to ignore aliases
+     (e.g. when the resolved field reference contains a table name or
+     when the resolved item is an expression)   (RESOLVED_IGNORING_ALIAS)    
+*/
+enum enum_resolution_type {
+  NOT_RESOLVED=0,
+  RESOLVED_IGNORING_ALIAS,
+  RESOLVED_BEHIND_ALIAS,
+  RESOLVED_WITH_NO_ALIAS,
+  RESOLVED_AGAINST_ALIAS
+};
 Item ** find_item_in_list(Item *item, List<Item> &items, uint *counter,
                           find_item_error_report_type report_error,
-                          bool *unaliased);
+                          enum_resolution_type *resolution);
 bool get_key_map_from_key_list(key_map *map, TABLE *table,
                                List<String> *index_list);
 bool insert_fields(THD *thd, Name_resolution_context *context,
@@ -1248,7 +1268,8 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table,
                                st_table_list *TABLE_LIST::*link,
                                const char *db_name,
                                const char *table_name);
-TABLE_LIST *unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list);
+TABLE_LIST *unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list,
+                         bool check_alias);
 TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name);
 TABLE *find_temporary_table(THD *thd, TABLE_LIST *table_list);
 bool close_temporary_table(THD *thd, TABLE_LIST *table_list);
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 758dc54316e..168c4d30b73 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -1804,6 +1804,12 @@ static bool cache_thread()
       thd= thread_cache.get();
       thd->thread_stack= (char*) &thd;          // For store_globals
       (void) thd->store_globals();
+      /*
+        THD::mysys_var::abort is associated with physical thread rather
+        than with THD object. So we need to reset this flag before using
+        this thread for handling of new THD object/connection.
+      */
+      thd->mysys_var->abort= 0;
       thd->thr_create_time= time(NULL);
       threads.append(thd);
       return(1);
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 3dc780e1b5f..05b22cee935 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -8924,7 +8924,7 @@ get_best_group_min_max(PARAM *param, SEL_TREE *tree)
   if ((join->tables != 1) ||  /* The query must reference one table. */
       ((!join->group_list) && /* Neither GROUP BY nor a DISTINCT query. */
        (!join->select_distinct)) ||
-      (thd->lex->select_lex.olap == ROLLUP_TYPE)) /* Check (B3) for ROLLUP */
+      (join->select_lex->olap == ROLLUP_TYPE)) /* Check (B3) for ROLLUP */
     DBUG_RETURN(NULL);
   if (table->s->keys == 0)        /* There are no indexes to use. */
     DBUG_RETURN(NULL);
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index 1e0986f6e82..4d286d237af 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -1127,6 +1127,7 @@ sp_head::execute(THD *thd)
         thd->clear_error();
         thd->is_fatal_error= 0;
 	thd->killed= THD::NOT_KILLED;
+        thd->mysys_var->abort= 0;
 	continue;
       }
     }
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 44325fe7b12..e764c498059 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -1410,6 +1410,7 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table,
     thd                   thread handle
     table                 table which should be checked
     table_list            list of tables
+    check_alias           whether to check tables' aliases
 
   NOTE: to exclude derived tables from check we use following mechanism:
     a) during derived table processing set THD::derived_tables_processing
@@ -1437,10 +1438,11 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table,
     0 if table is unique
 */
 
-TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list)
+TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list,
+                         bool check_alias)
 {
   TABLE_LIST *res;
-  const char *d_name, *t_name;
+  const char *d_name, *t_name, *t_alias;
   DBUG_ENTER("unique_table");
   DBUG_PRINT("enter", ("table alias: %s", table->alias));
 
@@ -1468,6 +1470,7 @@ TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list)
   }
   d_name= table->db;
   t_name= table->table_name;
+  t_alias= table->alias;
 
   DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
   for (;;)
@@ -1475,6 +1478,9 @@ TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list)
     if (((! (res= find_table_in_global_list(table_list, d_name, t_name))) &&
          (! (res= mysql_lock_have_duplicate(thd, table, table_list)))) ||
         ((!res->table || res->table != table->table) &&
+         (!check_alias || !(lower_case_table_names ?
+          my_strcasecmp(files_charset_info, t_alias, res->alias) :
+          strcmp(t_alias, res->alias))) &&
          res->select_lex && !res->select_lex->exclude_from_table_unique_test &&
          !res->prelocking_placeholder))
       break;
@@ -4577,10 +4583,13 @@ find_field_in_tables(THD *thd, Item_ident *item,
 				return not_found_item, report other errors,
 				return 0
       IGNORE_ERRORS		Do not report errors, return 0 if error
-    unaliased                   Set to true if item is field which was found
-                                by original field name and not by its alias
-                                in item list. Set to false otherwise.
-
+    resolution                  Set to the resolution type if the item is found 
+                                (it says whether the item is resolved 
+                                 against an alias name,
+                                 or as a field name without alias,
+                                 or as a field hidden by alias,
+                                 or ignoring alias)
+                                
   RETURN VALUES
     0			Item is not found or item is not unique,
 			error message is reported
@@ -4596,7 +4605,8 @@ Item **not_found_item= (Item**) 0x1;
 
 Item **
 find_item_in_list(Item *find, List<Item> &items, uint *counter,
-                  find_item_error_report_type report_error, bool *unaliased)
+                  find_item_error_report_type report_error,
+                  enum_resolution_type *resolution)
 {
   List_iterator<Item> li(items);
   Item **found=0, **found_unaliased= 0, *item;
@@ -4610,10 +4620,9 @@ find_item_in_list(Item *find, List<Item> &items, uint *counter,
   */
   bool is_ref_by_name= 0;
   uint unaliased_counter;
-
   LINT_INIT(unaliased_counter);                 // Dependent on found_unaliased
 
-  *unaliased= FALSE;
+  *resolution= NOT_RESOLVED;
 
   is_ref_by_name= (find->type() == Item::FIELD_ITEM  || 
                    find->type() == Item::REF_ITEM);
@@ -4680,63 +4689,77 @@ find_item_in_list(Item *find, List<Item> &items, uint *counter,
           }
           found_unaliased= li.ref();
           unaliased_counter= i;
+          *resolution= RESOLVED_IGNORING_ALIAS;
           if (db_name)
             break;                              // Perfect match
         }
       }
-      else if (!my_strcasecmp(system_charset_info, item_field->name,
-                              field_name))
+      else
       {
-        /*
-          If table name was not given we should scan through aliases
-          (or non-aliased fields) first. We are also checking unaliased
-          name of the field in then next else-if, to be able to find
-          instantly field (hidden by alias) if no suitable alias (or
-          non-aliased field) was found.
-        */
-        if (found)
+        int fname_cmp= my_strcasecmp(system_charset_info,
+                                     item_field->field_name,
+                                     field_name);
+        if (!my_strcasecmp(system_charset_info,
+                           item_field->name,field_name))
         {
-          if ((*found)->eq(item, 0))
-            continue;                           // Same field twice
-          if (report_error != IGNORE_ERRORS)
-            my_error(ER_NON_UNIQ_ERROR, MYF(0),
-                     find->full_name(), current_thd->where);
-          return (Item**) 0;
+          /*
+            If table name was not given we should scan through aliases
+            and non-aliased fields first. We are also checking unaliased
+            name of the field in then next  else-if, to be able to find
+            instantly field (hidden by alias) if no suitable alias or
+            non-aliased field was found.
+          */
+          if (found)
+          {
+            if ((*found)->eq(item, 0))
+              continue;                           // Same field twice
+            if (report_error != IGNORE_ERRORS)
+              my_error(ER_NON_UNIQ_ERROR, MYF(0),
+                       find->full_name(), current_thd->where);
+            return (Item**) 0;
+          }
+          found= li.ref();
+          *counter= i;
+          *resolution= fname_cmp ? RESOLVED_AGAINST_ALIAS:
+	                           RESOLVED_WITH_NO_ALIAS;
         }
-        found= li.ref();
-        *counter= i;
-      }
-      else if (!my_strcasecmp(system_charset_info, item_field->field_name,
-                              field_name))
-      {
-        /*
-          We will use un-aliased field or react on such ambiguities only if
-          we won't be able to find aliased field.
-          Again if we have ambiguity with field outside of select list
-          we should prefer fields from select list.
-        */
-        if (found_unaliased)
-        {
-          if ((*found_unaliased)->eq(item, 0))
-            continue;                           // Same field twice
-          found_unaliased_non_uniq= 1;
-        }
-        else
+        else if (!fname_cmp)
         {
+          /*
+            We will use non-aliased field or react on such ambiguities only if
+            we won't be able to find aliased field.
+            Again if we have ambiguity with field outside of select list
+            we should prefer fields from select list.
+          */
+          if (found_unaliased)
+          {
+            if ((*found_unaliased)->eq(item, 0))
+              continue;                           // Same field twice
+            found_unaliased_non_uniq= 1;
+          }
           found_unaliased= li.ref();
           unaliased_counter= i;
         }
       }
     }
-    else if (!table_name && (find->eq(item,0) ||
-			     is_ref_by_name && find->name && item->name &&
-			     !my_strcasecmp(system_charset_info, 
-					    item->name,find->name)))
-    {
-      found= li.ref();
-      *counter= i;
-      break;
-    }
+    else if (!table_name)
+    { 
+      if (is_ref_by_name && find->name && item->name &&
+	  !my_strcasecmp(system_charset_info,item->name,find->name))
+      {
+        found= li.ref();
+        *counter= i;
+        *resolution= RESOLVED_AGAINST_ALIAS;
+        break;
+      }
+      else if (find->eq(item,0))
+      {
+        found= li.ref();
+        *counter= i;
+        *resolution= RESOLVED_IGNORING_ALIAS;
+        break;
+      }
+    } 
   }
   if (!found)
   {
@@ -4751,7 +4774,7 @@ find_item_in_list(Item *find, List<Item> &items, uint *counter,
     {
       found= found_unaliased;
       *counter= unaliased_counter;
-      *unaliased= TRUE;
+      *resolution= RESOLVED_BEHIND_ALIAS;
     }
   }
   if (found)
@@ -5533,6 +5556,7 @@ bool setup_fields(THD *thd, Item **ref_pointer_array,
   enum_mark_columns save_mark_used_columns= thd->mark_used_columns;
   nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
   List_iterator<Item> it(fields);
+  bool save_is_item_list_lookup;
   DBUG_ENTER("setup_fields");
 
   thd->mark_used_columns= mark_used_columns;
@@ -5540,6 +5564,8 @@ bool setup_fields(THD *thd, Item **ref_pointer_array,
   if (allow_sum_func)
     thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
   thd->where= THD::DEFAULT_WHERE;
+  save_is_item_list_lookup= thd->lex->current_select->is_item_list_lookup;
+  thd->lex->current_select->is_item_list_lookup= 0;
 
   /*
     To prevent fail on forward lookup we fill it with zerows,
@@ -5562,6 +5588,7 @@ bool setup_fields(THD *thd, Item **ref_pointer_array,
     if (!item->fixed && item->fix_fields(thd, it.ref()) ||
 	(item= *(it.ref()))->check_cols(1))
     {
+      thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
       thd->lex->allow_sum_func= save_allow_sum_func;
       thd->mark_used_columns= save_mark_used_columns;
       DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
@@ -5575,6 +5602,7 @@ bool setup_fields(THD *thd, Item **ref_pointer_array,
     thd->used_tables|= item->used_tables();
     thd->lex->current_select->cur_pos_in_select_list++;
   }
+  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
   thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
 
   thd->lex->allow_sum_func= save_allow_sum_func;
@@ -6068,6 +6096,8 @@ int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
   */
   bool it_is_update= (select_lex == &thd->lex->select_lex) &&
     thd->lex->which_check_option_applicable();
+  bool save_is_item_list_lookup= select_lex->is_item_list_lookup;
+  select_lex->is_item_list_lookup= 0;
   DBUG_ENTER("setup_conds");
 
   if (select_lex->conds_processed_with_permanent_arena ||
@@ -6143,9 +6173,11 @@ int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
     select_lex->where= *conds;
     select_lex->conds_processed_with_permanent_arena= 1;
   }
+  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
   DBUG_RETURN(test(thd->net.report_error));
 
 err_no_arena:
+  select_lex->is_item_list_lookup= save_is_item_list_lookup;
   DBUG_RETURN(1);
 }
 
diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc
index 3ab053d1741..07313c954ba 100644
--- a/sql/sql_delete.cc
+++ b/sql/sql_delete.cc
@@ -395,7 +395,7 @@ bool mysql_prepare_delete(THD *thd, TABLE_LIST *table_list, Item **conds)
   }
   {
     TABLE_LIST *duplicate;
-    if ((duplicate= unique_table(thd, table_list, table_list->next_global)))
+    if ((duplicate= unique_table(thd, table_list, table_list->next_global, 0)))
     {
       update_non_unique_table_error(table_list, "DELETE", duplicate);
       DBUG_RETURN(TRUE);
@@ -492,7 +492,7 @@ bool mysql_multi_delete_prepare(THD *thd)
     {
       TABLE_LIST *duplicate;
       if ((duplicate= unique_table(thd, target_tbl->correspondent_table,
-                                   lex->query_tables)))
+                                   lex->query_tables, 0)))
       {
         update_non_unique_table_error(target_tbl->correspondent_table,
                                       "DELETE", duplicate);
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index f58d08b8dea..479154cbed2 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -1063,7 +1063,7 @@ bool mysql_prepare_insert(THD *thd, TABLE_LIST *table_list,
   {
     Item *fake_conds= 0;
     TABLE_LIST *duplicate;
-    if ((duplicate= unique_table(thd, table_list, table_list->next_global)))
+    if ((duplicate= unique_table(thd, table_list, table_list->next_global, 1)))
     {
       update_non_unique_table_error(table_list, "INSERT", duplicate);
       DBUG_RETURN(TRUE);
@@ -2576,7 +2576,7 @@ select_insert::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
     query
   */
   if (!(lex->current_select->options & OPTION_BUFFER_RESULT) &&
-      unique_table(thd, table_list, table_list->next_global))
+      unique_table(thd, table_list, table_list->next_global, 0))
   {
     /* Using same table for INSERT and SELECT */
     lex->current_select->options|= OPTION_BUFFER_RESULT;
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index ef1f0592051..389e7b5fd7a 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -1224,6 +1224,7 @@ void st_select_lex::init_select()
   is_correlated= 0;
   cur_pos_in_select_list= UNDEF_POS;
   non_agg_fields.empty();
+  cond_value= having_value= Item::COND_UNDEF;
   inner_refs_list.empty();
 }
 
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index 33d028c829e..1271df5e458 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -523,6 +523,8 @@ public:
   Item *where, *having;                         /* WHERE & HAVING clauses */
   Item *prep_where; /* saved WHERE clause for prepared statement processing */
   Item *prep_having;/* saved HAVING clause for prepared statement processing */
+  /* Saved values of the WHERE and HAVING clauses*/
+  Item::cond_result cond_value, having_value;
   /* point on lex in which it was created, used in view subquery detection */
   st_lex *parent_lex;
   enum olap_type olap;
diff --git a/sql/sql_load.cc b/sql/sql_load.cc
index 09066e875bd..cf356a4b336 100644
--- a/sql/sql_load.cc
+++ b/sql/sql_load.cc
@@ -175,7 +175,7 @@ bool mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list,
     table is marked to be 'used for insert' in which case we should never
     mark this table as 'const table' (ie, one that has only one row).
   */
-  if (unique_table(thd, table_list, table_list->next_global))
+  if (unique_table(thd, table_list, table_list->next_global, 0))
   {
     my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name);
     DBUG_RETURN(TRUE);
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 33209b6e023..d083e01514f 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -689,7 +689,10 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
   DBUG_ENTER("dispatch_command");
 
   if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
+  {
     thd->killed= THD::NOT_KILLED;
+    thd->mysys_var->abort= 0;
+  }
 
   thd->command=command;
   /*
@@ -2171,7 +2174,7 @@ mysql_execute_command(THD *thd)
         if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
         {
           TABLE_LIST *duplicate;
-          if ((duplicate= unique_table(thd, create_table, select_tables)))
+          if ((duplicate= unique_table(thd, create_table, select_tables, 0)))
           {
             update_non_unique_table_error(create_table, "CREATE", duplicate);
             res= 1;
@@ -2187,7 +2190,7 @@ mysql_execute_command(THD *thd)
                tab= tab->next_local)
           {
             TABLE_LIST *duplicate;
-            if ((duplicate= unique_table(thd, tab, select_tables)))
+            if ((duplicate= unique_table(thd, tab, select_tables, 0)))
             {
               update_non_unique_table_error(tab, "CREATE", duplicate);
               res= 1;
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index d062cbb3ef6..c901655f2d3 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -396,6 +396,7 @@ JOIN::prepare(Item ***rref_pointer_array,
   join_list= &select_lex->top_join_list;
   union_part= (unit_arg->first_select()->next_select() != 0);
 
+  thd->lex->current_select->is_item_list_lookup= 1;
   /*
     If we have already executed SELECT, then it have not sense to prevent
     its table from update (see unique_table())
@@ -455,6 +456,17 @@ JOIN::prepare(Item ***rref_pointer_array,
 
   select_lex->fix_prepare_information(thd, &conds, &having);
 
+  if (order)
+  {
+    ORDER *ord;
+    for (ord= order; ord; ord= ord->next)
+    {
+      Item *item= *ord->item;
+      if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM)
+        item->split_sum_func(thd, ref_pointer_array, all_fields);
+    }
+  }
+
   if (having && having->with_sum_func)
     having->split_sum_func2(thd, ref_pointer_array, all_fields,
                             &having, TRUE);
@@ -738,7 +750,6 @@ JOIN::optimize()
   }
 
   {
-    Item::cond_result having_value;
     having= optimize_cond(this, having, join_list, &having_value);
     if (thd->net.report_error)
     {
@@ -746,6 +757,10 @@ JOIN::optimize()
       DBUG_PRINT("error",("Error from optimize_cond"));
       DBUG_RETURN(1);
     }
+    if (select_lex->where)
+      select_lex->cond_value= cond_value;
+    if (select_lex->having)
+      select_lex->having_value= having_value;
 
     if (cond_value == Item::COND_FALSE || having_value == Item::COND_FALSE || 
         (!unit->select_limit_cnt && !(select_options & OPTION_FOUND_ROWS)))
@@ -906,6 +921,7 @@ JOIN::optimize()
     conds->update_used_tables();
     DBUG_EXECUTE("where", print_where(conds, "after substitute_best_equal"););
   }
+
   /*
     Permorm the the optimization on fields evaluation mentioned above
     for all on expressions.
@@ -7772,6 +7788,10 @@ static COND* substitute_for_best_equal_field(COND *cond,
           break;
       }
     }
+    if (cond->type() == Item::COND_ITEM &&
+        !((Item_cond*)cond)->argument_list()->elements)
+      cond= new Item_int((int32)cond->val_bool());
+
   }
   else if (cond->type() == Item::FUNC_ITEM && 
            ((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)
@@ -13407,7 +13427,7 @@ find_order_in_list(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
   Item **select_item; /* The corresponding item from the SELECT clause. */
   Field *from_field;  /* The corresponding field from the FROM clause. */
   uint counter;
-  bool unaliased;
+  enum_resolution_type resolution;
 
   /*
     Local SP variables may be int but are expressions, not positions.
@@ -13430,7 +13450,7 @@ find_order_in_list(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
   }
   /* Lookup the current GROUP/ORDER field in the SELECT clause. */
   select_item= find_item_in_list(order_item, fields, &counter,
-                                 REPORT_EXCEPT_NOT_FOUND, &unaliased);
+                                 REPORT_EXCEPT_NOT_FOUND, &resolution);
   if (!select_item)
     return TRUE; /* The item is not unique, or some other error occured. */
 
@@ -13444,7 +13464,7 @@ find_order_in_list(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
       original field name, we should additionaly check if we have conflict
       for this name (in case if we would perform lookup in all tables).
     */
-    if (unaliased && !order_item->fixed &&
+    if (resolution == RESOLVED_BEHIND_ALIAS && !order_item->fixed &&
         order_item->fix_fields(thd, order->item))
       return TRUE;
 
@@ -13514,16 +13534,11 @@ find_order_in_list(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
     We check order_item->fixed because Item_func_group_concat can put
     arguments for which fix_fields already was called.
   */
-  thd->lex->current_select->is_item_list_lookup= 1;
   if (!order_item->fixed &&
       (order_item->fix_fields(thd, order->item) ||
        (order_item= *order->item)->check_cols(1) ||
        thd->is_fatal_error))
-  {
-    thd->lex->current_select->is_item_list_lookup= 0;
     return TRUE; /* Wrong field. */
-  }
-  thd->lex->current_select->is_item_list_lookup= 0;
 
   uint el= all_fields.elements;
   all_fields.push_front(order_item); /* Add new field to field list. */
@@ -13675,7 +13690,7 @@ setup_new_fields(THD *thd, List<Item> &fields,
 {
   Item	  **item;
   uint counter;
-  bool not_used;
+  enum_resolution_type not_used;
   DBUG_ENTER("setup_new_fields");
 
   thd->mark_used_columns= MARK_COLUMNS_READ;       // Not really needed, but...
@@ -15635,10 +15650,13 @@ void st_select_lex::print(THD *thd, String *str)
   Item *cur_where= where;
   if (join)
     cur_where= join->conds;
-  if (cur_where)
+  if (cur_where || cond_value != Item::COND_UNDEF)
   {
     str->append(STRING_WITH_LEN(" where "));
-    cur_where->print(str);
+    if (cur_where)
+      cur_where->print(str);
+    else
+      str->append(cond_value != Item::COND_FALSE ? "1" : "0");
   }
 
   // group by & olap
@@ -15664,10 +15682,13 @@ void st_select_lex::print(THD *thd, String *str)
   if (join)
     cur_having= join->having;
 
-  if (cur_having)
+  if (cur_having || having_value != Item::COND_UNDEF)
   {
     str->append(STRING_WITH_LEN(" having "));
-    cur_having->print(str);
+    if (cur_having)
+      cur_having->print(str);
+    else
+      str->append(having_value != Item::COND_FALSE ? "1" : "0");
   }
 
   if (order_list.elements)
diff --git a/sql/sql_select.h b/sql/sql_select.h
index 1d1fa666c60..2e01e54e4ca 100644
--- a/sql/sql_select.h
+++ b/sql/sql_select.h
@@ -331,7 +331,7 @@ public:
 
   bool need_tmp, hidden_group_fields;
   DYNAMIC_ARRAY keyuse;
-  Item::cond_result cond_value;
+  Item::cond_result cond_value, having_value;
   List<Item> all_fields; // to store all fields that used in query
   //Above list changed to use temporary table
   List<Item> tmp_all_fields1, tmp_all_fields2, tmp_all_fields3;
diff --git a/sql/sql_union.cc b/sql/sql_union.cc
index f020168d742..c3635e24407 100644
--- a/sql/sql_union.cc
+++ b/sql/sql_union.cc
@@ -623,6 +623,12 @@ bool st_select_lex_unit::cleanup()
       join->tables= 0;
     }
     error|= fake_select_lex->cleanup();
+    if (fake_select_lex->order_list.elements)
+    {
+      ORDER *ord;
+      for (ord= (ORDER*)fake_select_lex->order_list.first; ord; ord= ord->next)
+        (*ord->item)->cleanup();
+    }
   }
 
   DBUG_RETURN(error);
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index 27a58a295ff..5aea05a9d39 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -761,7 +761,7 @@ bool mysql_prepare_update(THD *thd, TABLE_LIST *table_list,
   /* Check that we are not using table that we are updating in a sub select */
   {
     TABLE_LIST *duplicate;
-    if ((duplicate= unique_table(thd, table_list, table_list->next_global)))
+    if ((duplicate= unique_table(thd, table_list, table_list->next_global, 0)))
     {
       update_non_unique_table_error(table_list, "UPDATE", duplicate);
       my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name);
@@ -987,7 +987,7 @@ reopen_tables:
         tl->lock_type != TL_READ_NO_INSERT)
     {
       TABLE_LIST *duplicate;
-      if ((duplicate= unique_table(thd, tl, table_list)))
+      if ((duplicate= unique_table(thd, tl, table_list, 0)))
       {
         update_non_unique_table_error(table_list, "UPDATE", duplicate);
         DBUG_RETURN(TRUE);
@@ -1203,7 +1203,7 @@ static bool safe_update_on_fly(THD *thd, JOIN_TAB *join_tab,
                                TABLE_LIST *table_ref, TABLE_LIST *all_tables)
 {
   TABLE *table= join_tab->table;
-  if (unique_table(thd, table_ref, all_tables))
+  if (unique_table(thd, table_ref, all_tables, 0))
     return 0;
   switch (join_tab->type) {
   case JT_SYSTEM:
diff --git a/storage/heap/ha_heap.cc b/storage/heap/ha_heap.cc
index cf11c9923eb..f2caa7e6d18 100644
--- a/storage/heap/ha_heap.cc
+++ b/storage/heap/ha_heap.cc
@@ -703,9 +703,10 @@ bool ha_heap::check_if_incompatible_data(HA_CREATE_INFO *info,
 					 uint table_changes)
 {
   /* Check that auto_increment value was not changed */
-  if ((table_changes != IS_EQUAL_YES &&
-       info->used_fields & HA_CREATE_USED_AUTO) &&
-      info->auto_increment_value != 0)
+  if ((info->used_fields & HA_CREATE_USED_AUTO &&
+       info->auto_increment_value != 0) ||
+      table_changes == IS_EQUAL_NO ||
+      table_changes & IS_EQUAL_PACK_LENGTH) // Not implemented yet
     return COMPATIBLE_DATA_NO;
   return COMPATIBLE_DATA_YES;
 }
diff --git a/storage/myisam/ha_myisam.cc b/storage/myisam/ha_myisam.cc
index 06ec5c4b44e..a67d62f7447 100644
--- a/storage/myisam/ha_myisam.cc
+++ b/storage/myisam/ha_myisam.cc
@@ -320,6 +320,12 @@ int table2myisam(TABLE *table_arg, MI_KEYDEF **keydef_out,
   RETURN VALUE
     0 - Equal definitions.
     1 - Different definitions.
+
+  TODO
+    - compare FULLTEXT keys;
+    - compare SPATIAL keys;
+    - compare FIELD_SKIP_ZERO which is converted to FIELD_NORMAL correctly
+      (should be corretly detected in table2myisam).
 */
 
 int check_definition(MI_KEYDEF *t1_keyinfo, MI_COLUMNDEF *t1_recinfo,
@@ -345,6 +351,28 @@ int check_definition(MI_KEYDEF *t1_keyinfo, MI_COLUMNDEF *t1_recinfo,
   {
     HA_KEYSEG *t1_keysegs= t1_keyinfo[i].seg;
     HA_KEYSEG *t2_keysegs= t2_keyinfo[i].seg;
+    if (t1_keyinfo[i].flag & HA_FULLTEXT && t2_keyinfo[i].flag & HA_FULLTEXT)
+      continue;
+    else if (t1_keyinfo[i].flag & HA_FULLTEXT ||
+             t2_keyinfo[i].flag & HA_FULLTEXT)
+    {
+       DBUG_PRINT("error", ("Key %d has different definition", i));
+       DBUG_PRINT("error", ("t1_fulltext= %d, t2_fulltext=%d",
+                            test(t1_keyinfo[i].flag & HA_FULLTEXT),
+                            test(t2_keyinfo[i].flag & HA_FULLTEXT)));
+       DBUG_RETURN(1);
+    }
+    if (t1_keyinfo[i].flag & HA_SPATIAL && t2_keyinfo[i].flag & HA_SPATIAL)
+      continue;
+    else if (t1_keyinfo[i].flag & HA_SPATIAL ||
+             t2_keyinfo[i].flag & HA_SPATIAL)
+    {
+       DBUG_PRINT("error", ("Key %d has different definition", i));
+       DBUG_PRINT("error", ("t1_spatial= %d, t2_spatial=%d",
+                            test(t1_keyinfo[i].flag & HA_SPATIAL),
+                            test(t2_keyinfo[i].flag & HA_SPATIAL)));
+       DBUG_RETURN(1);
+    }
     if (t1_keyinfo[i].keysegs != t2_keyinfo[i].keysegs ||
         t1_keyinfo[i].key_alg != t2_keyinfo[i].key_alg)
     {
@@ -381,7 +409,14 @@ int check_definition(MI_KEYDEF *t1_keyinfo, MI_COLUMNDEF *t1_recinfo,
   {
     MI_COLUMNDEF *t1_rec= &t1_recinfo[i];
     MI_COLUMNDEF *t2_rec= &t2_recinfo[i];
-    if (t1_rec->type != t2_rec->type ||
+    /*
+      FIELD_SKIP_ZERO can be changed to FIELD_NORMAL in mi_create,
+      see NOTE1 in mi_create.c
+    */
+    if ((t1_rec->type != t2_rec->type &&
+         !(t1_rec->type == (int) FIELD_SKIP_ZERO &&
+           t1_rec->length == 1 &&
+           t2_rec->type == (int) FIELD_NORMAL)) ||
         t1_rec->length != t2_rec->length ||
         t1_rec->null_bit != t2_rec->null_bit)
     {
diff --git a/storage/myisam/mi_create.c b/storage/myisam/mi_create.c
index 2b8cbcc7da5..5dd4a98127e 100644
--- a/storage/myisam/mi_create.c
+++ b/storage/myisam/mi_create.c
@@ -158,6 +158,10 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
       rec--;
       if (rec->type == (int) FIELD_SKIP_ZERO && rec->length == 1)
       {
+        /*
+          NOTE1: here we change a field type FIELD_SKIP_ZERO ->
+          FIELD_NORMAL
+        */
 	rec->type=(int) FIELD_NORMAL;
 	packed--;
 	min_pack_length++;
diff --git a/storage/myisam/mi_extra.c b/storage/myisam/mi_extra.c
index ae584b06173..729174b6f88 100644
--- a/storage/myisam/mi_extra.c
+++ b/storage/myisam/mi_extra.c
@@ -350,11 +350,13 @@ int mi_extra(MI_INFO *info, enum ha_extra_function function, void *extra_arg)
 #ifdef HAVE_MMAP
     pthread_mutex_lock(&share->intern_lock);
     /*
-      Memory map the data file if it is not already mapped and if there
-      are no other threads using this table. intern_lock prevents other
-      threads from starting to use the table while we are mapping it.
+      Memory map the data file if it is not already mapped. It is safe
+      to memory map a file while other threads are using file I/O on it.
+      Assigning a new address to a function pointer is an atomic
+      operation. intern_lock prevents that two or more mappings are done
+      at the same time.
     */
-    if (!share->file_map && (share->tot_locks == 1))
+    if (!share->file_map)
     {
       if (mi_dynmap_file(info, share->state.state.data_file_length))
       {
diff --git a/storage/myisam/mi_open.c b/storage/myisam/mi_open.c
index 5db5bc561d1..f4e089b6313 100644
--- a/storage/myisam/mi_open.c
+++ b/storage/myisam/mi_open.c
@@ -506,24 +506,6 @@ MI_INFO *mi_open(const char *name, int mode, uint open_flags)
       share->data_file_type = DYNAMIC_RECORD;
     my_afree((gptr) disk_cache);
     mi_setup_functions(share);
-#ifdef HAVE_MMAP
-    if (open_flags & HA_OPEN_MMAP)
-    {
-      info.s= share;
-      if (mi_dynmap_file(&info, share->state.state.data_file_length))
-      {
-        /* purecov: begin inspected */
-        /* Ignore if mmap fails. Use file I/O instead. */
-        DBUG_PRINT("warning", ("mmap failed: errno: %d", errno));
-        /* purecov: end */
-      }
-      else
-      {
-        share->file_read= mi_mmap_pread;
-        share->file_write= mi_mmap_pwrite;
-      }
-    }
-#endif /* HAVE_MMAP */
     share->is_log_table= FALSE;
 #ifdef THREAD
     thr_lock_init(&share->lock);
@@ -554,6 +536,14 @@ MI_INFO *mi_open(const char *name, int mode, uint open_flags)
       }
     }
 #endif
+    /*
+      Memory mapping can only be requested after initializing intern_lock.
+    */
+    if (open_flags & HA_OPEN_MMAP)
+    {
+      info.s= share;
+      mi_extra(&info, HA_EXTRA_MMAP, 0);
+    }
   }
   else
   {
@@ -1235,7 +1225,7 @@ int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, File file_to_dup __attr
 int mi_open_keyfile(MYISAM_SHARE *share)
 {
   if ((share->kfile=my_open(share->unique_file_name, share->mode | O_SHARE,
-			    MYF(MY_WME))) < 0)
+                            MYF(MY_WME))) < 0)
     return 1;
   return 0;
 }
diff --git a/storage/myisam/rt_index.c b/storage/myisam/rt_index.c
index edb33ec10b9..cf144839dd1 100644
--- a/storage/myisam/rt_index.c
+++ b/storage/myisam/rt_index.c
@@ -184,6 +184,7 @@ int rtree_find_first(MI_INFO *info, uint keynr, uchar *key, uint key_length,
   /*
     Save searched key, include data pointer.
     The data pointer is required if the search_flag contains MBR_DATA.
+    (minimum bounding rectangle)
   */
   memcpy(info->first_mbr_key, key, keyinfo->keylength);
   info->last_rkey_length = key_length;
@@ -538,16 +539,19 @@ static int rtree_insert_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
   uint nod_flag;
   uchar *page_buf;
   int res;
+  DBUG_ENTER("rtree_insert_req");
 
   if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length + 
                                      MI_MAX_KEY_BUFF)))
   {
     my_errno = HA_ERR_OUT_OF_MEM;
-    return -1;
+    DBUG_RETURN(-1); /* purecov: inspected */
   }
   if (!_mi_fetch_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf, 0))
     goto err1;
   nod_flag = mi_test_if_nod(page_buf);
+  DBUG_PRINT("rtree", ("page: %lu  level: %d  ins_level: %d  nod_flag: %u",
+                       (ulong) page, level, ins_level, nod_flag));
 
   if ((ins_level == -1 && nod_flag) ||       /* key: go down to leaf */
       (ins_level > -1 && ins_level > level)) /* branch: go down to ins_level */
@@ -599,11 +603,11 @@ static int rtree_insert_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
 
 ok:
   my_afree((byte*)page_buf);
-  return res;
+  DBUG_RETURN(res);
 
 err1:
   my_afree((byte*)page_buf);
-  return -1;
+  DBUG_RETURN(-1); /* purecov: inspected */
 }
 
 
@@ -623,18 +627,19 @@ static int rtree_insert_level(MI_INFO *info, uint keynr, uchar *key,
   MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
   int res;
   my_off_t new_page;
-  
+  DBUG_ENTER("rtree_insert_level");
+
   if ((old_root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
   {
     if ((old_root = _mi_new(info, keyinfo, DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
-      return -1;
+      DBUG_RETURN(-1);
     info->buff_used = 1;
     mi_putint(info->buff, 2, 0);
     res = rtree_add_key(info, keyinfo, key, key_length, info->buff, NULL);
     if (_mi_write_keypage(info, keyinfo, old_root, DFLT_INIT_HITS, info->buff))
-      return 1;
+      DBUG_RETURN(1);
     info->s->state.key_root[keynr] = old_root;
-    return res;
+    DBUG_RETURN(res);
   }
 
   switch ((res = rtree_insert_req(info, keyinfo, key, key_length, 
@@ -651,11 +656,12 @@ static int rtree_insert_level(MI_INFO *info, uint keynr, uchar *key,
       uchar *new_key;
       uint nod_flag = info->s->base.key_reflength;
 
+      DBUG_PRINT("rtree", ("root was split, grow a new root"));
       if (!(new_root_buf = (uchar*)my_alloca((uint)keyinfo->block_length + 
                                              MI_MAX_KEY_BUFF)))
       {
         my_errno = HA_ERR_OUT_OF_MEM;
-        return -1;
+        DBUG_RETURN(-1); /* purecov: inspected */
       }
 
       mi_putint(new_root_buf, 2, nod_flag);
@@ -681,12 +687,14 @@ static int rtree_insert_level(MI_INFO *info, uint keynr, uchar *key,
                             DFLT_INIT_HITS, new_root_buf))
         goto err1;
       info->s->state.key_root[keynr] = new_root;
+      DBUG_PRINT("rtree", ("new root page: %lu  level: %d  nod_flag: %u",
+                           (ulong) new_root, 0, mi_test_if_nod(new_root_buf)));
 
       my_afree((byte*)new_root_buf);
       break;
 err1:
       my_afree((byte*)new_root_buf);
-      return -1;
+      DBUG_RETURN(-1); /* purecov: inspected */
     }
     default:
     case -1: /* error */
@@ -694,7 +702,7 @@ err1:
       break;
     }
   }
-  return res;
+  DBUG_RETURN(res);
 }
 
 
@@ -708,8 +716,10 @@ err1:
 
 int rtree_insert(MI_INFO *info, uint keynr, uchar *key, uint key_length)
 {
-  return (!key_length ||
-	  (rtree_insert_level(info, keynr, key, key_length, -1) == -1)) ? -1 : 0;
+  DBUG_ENTER("rtree_insert");
+  DBUG_RETURN((!key_length ||
+               (rtree_insert_level(info, keynr, key, key_length, -1) == -1)) ?
+              -1 : 0);
 }
 
 
@@ -724,6 +734,8 @@ int rtree_insert(MI_INFO *info, uint keynr, uchar *key, uint key_length)
 static int rtree_fill_reinsert_list(stPageList *ReinsertList, my_off_t page, 
                                     int level)
 {
+  DBUG_ENTER("rtree_fill_reinsert_list");
+  DBUG_PRINT("rtree", ("page: %lu  level: %d", (ulong) page, level));
   if (ReinsertList->n_pages == ReinsertList->m_pages)
   {
     ReinsertList->m_pages += REINSERT_BUFFER_INC;
@@ -735,10 +747,10 @@ static int rtree_fill_reinsert_list(stPageList *ReinsertList, my_off_t page,
   ReinsertList->pages[ReinsertList->n_pages].offs = page;
   ReinsertList->pages[ReinsertList->n_pages].level = level;
   ReinsertList->n_pages++;
-  return 0;
+  DBUG_RETURN(0);
 
 err1:
-  return -1;
+  DBUG_RETURN(-1); /* purecov: inspected */
 }
 
 
@@ -762,15 +774,18 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
   uint nod_flag;
   uchar *page_buf;
   int res;
+  DBUG_ENTER("rtree_delete_req");
 
   if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length)))
   {
     my_errno = HA_ERR_OUT_OF_MEM;
-    return -1;
+    DBUG_RETURN(-1); /* purecov: inspected */
   }
   if (!_mi_fetch_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf, 0))
     goto err1;
   nod_flag = mi_test_if_nod(page_buf);
+  DBUG_PRINT("rtree", ("page: %lu  level: %d  nod_flag: %u",
+                       (ulong) page, level, nod_flag));
 
   k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
   last = rt_PAGE_END(page_buf);
@@ -791,6 +806,7 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
             if (*page_size + key_length >= rt_PAGE_MIN_SIZE(keyinfo->block_length)) 
             { 
               /* OK */
+              /* Calculate a new key value (MBR) for the shrinked block. */
               if (rtree_set_key_mbr(info, keyinfo, k, key_length, 
                                   _mi_kpos(nod_flag, k)))
                 goto err1;
@@ -800,10 +816,23 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
             }
             else
             { 
-              /* too small: delete key & add it descendant to reinsert list */
+              /*
+                Too small: delete key & add it descendant to reinsert list.
+                Store position and level of the block so that it can be
+                accessed later for inserting the remaining keys.
+              */
+              DBUG_PRINT("rtree", ("too small. move block to reinsert list"));
               if (rtree_fill_reinsert_list(ReinsertList, _mi_kpos(nod_flag, k),
                                            level + 1))
                 goto err1;
+              /*
+                Delete the key that references the block. This makes the
+                block disappear from the index. Hence we need to insert
+                its remaining keys later. Note: if the block is a branch
+                block, we do not only remove this block, but the whole
+                subtree. So we need to re-insert its keys on the same
+                level later to reintegrate the subtrees.
+              */
               rtree_delete_key(info, page_buf, k, key_length, nod_flag);
               if (_mi_write_keypage(info, keyinfo, page,
                                     DFLT_INIT_HITS, page_buf))
@@ -863,11 +892,11 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
 
 ok:
   my_afree((byte*)page_buf);
-  return res;
+  DBUG_RETURN(res);
 
 err1:
   my_afree((byte*)page_buf);
-  return -1;
+  DBUG_RETURN(-1); /* purecov: inspected */
 }
 
 
@@ -885,12 +914,15 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length)
   stPageList ReinsertList;
   my_off_t old_root;
   MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
+  DBUG_ENTER("rtree_delete");
 
   if ((old_root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
   {
     my_errno= HA_ERR_END_OF_FILE;
-    return -1;
+    DBUG_RETURN(-1); /* purecov: inspected */
   }
+  DBUG_PRINT("rtree", ("starting deletion at root page: %lu",
+                       (ulong) old_root));
 
   ReinsertList.pages = NULL;
   ReinsertList.n_pages = 0;
@@ -899,12 +931,12 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length)
   switch (rtree_delete_req(info, keyinfo, key, key_length, old_root, 
                                  &page_size, &ReinsertList, 0))
   {
-    case 2:
+    case 2: /* empty */
     {
       info->s->state.key_root[keynr] = HA_OFFSET_ERROR;
-      return 0;
+      DBUG_RETURN(0);
     }
-    case 0:
+    case 0: /* deleted */
     {
       uint nod_flag;
       ulong i;
@@ -923,16 +955,34 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length)
                                DFLT_INIT_HITS, page_buf, 0))
           goto err1;
         nod_flag = mi_test_if_nod(page_buf);
+        DBUG_PRINT("rtree", ("reinserting keys from "
+                             "page: %lu  level: %d  nod_flag: %u",
+                             (ulong) ReinsertList.pages[i].offs,
+                             ReinsertList.pages[i].level, nod_flag));
+
         k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
         last = rt_PAGE_END(page_buf);
         for (; k < last; k = rt_PAGE_NEXT_KEY(k, key_length, nod_flag))
         {
-          if (rtree_insert_level(info, keynr, k, key_length, 
-                                 ReinsertList.pages[i].level) == -1)
+          int res;
+          if ((res= rtree_insert_level(info, keynr, k, key_length,
+                                       ReinsertList.pages[i].level)) == -1)
           {
             my_afree((byte*)page_buf);
             goto err1;
           }
+          if (res)
+          {
+            ulong j;
+            DBUG_PRINT("rtree", ("root has been split, adjust levels"));
+            for (j= i; j < ReinsertList.n_pages; j++)
+            {
+              ReinsertList.pages[j].level++;
+              DBUG_PRINT("rtree", ("keys from page: %lu  now level: %d",
+                                   (ulong) ReinsertList.pages[i].offs,
+                                   ReinsertList.pages[i].level));
+            }
+          }
         }
         my_afree((byte*)page_buf);
         if (_mi_dispose(info, keyinfo, ReinsertList.pages[i].offs,
@@ -959,20 +1009,20 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length)
         info->s->state.key_root[keynr] = new_root;
       }
       info->update= HA_STATE_DELETED;
-      return 0;
+      DBUG_RETURN(0);
 
 err1:
-      return -1;
+      DBUG_RETURN(-1); /* purecov: inspected */
     }
     case 1: /* not found */
     {
       my_errno = HA_ERR_KEY_NOT_FOUND;
-      return -1;
+      DBUG_RETURN(-1); /* purecov: inspected */
     }
     default:
     case -1: /* error */
     {
-      return -1;
+      DBUG_RETURN(-1); /* purecov: inspected */
     }
   }
 }
diff --git a/storage/myisam/rt_key.c b/storage/myisam/rt_key.c
index cb6a82c51f6..fe59af3c605 100644
--- a/storage/myisam/rt_key.c
+++ b/storage/myisam/rt_key.c
@@ -34,6 +34,7 @@ int rtree_add_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
 {
   uint page_size = mi_getint(page_buf);
   uint nod_flag = mi_test_if_nod(page_buf);
+  DBUG_ENTER("rtree_add_key");
 
   if (page_size + key_length + info->s->base.rec_reflength <=
       keyinfo->block_length)
@@ -42,22 +43,26 @@ int rtree_add_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
     if (nod_flag)
     {
       /* save key */
+      DBUG_ASSERT(_mi_kpos(nod_flag, key) < info->state->key_file_length);
       memcpy(rt_PAGE_END(page_buf), key - nod_flag, key_length + nod_flag); 
       page_size += key_length + nod_flag;
     }
     else
     {
       /* save key */
+      DBUG_ASSERT(_mi_dpos(info, nod_flag, key + key_length +
+                           info->s->base.rec_reflength) <
+                  info->state->data_file_length + info->s->base.pack_reclength);
       memcpy(rt_PAGE_END(page_buf), key, key_length + 
                                          info->s->base.rec_reflength);
       page_size += key_length + info->s->base.rec_reflength;
     }
     mi_putint(page_buf, page_size, nod_flag);
-    return 0;
+    DBUG_RETURN(0);
   }
 
-  return (rtree_split_page(info, keyinfo, page_buf, key, key_length,
-			   new_page) ? -1 : 1);
+  DBUG_RETURN((rtree_split_page(info, keyinfo, page_buf, key, key_length,
+                                new_page) ? -1 : 1));
 }
 
 /*
@@ -89,11 +94,13 @@ int rtree_delete_key(MI_INFO *info, uchar *page_buf, uchar *key,
 int rtree_set_key_mbr(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, 
 		      uint key_length, my_off_t child_page)
 {
+  DBUG_ENTER("rtree_set_key_mbr");
+
   if (!_mi_fetch_keypage(info, keyinfo, child_page,
                          DFLT_INIT_HITS, info->buff, 0))
-    return -1;
+    DBUG_RETURN(-1); /* purecov: inspected */
 
-  return rtree_page_mbr(info, keyinfo->seg, info->buff, key, key_length);
+  DBUG_RETURN(rtree_page_mbr(info, keyinfo->seg, info->buff, key, key_length));
 }
 
 #endif /*HAVE_RTREE_KEYS*/
diff --git a/storage/myisam/rt_split.c b/storage/myisam/rt_split.c
index 9f25ee608d8..0f6dc872958 100644
--- a/storage/myisam/rt_split.c
+++ b/storage/myisam/rt_split.c
@@ -264,13 +264,15 @@ int rtree_split_page(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page, uchar *key,
   uint full_length= key_length + (nod_flag ? nod_flag : 
                                   info->s->base.rec_reflength);
   int max_keys= (mi_getint(page)-2) / (full_length);
+  DBUG_ENTER("rtree_split_page");
+  DBUG_PRINT("rtree", ("splitting block"));
 
   n_dim = keyinfo->keysegs / 2;
   
   if (!(coord_buf= (double*) my_alloca(n_dim * 2 * sizeof(double) *
                                        (max_keys + 1 + 4) +
                                        sizeof(SplitStruct) * (max_keys + 1))))
-    return -1;
+    DBUG_RETURN(-1); /* purecov: inspected */
 
   task= (SplitStruct *)(coord_buf + n_dim * 2 * (max_keys + 1 + 4));
 
@@ -341,12 +343,13 @@ int rtree_split_page(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page, uchar *key,
   else
     err_code= _mi_write_keypage(info, keyinfo, *new_page_offs,
                                 DFLT_INIT_HITS, new_page);
+  DBUG_PRINT("rtree", ("split new block: %lu", (ulong) *new_page_offs));
 
   my_afree((byte*)new_page);
 
 split_err:
   my_afree((byte*) coord_buf);
-  return err_code;
+  DBUG_RETURN(err_code);
 }
 
 #endif /*HAVE_RTREE_KEYS*/
diff --git a/storage/myisammrg/ha_myisammrg.h b/storage/myisammrg/ha_myisammrg.h
index ffa55673ad1..04379f6cf70 100644
--- a/storage/myisammrg/ha_myisammrg.h
+++ b/storage/myisammrg/ha_myisammrg.h
@@ -36,8 +36,8 @@ class ha_myisammrg: public handler
   {
     return (HA_REC_NOT_IN_SEQ | HA_AUTO_PART_KEY | HA_NO_TRANSACTIONS |
 	    HA_NULL_IN_KEY | HA_CAN_INDEX_BLOBS | HA_FILE_BASED |
-            HA_CAN_INSERT_DELAYED | HA_ANY_INDEX_MAY_BE_UNIQUE |
-            HA_CAN_BIT_FIELD | HA_NO_COPY_ON_ALTER);
+            HA_ANY_INDEX_MAY_BE_UNIQUE | HA_CAN_BIT_FIELD |
+            HA_NO_COPY_ON_ALTER);
   }
   ulong index_flags(uint inx, uint part, bool all_parts) const
   {
diff --git a/storage/ndb/include/kernel/signaldata/LqhKey.hpp b/storage/ndb/include/kernel/signaldata/LqhKey.hpp
index 15ed7c25395..c85a4d4a796 100644
--- a/storage/ndb/include/kernel/signaldata/LqhKey.hpp
+++ b/storage/ndb/include/kernel/signaldata/LqhKey.hpp
@@ -582,6 +582,7 @@ class LqhKeyRef {
    * Reciver(s)
    */
   friend class Dbtc;      
+  friend class Restore;
 
   /**
    * Sender(s)
diff --git a/storage/ndb/src/kernel/blocks/ERROR_codes.txt b/storage/ndb/src/kernel/blocks/ERROR_codes.txt
index c91a2da15d1..35a3b69f337 100644
--- a/storage/ndb/src/kernel/blocks/ERROR_codes.txt
+++ b/storage/ndb/src/kernel/blocks/ERROR_codes.txt
@@ -1,8 +1,8 @@
 Next QMGR 1
-Next NDBCNTR 1000
+Next NDBCNTR 1001
 Next NDBFS 2000
 Next DBACC 3002
-Next DBTUP 4024
+Next DBTUP 4029
 Next DBLQH 5045
 Next DBDICT 6007
 Next DBDIH 7181
@@ -512,3 +512,12 @@ Dbtup:
 
 4022 - addTuxEntries - fail before add of first entry
 4023 - addTuxEntries - fail add of last entry (the entry for last index)
+
+4025: Fail all inserts with out of memory
+4026: Fail one insert with oom
+4027: Fail inserts randomly with oom
+4028: Fail one random insert with oom
+
+NDBCNTR:
+
+1000: Crash insertion on SystemError::CopyFragRef
diff --git a/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp b/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp
index ca348b23e6a..21114c6a155 100644
--- a/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp
+++ b/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp
@@ -760,7 +760,7 @@ private:
   void increaselistcont(Signal* signal);
   void seizeLeftlist(Signal* signal);
   void seizeRightlist(Signal* signal);
-  Uint32 readTablePk(Uint32 localkey1, Uint32 eh, const Operationrec*);
+  Uint32 readTablePk(Uint32 localkey1, Uint32 eh, OperationrecPtr);
   Uint32 getElement(Signal* signal, OperationrecPtr& lockOwner);
   void getdirindex(Signal* signal);
   void commitdelete(Signal* signal);
diff --git a/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp b/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp
index b90a000d55b..0ba5908ddb4 100644
--- a/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp
+++ b/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp
@@ -46,6 +46,7 @@
    ndbrequire(false); } } while(0)
 #else
 #define vlqrequire(x) ndbrequire(x)
+#define dump_lock_queue(x)
 #endif
 
 
@@ -3182,7 +3183,7 @@ void Dbacc::getdirindex(Signal* signal)
 }//Dbacc::getdirindex()
 
 Uint32
-Dbacc::readTablePk(Uint32 localkey1, Uint32 eh, const Operationrec* op)
+Dbacc::readTablePk(Uint32 localkey1, Uint32 eh, Ptr<Operationrec> opPtr)
 {
   int ret;
   Uint32 tableId = fragrecptr.p->myTableId;
@@ -3203,8 +3204,17 @@ Dbacc::readTablePk(Uint32 localkey1, Uint32 eh, const Operationrec* op)
   else
   {
     ndbrequire(ElementHeader::getLocked(eh));
-    ndbrequire((op->m_op_bits & Operationrec::OP_MASK) != ZSCAN_OP);
-    ret = c_lqh->readPrimaryKeys(op->userptr, ckeys, xfrm);
+    if (unlikely((opPtr.p->m_op_bits & Operationrec::OP_MASK) == ZSCAN_OP))
+    {
+      dump_lock_queue(opPtr);
+      ndbrequire(opPtr.p->nextParallelQue == RNIL);
+      ndbrequire(opPtr.p->nextSerialQue == RNIL);
+      ndbrequire(opPtr.p->m_op_bits & Operationrec::OP_ELEMENT_DISAPPEARED);
+      ndbrequire(opPtr.p->m_op_bits & Operationrec::OP_COMMIT_DELETE_CHECK);
+      ndbrequire((opPtr.p->m_op_bits & Operationrec::OP_STATE_MASK) == Operationrec::OP_STATE_RUNNING);
+      return 0;
+    }
+    ret = c_lqh->readPrimaryKeys(opPtr.p->userptr, ckeys, xfrm);
   }
   jamEntry();
   ndbrequire(ret >= 0);
@@ -3349,7 +3359,7 @@ Dbacc::getElement(Signal* signal, OperationrecPtr& lockOwnerPtr)
           if (! searchLocalKey) 
 	  {
             Uint32 len = readTablePk(localkey1, tgeElementHeader, 
-				     lockOwnerPtr.p);
+				     lockOwnerPtr);
             found = (len == operationRecPtr.p->xfrmtupkeylen) &&
 	      (memcmp(Tkeydata, ckeys, len << 2) == 0);
           } else {
@@ -6864,6 +6874,7 @@ void Dbacc::execACC_TO_REQ(Signal* signal)
   {
     tatrOpPtr.p->transId1 = signal->theData[2];
     tatrOpPtr.p->transId2 = signal->theData[3];
+    validate_lock_queue(tatrOpPtr);
   } else {
     jam();
     signal->theData[0] = cminusOne;
diff --git a/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp b/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
index fa982063e36..dc6581afd05 100644
--- a/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
+++ b/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
@@ -1089,7 +1089,6 @@ Dbdict::updateSchemaState(Signal* signal, Uint32 tableId,
 			  SchemaFile::TableEntry* te, Callback* callback,
                           bool savetodisk){
   jam();
-  ndbrequire(tableId < c_tableRecordPool.getSize());
   XSchemaFile * xsf = &c_schemaFile[c_schemaRecord.schemaPage != 0];
   SchemaFile::TableEntry * tableEntry = getTableEntry(xsf, tableId);
   
diff --git a/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp b/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
index b8882d72913..56d320de68c 100644
--- a/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
+++ b/storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
@@ -10570,6 +10570,15 @@ void Dblqh::copyCompletedLab(Signal* signal)
     closeCopyLab(signal);
     return;
   }//if
+
+  if (scanptr.p->scanState == ScanRecord::WAIT_LQHKEY_COPY &&
+      scanptr.p->scanErrorCounter)
+  {
+    jam();
+    closeCopyLab(signal);
+    return;
+  }
+  
   if (scanptr.p->scanState == ScanRecord::WAIT_LQHKEY_COPY) {
     jam();
 /*---------------------------------------------------------------------------*/
@@ -10658,13 +10667,16 @@ void Dblqh::continueCopyAfterBlockedLab(Signal* signal)
 void Dblqh::copyLqhKeyRefLab(Signal* signal) 
 {
   ndbrequire(tcConnectptr.p->transid[1] == signal->theData[4]);
-  tcConnectptr.p->copyCountWords -= signal->theData[3];
+  Uint32 copyWords = signal->theData[3];
   scanptr.i = tcConnectptr.p->tcScanRec;
   c_scanRecordPool.getPtr(scanptr);
   scanptr.p->scanErrorCounter++;
   tcConnectptr.p->errorCode = terrorCode;
-  closeCopyLab(signal);
-  return;
+  
+  LqhKeyConf* conf = (LqhKeyConf*)signal->getDataPtrSend();
+  conf->transId1 = copyWords;
+  conf->transId2 = tcConnectptr.p->transid[1];
+  copyCompletedLab(signal);
 }//Dblqh::copyLqhKeyRefLab()
 
 void Dblqh::closeCopyLab(Signal* signal) 
@@ -10675,6 +10687,7 @@ void Dblqh::closeCopyLab(Signal* signal)
 // Wait until all of those have arrived until we start the
 // close process.
 /*---------------------------------------------------------------------------*/
+    scanptr.p->scanState = ScanRecord::WAIT_LQHKEY_COPY;
     jam();
     return;
   }//if
diff --git a/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp b/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
index fecc4649fe9..7aef13204f2 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
@@ -32,6 +32,82 @@
 #include <../pgman.hpp>
 #include <../tsman.hpp>
 
+// jams
+#undef jam
+#undef jamEntry
+#ifdef DBTUP_BUFFER_CPP
+#define jam()	 	jamLine(10000 + __LINE__)
+#define jamEntry() 	jamEntryLine(10000 + __LINE__)
+#endif
+#ifdef DBTUP_ROUTINES_CPP
+#define jam()           jamLine(15000 + __LINE__)
+#define jamEntry()      jamEntryLine(15000 + __LINE__)
+#endif
+#ifdef DBTUP_COMMIT_CPP
+#define jam()           jamLine(20000 + __LINE__)
+#define jamEntry()      jamEntryLine(20000 + __LINE__)
+#endif
+#ifdef DBTUP_FIXALLOC_CPP
+#define jam()           jamLine(25000 + __LINE__)
+#define jamEntry()      jamEntryLine(25000 + __LINE__)
+#endif
+#ifdef DBTUP_TRIGGER_CPP
+#define jam()           jamLine(30000 + __LINE__)
+#define jamEntry()      jamEntryLine(30000 + __LINE__)
+#endif
+#ifdef DBTUP_ABORT_CPP
+#define jam()           jamLine(35000 + __LINE__)
+#define jamEntry()      jamEntryLine(35000 + __LINE__)
+#endif
+#ifdef DBTUP_PAGE_MAP_CPP
+#define jam()           jamLine(40000 + __LINE__)
+#define jamEntry()      jamEntryLine(40000 + __LINE__)
+#endif
+#ifdef DBTUP_PAG_MAN_CPP
+#define jam()           jamLine(45000 + __LINE__)
+#define jamEntry()      jamEntryLine(45000 + __LINE__)
+#endif
+#ifdef DBTUP_STORE_PROC_DEF_CPP
+#define jam()           jamLine(50000 + __LINE__)
+#define jamEntry()      jamEntryLine(50000 + __LINE__)
+#endif
+#ifdef DBTUP_META_CPP
+#define jam()           jamLine(55000 + __LINE__)
+#define jamEntry()      jamEntryLine(55000 + __LINE__)
+#endif
+#ifdef DBTUP_TAB_DES_MAN_CPP
+#define jam()           jamLine(60000 + __LINE__)
+#define jamEntry()      jamEntryLine(60000 + __LINE__)
+#endif
+#ifdef DBTUP_GEN_CPP
+#define jam()           jamLine(65000 + __LINE__)
+#define jamEntry()      jamEntryLine(65000 + __LINE__)
+#endif
+#ifdef DBTUP_INDEX_CPP
+#define jam()           jamLine(70000 + __LINE__)
+#define jamEntry()      jamEntryLine(70000 + __LINE__)
+#endif
+#ifdef DBTUP_DEBUG_CPP
+#define jam()           jamLine(75000 + __LINE__)
+#define jamEntry()      jamEntryLine(75000 + __LINE__)
+#endif
+#ifdef DBTUP_VAR_ALLOC_CPP
+#define jam()           jamLine(80000 + __LINE__)
+#define jamEntry()      jamEntryLine(80000 + __LINE__)
+#endif
+#ifdef DBTUP_SCAN_CPP
+#define jam()           jamLine(85000 + __LINE__)
+#define jamEntry()      jamEntryLine(85000 + __LINE__)
+#endif
+#ifdef DBTUP_DISK_ALLOC_CPP
+#define jam()           jamLine(90000 + __LINE__)
+#define jamEntry()      jamEntryLine(90000 + __LINE__)
+#endif
+#ifndef jam
+#define jam()           jamLine(__LINE__)
+#define jamEntry()      jamEntryLine(__LINE__)
+#endif
+
 #ifdef VM_TRACE
 inline const char* dbgmask(const Bitmask<MAXNROFATTRIBUTESINWORDS>& bm) {
   static int i=0; static char buf[5][200];
@@ -70,22 +146,23 @@ inline const Uint32* ALIGN_WORD(const void* ptr)
 // only reports the line number in the file it currently is located in.
 // 
 // DbtupExecQuery.cpp         0
-// DbtupBuffer.cpp         2000
-// DbtupRoutines.cpp       3000
-// DbtupCommit.cpp         5000
-// DbtupFixAlloc.cpp       6000
-// DbtupTrigger.cpp        7000
-// DbtupAbort.cpp          9000
-// DbtupPageMap.cpp       14000
-// DbtupPagMan.cpp        16000
-// DbtupStoredProcDef.cpp 18000
-// DbtupMeta.cpp          20000
-// DbtupTabDesMan.cpp     22000
-// DbtupGen.cpp           24000
-// DbtupIndex.cpp         28000
-// DbtupDebug.cpp         30000
-// DbtupVarAlloc.cpp      32000
-// DbtupScan.cpp          33000
+// DbtupBuffer.cpp         10000
+// DbtupRoutines.cpp       15000
+// DbtupCommit.cpp         20000
+// DbtupFixAlloc.cpp       25000
+// DbtupTrigger.cpp        30000
+// DbtupAbort.cpp          35000
+// DbtupPageMap.cpp        40000
+// DbtupPagMan.cpp         45000
+// DbtupStoredProcDef.cpp  50000
+// DbtupMeta.cpp           55000
+// DbtupTabDesMan.cpp      60000
+// DbtupGen.cpp            65000
+// DbtupIndex.cpp          70000
+// DbtupDebug.cpp          75000
+// DbtupVarAlloc.cpp       80000
+// DbtupScan.cpp           85000
+// DbtupDiskAlloc.cpp      90000
 //------------------------------------------------------------------
 
 /*
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp
index 2414e8a10bf..b3ecbc4f435 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp
@@ -14,21 +14,19 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_ABORT_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 
-#define ljam() { jamLine(9000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(9000 + __LINE__); }
-
 void Dbtup::freeAllAttrBuffers(Operationrec*  const regOperPtr)
 {
   if (regOperPtr->storedProcedureId == RNIL) {
-    ljam();
+    jam();
     freeAttrinbufrec(regOperPtr->firstAttrinbufrec);
   } else {
-    ljam();
+    jam();
     StoredProcPtr storedPtr;
     c_storedProcPool.getPtr(storedPtr, (Uint32)regOperPtr->storedProcedureId);
     ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE);
@@ -46,7 +44,7 @@ void Dbtup::freeAttrinbufrec(Uint32 anAttrBuf)
   Uint32 RnoFree = cnoFreeAttrbufrec;
   localAttrBufPtr.i = anAttrBuf;
   while (localAttrBufPtr.i != RNIL) {
-    ljam();
+    jam();
     ptrCheckGuard(localAttrBufPtr, cnoOfAttrbufrec, attrbufrec);
     Ttemp = localAttrBufPtr.p->attrbuf[ZBUF_NEXT];
     localAttrBufPtr.p->attrbuf[ZBUF_NEXT] = cfirstfreeAttrbufrec;
@@ -62,7 +60,7 @@ void Dbtup::freeAttrinbufrec(Uint32 anAttrBuf)
  */
 void Dbtup::execTUP_ABORTREQ(Signal* signal) 
 {
-  ljamEntry();
+  jamEntry();
   do_tup_abortreq(signal, 0);
 }
 
@@ -80,7 +78,7 @@ void Dbtup::do_tup_abortreq(Signal* signal, Uint32 flags)
              (trans_state == TRANS_ERROR_WAIT_TUPKEYREQ) ||
              (trans_state == TRANS_IDLE));
   if (regOperPtr.p->op_struct.op_type == ZREAD) {
-    ljam();
+    jam();
     freeAllAttrBuffers(regOperPtr.p);
     initOpConnection(regOperPtr.p);
     return;
@@ -94,7 +92,7 @@ void Dbtup::do_tup_abortreq(Signal* signal, Uint32 flags)
 
   if (get_tuple_state(regOperPtr.p) == TUPLE_PREPARED)
   {
-    ljam();
+    jam();
     if (!regTabPtr.p->tuxCustomTriggers.isEmpty() &&
         (flags & ZSKIP_TUX_TRIGGERS) == 0)
       executeTuxAbortTriggers(signal,
@@ -105,12 +103,12 @@ void Dbtup::do_tup_abortreq(Signal* signal, Uint32 flags)
     OperationrecPtr loopOpPtr;
     loopOpPtr.i = regOperPtr.p->nextActiveOp;
     while (loopOpPtr.i != RNIL) {
-      ljam();
+      jam();
       c_operation_pool.getPtr(loopOpPtr);
       if (get_tuple_state(loopOpPtr.p) != TUPLE_ALREADY_ABORTED &&
 	  !regTabPtr.p->tuxCustomTriggers.isEmpty() &&
           (flags & ZSKIP_TUX_TRIGGERS) == 0) {
-        ljam();
+        jam();
         executeTuxAbortTriggers(signal,
                                 loopOpPtr.p,
                                 regFragPtr.p,
@@ -211,116 +209,116 @@ int Dbtup::TUPKEY_abort(Signal* signal, int error_type)
   case 1:
 //tmupdate_alloc_error:
     terrorCode= ZMEM_NOMEM_ERROR;
-    ljam();
+    jam();
     break;
 
   case 15:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 16:
-    ljam();
+    jam();
     terrorCode = ZTRY_TO_UPDATE_ERROR;
     break;
 
   case 17:
-    ljam();
+    jam();
     terrorCode = ZNO_ILLEGAL_NULL_ATTR;
     break;
 
   case 19:
-    ljam();
+    jam();
     terrorCode = ZTRY_TO_UPDATE_ERROR;
     break;
 
   case 20:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 22:
-    ljam();
+    jam();
     terrorCode = ZTOTAL_LEN_ERROR;
     break;
 
   case 23:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 24:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 26:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 27:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 28:
-    ljam();
+    jam();
     terrorCode = ZREGISTER_INIT_ERROR;
     break;
 
   case 29:
-    ljam();
+    jam();
     break;
 
   case 30:
-    ljam();
+    jam();
     terrorCode = ZCALL_ERROR;
     break;
 
   case 31:
-    ljam();
+    jam();
     terrorCode = ZSTACK_OVERFLOW_ERROR;
     break;
 
   case 32:
-    ljam();
+    jam();
     terrorCode = ZSTACK_UNDERFLOW_ERROR;
     break;
 
   case 33:
-    ljam();
+    jam();
     terrorCode = ZNO_INSTRUCTION_ERROR;
     break;
 
   case 34:
-    ljam();
+    jam();
     terrorCode = ZOUTSIDE_OF_PROGRAM_ERROR;
     break;
 
   case 35:
-    ljam();
+    jam();
     terrorCode = ZTOO_MANY_INSTRUCTIONS_ERROR;
     break;
 
   case 38:
-    ljam();
+    jam();
     terrorCode = ZTEMPORARY_RESOURCE_FAILURE;
     break;
 
   case 39:
     if (get_trans_state(operPtr.p) == TRANS_TOO_MUCH_AI) {
-      ljam();
+      jam();
       terrorCode = ZTOO_MUCH_ATTRINFO_ERROR;
     } else if (get_trans_state(operPtr.p) == TRANS_ERROR_WAIT_TUPKEYREQ) {
-      ljam();
+      jam();
       terrorCode = ZSEIZE_ATTRINBUFREC_ERROR;
     } else {
       ndbrequire(false);
     }//if
     break;
   case 40:
-    ljam();
+    jam();
     terrorCode = ZUNSUPPORTED_BRANCH;
     break;
   default:
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
index 60c0c22ae6c..adac4d3d460 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp
@@ -14,28 +14,26 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_BUFFER_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 #include <signaldata/TransIdAI.hpp>
 
-#define ljam() { jamLine(2000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(2000 + __LINE__); }
-
 void Dbtup::execSEND_PACKED(Signal* signal)
 {
   Uint16 hostId;
   Uint32 i;
   Uint32 TpackedListIndex= cpackedListIndex;
-  ljamEntry();
+  jamEntry();
   for (i= 0; i < TpackedListIndex; i++) {
-    ljam();
+    jam();
     hostId= cpackedList[i];
     ndbrequire((hostId - 1) < (MAX_NODES - 1)); // Also check not zero
     Uint32 TpacketTA= hostBuffer[hostId].noOfPacketsTA;
     if (TpacketTA != 0) {
-      ljam();
+      jam();
       BlockReference TBref= numberToRef(API_PACKED, hostId);
       Uint32 TpacketLen= hostBuffer[hostId].packetLenTA;
       MEMCOPY_NO_WORDS(&signal->theData[0],
@@ -73,7 +71,7 @@ void Dbtup::bufferTRANSID_AI(Signal* signal, BlockReference aRef,
 // There is still space in the buffer. We will copy it into the
 // buffer.
 // ----------------------------------------------------------------
-    ljam();
+    jam();
     updatePackedList(signal, hostId);
   } else if (false && TnoOfPackets == 1) {
 // ----------------------------------------------------------------
@@ -118,7 +116,7 @@ void Dbtup::updatePackedList(Signal* signal, Uint16 hostId)
 {
   if (hostBuffer[hostId].inPackedList == false) {
     Uint32 TpackedListIndex= cpackedListIndex;
-    ljam();
+    jam();
     hostBuffer[hostId].inPackedList= true;
     cpackedList[TpackedListIndex]= hostId;
     cpackedListIndex= TpackedListIndex + 1;
@@ -149,7 +147,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
 
   if (ERROR_INSERTED(4006) && (nodeId != getOwnNodeId())){
     // Use error insert to turn routing on
-    ljam();
+    jam();
     connectedToNode= false;    
   }
 
@@ -167,18 +165,18 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
      * Own node -> execute direct
      */
     if(nodeId != getOwnNodeId()){
-      ljam();
+      jam();
     
       /**
        * Send long sig
        */
       if (ToutBufIndex >= 22 && is_api && !old_dest) {
-	ljam();
+	jam();
 	/**
 	 * Flush buffer so that order is maintained
 	 */
 	if (TpacketTA != 0) {
-	  ljam();
+	  jam();
 	  BlockReference TBref = numberToRef(API_PACKED, nodeId);
 	  MEMCOPY_NO_WORDS(&signal->theData[0],
 			   &hostBuffer[nodeId].packetBufferTA[0],
@@ -202,7 +200,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
        */
 #ifndef NDB_NO_DROPPED_SIGNAL
       if (ToutBufIndex < 22 && is_api){
-	ljam();
+	jam();
 	bufferTRANSID_AI(signal, recBlockref, 3+ToutBufIndex);
 	return;
       }
@@ -214,7 +212,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
       Uint32 * src= signal->theData+25;
       if (ToutBufIndex >= 22){
 	do {
-	  ljam();
+	  jam();
 	  MEMCOPY_NO_WORDS(&signal->theData[3], src, 22);
 	  sendSignal(recBlockref, GSN_TRANSID_AI, signal, 25, JBB);
 	  ToutBufIndex -= 22;
@@ -223,14 +221,14 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
       }
       
       if (ToutBufIndex > 0){
-	ljam();
+	jam();
 	MEMCOPY_NO_WORDS(&signal->theData[3], src, ToutBufIndex);
 	sendSignal(recBlockref, GSN_TRANSID_AI, signal, 3+ToutBufIndex, JBB);
       }
       return;
     }
     EXECUTE_DIRECT(block, GSN_TRANSID_AI, signal, 3 + ToutBufIndex);
-    ljamEntry();
+    jamEntry();
     return;
   }
 
@@ -242,7 +240,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
   Uint32 routeBlockref= req_struct->TC_ref;
   
   if (true){ // TODO is_api && !old_dest){
-    ljam();
+    jam();
     transIdAI->attrData[0]= recBlockref;
     LinearSectionPtr ptr[3];
     ptr[0].p= &signal->theData[25];
@@ -260,7 +258,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal,
   Uint32 sent= 0;
   Uint32 maxLen= TransIdAI::DataLength - 1;
   while (sent < tot) {
-    ljam();      
+    jam();      
     Uint32 dataLen= (tot - sent > maxLen) ? maxLen : tot - sent;
     Uint32 sigLen= dataLen + TransIdAI::HeaderLength + 1; 
     MEMCOPY_NO_WORDS(&transIdAI->attrData,
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp
index 91d2ca97744..880c956185f 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp
@@ -14,6 +14,7 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_COMMIT_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -21,16 +22,13 @@
 #include <signaldata/TupCommit.hpp>
 #include "../dblqh/Dblqh.hpp"
 
-#define ljam() { jamLine(5000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(5000 + __LINE__); }
-
 void Dbtup::execTUP_DEALLOCREQ(Signal* signal)
 {
   TablerecPtr regTabPtr;
   FragrecordPtr regFragPtr;
   Uint32 frag_page_id, frag_id;
 
-  ljamEntry();
+  jamEntry();
 
   frag_id= signal->theData[0];
   regTabPtr.i= signal->theData[1];
@@ -62,7 +60,7 @@ void Dbtup::execTUP_DEALLOCREQ(Signal* signal)
     
     if (regTabPtr.p->m_attributes[MM].m_no_of_varsize)
     {
-      ljam();
+      jam();
       free_var_rec(regFragPtr.p, regTabPtr.p, &tmp, pagePtr);
     } else {
       free_fix_rec(regFragPtr.p, regTabPtr.p, &tmp, (Fix_page*)pagePtr.p);
@@ -78,7 +76,7 @@ void Dbtup::execTUP_WRITELOG_REQ(Signal* signal)
   Uint32 gci= signal->theData[1];
   c_operation_pool.getPtr(loopOpPtr);
   while (loopOpPtr.p->prevActiveOp != RNIL) {
-    ljam();
+    jam();
     loopOpPtr.i= loopOpPtr.p->prevActiveOp;
     c_operation_pool.getPtr(loopOpPtr);
   }
@@ -87,11 +85,11 @@ void Dbtup::execTUP_WRITELOG_REQ(Signal* signal)
     signal->theData[0]= loopOpPtr.p->userpointer;
     signal->theData[1]= gci;
     if (loopOpPtr.p->nextActiveOp == RNIL) {
-      ljam();
+      jam();
       EXECUTE_DIRECT(DBLQH, GSN_LQH_WRITELOG_REQ, signal, 2);
       return;
     }
-    ljam();
+    jam();
     EXECUTE_DIRECT(DBLQH, GSN_LQH_WRITELOG_REQ, signal, 2);
     jamEntry();
     loopOpPtr.i= loopOpPtr.p->nextActiveOp;
@@ -114,16 +112,16 @@ void Dbtup::removeActiveOpList(Operationrec*  const regOperPtr,
   if (regOperPtr->op_struct.in_active_list) {
     regOperPtr->op_struct.in_active_list= false;
     if (regOperPtr->nextActiveOp != RNIL) {
-      ljam();
+      jam();
       raoOperPtr.i= regOperPtr->nextActiveOp;
       c_operation_pool.getPtr(raoOperPtr);
       raoOperPtr.p->prevActiveOp= regOperPtr->prevActiveOp;
     } else {
-      ljam();
+      jam();
       tuple_ptr->m_operation_ptr_i = regOperPtr->prevActiveOp;
     }
     if (regOperPtr->prevActiveOp != RNIL) {
-      ljam();
+      jam();
       raoOperPtr.i= regOperPtr->prevActiveOp;
       c_operation_pool.getPtr(raoOperPtr);
       raoOperPtr.p->nextActiveOp= regOperPtr->nextActiveOp;
@@ -343,7 +341,7 @@ Dbtup::disk_page_commit_callback(Signal* signal,
   Uint32 gci;
   OperationrecPtr regOperPtr;
 
-  ljamEntry();
+  jamEntry();
   
   c_operation_pool.getPtr(regOperPtr, opPtrI);
   c_lqh->get_op_info(regOperPtr.p->userpointer, &hash_value, &gci);
@@ -379,7 +377,7 @@ Dbtup::disk_page_log_buffer_callback(Signal* signal,
   Uint32 gci;
   OperationrecPtr regOperPtr;
 
-  ljamEntry();
+  jamEntry();
   
   c_operation_pool.getPtr(regOperPtr, opPtrI);
   c_lqh->get_op_info(regOperPtr.p->userpointer, &hash_value, &gci);
@@ -447,7 +445,7 @@ void Dbtup::execTUP_COMMITREQ(Signal* signal)
   TupCommitReq * const tupCommitReq= (TupCommitReq *)signal->getDataPtr();
 
   regOperPtr.i= tupCommitReq->opPtr;
-  ljamEntry();
+  jamEntry();
 
   c_operation_pool.getPtr(regOperPtr);
   if(!regOperPtr.p->is_first_operation())
@@ -603,7 +601,7 @@ skip_disk:
      *   why can't we instead remove "own version" (when approriate ofcourse)
      */
     if (!regTabPtr.p->tuxCustomTriggers.isEmpty()) {
-      ljam();
+      jam();
       OperationrecPtr loopPtr= regOperPtr;
       while(loopPtr.i != RNIL)
       {
@@ -656,18 +654,18 @@ Dbtup::set_change_mask_info(KeyReqStruct * const req_struct,
 {
   ChangeMaskState state = get_change_mask_state(regOperPtr);
   if (state == USE_SAVED_CHANGE_MASK) {
-    ljam();
+    jam();
     req_struct->changeMask.setWord(0, regOperPtr->saved_change_mask[0]);
     req_struct->changeMask.setWord(1, regOperPtr->saved_change_mask[1]);
   } else if (state == RECALCULATE_CHANGE_MASK) {
-    ljam();
+    jam();
     // Recompute change mask, for now set all bits
     req_struct->changeMask.set();
   } else if (state == SET_ALL_MASK) {
-    ljam();
+    jam();
     req_struct->changeMask.set();
   } else {
-    ljam();
+    jam();
     ndbrequire(state == DELETE_CHANGES);
     req_struct->changeMask.set();
   }
@@ -687,17 +685,17 @@ Dbtup::calculateChangeMask(Page* const pagePtr,
     ndbrequire(loopOpPtr.p->op_struct.op_type == ZUPDATE);
     ChangeMaskState change_mask= get_change_mask_state(loopOpPtr.p);
     if (change_mask == USE_SAVED_CHANGE_MASK) {
-      ljam();
+      jam();
       saved_word1|= loopOpPtr.p->saved_change_mask[0];
       saved_word2|= loopOpPtr.p->saved_change_mask[1];
     } else if (change_mask == RECALCULATE_CHANGE_MASK) {
-      ljam();
+      jam();
       //Recompute change mask, for now set all bits
       req_struct->changeMask.set();
       return;
     } else {
       ndbrequire(change_mask == SET_ALL_MASK);
-      ljam();
+      jam();
       req_struct->changeMask.set();
       return;
     }
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp
index ccb0bdcb537..708b4e0e8d7 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp
@@ -15,6 +15,7 @@
 
 
 #define DBTUP_C
+#define DBTUP_DEBUG_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -24,9 +25,6 @@
 #include <signaldata/EventReport.hpp>
 #include <Vector.hpp>
 
-#define ljam() { jamLine(30000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(30000 + __LINE__); }
-
 /* **************************************************************** */
 /* ---------------------------------------------------------------- */
 /* ------------------------ DEBUG MODULE -------------------------- */
@@ -35,7 +33,7 @@
 void Dbtup::execDEBUG_SIG(Signal* signal) 
 {
   PagePtr regPagePtr;
-  ljamEntry();
+  jamEntry();
   regPagePtr.i = signal->theData[0];
   c_page_pool.getPtr(regPagePtr);
 }//Dbtup::execDEBUG_SIG()
@@ -248,18 +246,18 @@ void Dbtup::execMEMCHECKREQ(Signal* signal)
   PagePtr regPagePtr;
   Uint32* data = &signal->theData[0];
 
-  ljamEntry();
+  jamEntry();
   BlockReference blockref = signal->theData[0];
   Uint32 i;
   for (i = 0; i < 25; i++) {
-    ljam();
+    jam();
     data[i] = 0;
   }//for
   for (i = 0; i < 16; i++) {
     regPagePtr.i = cfreepageList[i];
-    ljam();
+    jam();
     while (regPagePtr.i != RNIL) {
-      ljam();
+      jam();
       ptrCheckGuard(regPagePtr, cnoOfPage, cpage);
       regPagePtr.i = regPagePtr.p->next_page;
       data[0]++;
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp
index f865904b413..1c3986afbbd 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp
@@ -14,6 +14,7 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_DISK_ALLOC_CPP
 #include "Dbtup.hpp"
 
 static bool f_undo_done = true;
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp
index fe0f570f484..cdaca3b8192 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp
@@ -1259,6 +1259,28 @@ int Dbtup::handleInsertReq(Signal* signal,
   {  
     shrink_tuple(req_struct, sizes+2, regTabPtr, true);
   }
+
+  if (ERROR_INSERTED(4025))
+  {
+    goto mem_error;
+  }
+
+  if (ERROR_INSERTED(4026))
+  {
+    CLEAR_ERROR_INSERT_VALUE;
+    goto mem_error;
+  }
+
+  if (ERROR_INSERTED(4027) && (rand() % 100) > 25)
+  {
+    goto mem_error;
+  }
+ 
+  if (ERROR_INSERTED(4028) && (rand() % 100) > 25)
+  {
+    CLEAR_ERROR_INSERT_VALUE;
+    goto mem_error;
+  }
   
   /**
    * Alloc memory
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp
index 50500b96134..31903ea8c33 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp
@@ -14,14 +14,12 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_FIXALLOC_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 
-#define ljam() { jamLine(6000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(6000 + __LINE__); }
-
 //
 // Fixed Allocator
 // This module is used to allocate and free fixed size tuples from the
@@ -79,7 +77,7 @@ Dbtup::alloc_fix_rec(Fragrecord* const regFragPtr,
 /* ---------------------------------------------------------------- */
     pagePtr.i = getEmptyPage(regFragPtr);
     if (pagePtr.i != RNIL) {
-      ljam();
+      jam();
 /* ---------------------------------------------------------------- */
 // We found empty pages on the fragment. Allocate an empty page and
 // convert it into a tuple header page and put it in thFreeFirst-list.
@@ -95,14 +93,14 @@ Dbtup::alloc_fix_rec(Fragrecord* const regFragPtr,
       LocalDLList<Page> free_pages(c_page_pool, regFragPtr->thFreeFirst);    
       free_pages.add(pagePtr);
     } else {
-      ljam();
+      jam();
 /* ---------------------------------------------------------------- */
 /*       THERE ARE NO EMPTY PAGES. MEMORY CAN NOT BE ALLOCATED.     */
 /* ---------------------------------------------------------------- */
       return 0;
     }
   } else {
-    ljam();
+    jam();
 /* ---------------------------------------------------------------- */
 /*       THIS SHOULD BE THE COMMON PATH THROUGH THE CODE, FREE      */
 /*       COPY PAGE EXISTED.                                         */
@@ -193,7 +191,7 @@ void Dbtup::free_fix_rec(Fragrecord* regFragPtr,
   
   if(free == 1)
   {
-    ljam();
+    jam();
     PagePtr pagePtr = { (Page*)regPagePtr, key->m_page_no };
     LocalDLList<Page> free_pages(c_page_pool, regFragPtr->thFreeFirst);    
     ndbrequire(regPagePtr->page_state == ZTH_MM_FULL);
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
index 67fc5a4ceb0..85a7ec2d431 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
@@ -15,6 +15,7 @@
 
 
 #define DBTUP_C
+#define DBTUP_GEN_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -34,9 +35,6 @@
 
 #define DEBUG(x) { ndbout << "TUP::" << x << endl; }
 
-#define ljam() { jamLine(24000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(24000 + __LINE__); }
-
 void Dbtup::initData() 
 {
   cnoOfAttrbufrec = ZNO_OF_ATTRBUFREC;
@@ -112,6 +110,7 @@ Dbtup::Dbtup(Block_context& ctx, Pgman* pgman)
   cnoOfAllocatedPages = 0;
   
   initData();
+  CLEAR_ERROR_INSERT_VALUE;
 }//Dbtup::Dbtup()
 
 Dbtup::~Dbtup() 
@@ -151,21 +150,21 @@ BLOCK_FUNCTIONS(Dbtup)
 
 void Dbtup::execCONTINUEB(Signal* signal) 
 {
-  ljamEntry();
+  jamEntry();
   Uint32 actionType = signal->theData[0];
   Uint32 dataPtr = signal->theData[1];
   switch (actionType) {
   case ZINITIALISE_RECORDS:
-    ljam();
+    jam();
     initialiseRecordsLab(signal, dataPtr, 
 			 signal->theData[2], signal->theData[3]);
     break;
   case ZREL_FRAG:
-    ljam();
+    jam();
     releaseFragment(signal, dataPtr, signal->theData[2]);
     break;
   case ZREPORT_MEMORY_USAGE:{
-    ljam();
+    jam();
     static int c_currentMemUsed = 0;
     Uint32 cnt = signal->theData[1];
     Uint32 tmp = c_page_pool.getSize();
@@ -200,11 +199,11 @@ void Dbtup::execCONTINUEB(Signal* signal)
     return;
   }
   case ZBUILD_INDEX:
-    ljam();
+    jam();
     buildIndex(signal, dataPtr);
     break;
   case ZTUP_SCAN:
-    ljam();
+    jam();
     {
       ScanOpPtr scanPtr;
       c_scanOpPool.getPtr(scanPtr, dataPtr);
@@ -213,7 +212,7 @@ void Dbtup::execCONTINUEB(Signal* signal)
     return;
   case ZFREE_EXTENT:
   {
-    ljam();
+    jam();
     
     TablerecPtr tabPtr;
     tabPtr.i= dataPtr;
@@ -226,7 +225,7 @@ void Dbtup::execCONTINUEB(Signal* signal)
   }
   case ZUNMAP_PAGES:
   {
-    ljam();
+    jam();
     
     TablerecPtr tabPtr;
     tabPtr.i= dataPtr;
@@ -239,7 +238,7 @@ void Dbtup::execCONTINUEB(Signal* signal)
   }
   case ZFREE_VAR_PAGES:
   {
-    ljam();
+    jam();
     drop_fragment_free_var_pages(signal);
     return;
   }
@@ -256,20 +255,19 @@ void Dbtup::execCONTINUEB(Signal* signal)
 /* **************************************************************** */
 void Dbtup::execSTTOR(Signal* signal) 
 {
-  ljamEntry();
+  jamEntry();
   Uint32 startPhase = signal->theData[1];
   Uint32 sigKey = signal->theData[6];
   switch (startPhase) {
   case ZSTARTPHASE1:
-    ljam();
-    CLEAR_ERROR_INSERT_VALUE;
+    jam();
     ndbrequire((c_lqh= (Dblqh*)globalData.getBlock(DBLQH)) != 0);
     ndbrequire((c_tsman= (Tsman*)globalData.getBlock(TSMAN)) != 0);
     ndbrequire((c_lgman= (Lgman*)globalData.getBlock(LGMAN)) != 0);
     cownref = calcTupBlockRef(0);
     break;
   default:
-    ljam();
+    jam();
     break;
   }//switch
   signal->theData[0] = sigKey;
@@ -292,7 +290,7 @@ void Dbtup::execREAD_CONFIG_REQ(Signal* signal)
   Uint32 senderData = req->senderData;
   ndbrequire(req->noOfParameters == 0);
   
-  ljamEntry();
+  jamEntry();
 
   const ndb_mgm_configuration_iterator * p = 
     m_ctx.m_config.getOwnConfigIterator();
@@ -412,58 +410,58 @@ void Dbtup::initialiseRecordsLab(Signal* signal, Uint32 switchData,
 {
   switch (switchData) {
   case 0:
-    ljam();
+    jam();
     initializeHostBuffer();
     break;
   case 1:
-    ljam();
+    jam();
     initializeOperationrec();
     break;
   case 2:
-    ljam();
+    jam();
     initializePage();
     break;
   case 3:
-    ljam();
+    jam();
     break;
   case 4:
-    ljam();
+    jam();
     initializeTablerec();
     break;
   case 5:
-    ljam();
+    jam();
     break;
   case 6:
-    ljam();
+    jam();
     initializeFragrecord();
     break;
   case 7:
-    ljam();
+    jam();
     initializeFragoperrec();
     break;
   case 8:
-    ljam();
+    jam();
     initializePageRange();
     break;
   case 9:
-    ljam();
+    jam();
     initializeTabDescr();
     break;
   case 10:
-    ljam();
+    jam();
     break;
   case 11:
-    ljam();
+    jam();
     break;
   case 12:
-    ljam();
+    jam();
     initializeAttrbufrec();
     break;
   case 13:
-    ljam();
+    jam();
     break;
   case 14:
-    ljam();
+    jam();
 
     {
       ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
@@ -487,28 +485,28 @@ void Dbtup::initialiseRecordsLab(Signal* signal, Uint32 switchData,
 
 void Dbtup::execNDB_STTOR(Signal* signal) 
 {
-  ljamEntry();
+  jamEntry();
   cndbcntrRef = signal->theData[0];
   Uint32 ownNodeId = signal->theData[1];
   Uint32 startPhase = signal->theData[2];
   switch (startPhase) {
   case ZSTARTPHASE1:
-    ljam();
+    jam();
     cownNodeId = ownNodeId;
     cownref = calcTupBlockRef(ownNodeId);
     break;
   case ZSTARTPHASE2:
-    ljam();
+    jam();
     break;
   case ZSTARTPHASE3:
-    ljam();
+    jam();
     startphase3Lab(signal, ~0, ~0);
     break;
   case ZSTARTPHASE4:
-    ljam();
+    jam();
     break;
   case ZSTARTPHASE6:
-    ljam();
+    jam();
 /*****************************************/
 /*       NOW SET THE DISK WRITE SPEED TO */
 /*       PAGES PER TICK AFTER SYSTEM     */
@@ -519,7 +517,7 @@ void Dbtup::execNDB_STTOR(Signal* signal)
     sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1000, 1);    
     break;
   default:
-    ljam();
+    jam();
     break;
   }//switch
   signal->theData[0] = cownref;
@@ -596,7 +594,7 @@ void Dbtup::initializeTablerec()
 {
   TablerecPtr regTabPtr;
   for (regTabPtr.i = 0; regTabPtr.i < cnoOfTablerec; regTabPtr.i++) {
-    ljam();
+    jam();
     refresh_watch_dog();
     ptrAss(regTabPtr, tablerec);
     initTab(regTabPtr.p);
@@ -667,12 +665,12 @@ void Dbtup::initializeTabDescr()
 void Dbtup::execTUPSEIZEREQ(Signal* signal)
 {
   OperationrecPtr regOperPtr;
-  ljamEntry();
+  jamEntry();
   Uint32 userPtr = signal->theData[0];
   BlockReference userRef = signal->theData[1];
   if (!c_operation_pool.seize(regOperPtr))
   {
-    ljam();
+    jam();
     signal->theData[0] = userPtr;
     signal->theData[1] = ZGET_OPREC_ERROR;
     sendSignal(userRef, GSN_TUPSEIZEREF, signal, 2, JBB);
@@ -706,7 +704,7 @@ void Dbtup::execTUPSEIZEREQ(Signal* signal)
 void Dbtup::execTUPRELEASEREQ(Signal* signal) 
 {
   OperationrecPtr regOperPtr;
-  ljamEntry();
+  jamEntry();
   regOperPtr.i = signal->theData[0];
   c_operation_pool.getPtr(regOperPtr);
   set_trans_state(regOperPtr.p, TRANS_DISCONNECTED);
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
index 3f42f0151e6..e4a26f8ccd0 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
@@ -14,6 +14,7 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_INDEX_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -23,9 +24,6 @@
 #include <AttributeHeader.hpp>
 #include <signaldata/TuxMaint.hpp>
 
-#define ljam() { jamLine(28000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(28000 + __LINE__); }
-
 // methods used by ordered index
 
 void
@@ -34,7 +32,7 @@ Dbtup::tuxGetTupAddr(Uint32 fragPtrI,
                      Uint32 pageIndex,
                      Uint32& tupAddr)
 {
-  ljamEntry();
+  jamEntry();
   PagePtr pagePtr;
   c_page_pool.getPtr(pagePtr, pageId);
   Uint32 fragPageId= pagePtr.p->frag_page_id;
@@ -48,7 +46,7 @@ Dbtup::tuxAllocNode(Signal* signal,
                     Uint32& pageOffset,
                     Uint32*& node)
 {
-  ljamEntry();
+  jamEntry();
   FragrecordPtr fragPtr;
   fragPtr.i= fragPtrI;
   ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
@@ -61,7 +59,7 @@ Dbtup::tuxAllocNode(Signal* signal,
   Uint32* ptr, frag_page_id;
   if ((ptr= alloc_fix_rec(fragPtr.p, tablePtr.p, &key, &frag_page_id)) == 0)
   {
-    ljam();
+    jam();
     terrorCode = ZMEM_NOMEM_ERROR; // caller sets error
     return terrorCode;
   }
@@ -82,7 +80,7 @@ Dbtup::tuxFreeNode(Signal* signal,
                    Uint32 pageOffset,
                    Uint32* node)
 {
-  ljamEntry();
+  jamEntry();
   FragrecordPtr fragPtr;
   fragPtr.i= fragPtrI;
   ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
@@ -105,7 +103,7 @@ Dbtup::tuxGetNode(Uint32 fragPtrI,
                   Uint32 pageOffset,
                   Uint32*& node)
 {
-  ljamEntry();
+  jamEntry();
   FragrecordPtr fragPtr;
   fragPtr.i= fragPtrI;
   ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
@@ -130,7 +128,7 @@ Dbtup::tuxReadAttrs(Uint32 fragPtrI,
                     Uint32 numAttrs,
                     Uint32* dataOut)
 {
-  ljamEntry();
+  jamEntry();
   // use own variables instead of globals
   FragrecordPtr fragPtr;
   fragPtr.i= fragPtrI;
@@ -150,21 +148,21 @@ Dbtup::tuxReadAttrs(Uint32 fragPtrI,
   Tuple_header *tuple_ptr= req_struct.m_tuple_ptr;
   if (tuple_ptr->get_tuple_version() != tupVersion)
   {
-    ljam();
+    jam();
     OperationrecPtr opPtr;
     opPtr.i= tuple_ptr->m_operation_ptr_i;
     Uint32 loopGuard= 0;
     while (opPtr.i != RNIL) {
       c_operation_pool.getPtr(opPtr);
       if (opPtr.p->tupVersion == tupVersion) {
-	ljam();
+	jam();
 	if (!opPtr.p->m_copy_tuple_location.isNull()) {
 	  req_struct.m_tuple_ptr= (Tuple_header*)
 	    c_undo_buffer.get_ptr(&opPtr.p->m_copy_tuple_location);
         }
 	break;
       }
-      ljam();
+      jam();
       opPtr.i= opPtr.p->prevActiveOp;
       ndbrequire(++loopGuard < (1 << ZTUP_VERSION_BITS));
     }
@@ -202,7 +200,7 @@ Dbtup::tuxReadAttrs(Uint32 fragPtrI,
 int
 Dbtup::tuxReadPk(Uint32 fragPtrI, Uint32 pageId, Uint32 pageIndex, Uint32* dataOut, bool xfrmFlag)
 {
-  ljamEntry();
+  jamEntry();
   // use own variables instead of globals
   FragrecordPtr fragPtr;
   fragPtr.i= fragPtrI;
@@ -305,7 +303,7 @@ Dbtup::tuxReadPk(Uint32 fragPtrI, Uint32 pageId, Uint32 pageIndex, Uint32* dataO
 int
 Dbtup::accReadPk(Uint32 tableId, Uint32 fragId, Uint32 fragPageId, Uint32 pageIndex, Uint32* dataOut, bool xfrmFlag)
 {
-  ljamEntry();
+  jamEntry();
   // get table
   TablerecPtr tablePtr;
   tablePtr.i = tableId;
@@ -329,7 +327,7 @@ Dbtup::tuxQueryTh(Uint32 fragPtrI,
                   Uint32 transId2,
                   Uint32 savePointId)
 {
-  ljamEntry();
+  jamEntry();
   FragrecordPtr fragPtr;
   fragPtr.i= fragPtrI;
   ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
@@ -358,9 +356,9 @@ Dbtup::tuxQueryTh(Uint32 fragPtrI,
      * for this transaction and savepoint id.  If its tuple version
      * equals the requested then we have a visible tuple otherwise not.
      */
-    ljam();
+    jam();
     if (req_struct.m_tuple_ptr->get_tuple_version() == tupVersion) {
-      ljam();
+      jam();
       return true;
     }
   }
@@ -378,7 +376,7 @@ Dbtup::tuxQueryTh(Uint32 fragPtrI,
 void
 Dbtup::execBUILDINDXREQ(Signal* signal)
 {
-  ljamEntry();
+  jamEntry();
 #ifdef TIME_MEASUREMENT
   time_events= 0;
   tot_time_passed= 0;
@@ -387,7 +385,7 @@ Dbtup::execBUILDINDXREQ(Signal* signal)
   // get new operation
   BuildIndexPtr buildPtr;
   if (! c_buildIndexList.seize(buildPtr)) {
-    ljam();
+    jam();
     BuildIndexRec buildRec;
     memcpy(buildRec.m_request, signal->theData, sizeof(buildRec.m_request));
     buildRec.m_errorCode= BuildIndxRef::Busy;
@@ -402,7 +400,7 @@ Dbtup::execBUILDINDXREQ(Signal* signal)
   do {
     const BuildIndxReq* buildReq= (const BuildIndxReq*)buildPtr.p->m_request;
     if (buildReq->getTableId() >= cnoOfTablerec) {
-      ljam();
+      jam();
       buildPtr.p->m_errorCode= BuildIndxRef::InvalidPrimaryTable;
       break;
     }
@@ -410,7 +408,7 @@ Dbtup::execBUILDINDXREQ(Signal* signal)
     tablePtr.i= buildReq->getTableId();
     ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
     if (tablePtr.p->tableStatus != DEFINED) {
-      ljam();
+      jam();
       buildPtr.p->m_errorCode= BuildIndxRef::InvalidPrimaryTable;
       break;
     }
@@ -418,7 +416,7 @@ Dbtup::execBUILDINDXREQ(Signal* signal)
     buildPtr.p->m_build_vs =
       tablePtr.p->m_attributes[MM].m_no_of_varsize > 0;
     if (DictTabInfo::isOrderedIndex(buildReq->getIndexType())) {
-      ljam();
+      jam();
       const DLList<TupTriggerData>& triggerList = 
 	tablePtr.p->tuxCustomTriggers;
 
@@ -426,13 +424,13 @@ Dbtup::execBUILDINDXREQ(Signal* signal)
       triggerList.first(triggerPtr);
       while (triggerPtr.i != RNIL) {
 	if (triggerPtr.p->indexId == buildReq->getIndexId()) {
-	  ljam();
+	  jam();
 	  break;
 	}
 	triggerList.next(triggerPtr);
       }
       if (triggerPtr.i == RNIL) {
-	ljam();
+	jam();
 	// trigger was not created
 	buildPtr.p->m_errorCode = BuildIndxRef::InternalError;
 	break;
@@ -440,12 +438,12 @@ Dbtup::execBUILDINDXREQ(Signal* signal)
       buildPtr.p->m_indexId = buildReq->getIndexId();
       buildPtr.p->m_buildRef = DBTUX;
     } else if(buildReq->getIndexId() == RNIL) {
-      ljam();
+      jam();
       // REBUILD of acc
       buildPtr.p->m_indexId = RNIL;
       buildPtr.p->m_buildRef = DBACC;
     } else {
-      ljam();
+      jam();
       buildPtr.p->m_errorCode = BuildIndxRef::InvalidIndexType;
       break;
     }
@@ -490,7 +488,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     // get fragment
     FragrecordPtr fragPtr;
     if (buildPtr.p->m_fragNo == MAX_FRAG_PER_NODE) {
-      ljam();
+      jam();
       // build ready
       buildIndexReply(signal, buildPtr.p);
       c_buildIndexList.release(buildPtr);
@@ -499,7 +497,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     ndbrequire(buildPtr.p->m_fragNo < MAX_FRAG_PER_NODE);
     fragPtr.i= tablePtr.p->fragrec[buildPtr.p->m_fragNo];
     if (fragPtr.i == RNIL) {
-      ljam();
+      jam();
       buildPtr.p->m_fragNo++;
       buildPtr.p->m_pageId= 0;
       buildPtr.p->m_tupleNo= firstTupleNo;
@@ -509,7 +507,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     // get page
     PagePtr pagePtr;
     if (buildPtr.p->m_pageId >= fragPtr.p->noOfPages) {
-      ljam();
+      jam();
       buildPtr.p->m_fragNo++;
       buildPtr.p->m_pageId= 0;
       buildPtr.p->m_tupleNo= firstTupleNo;
@@ -520,7 +518,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     Uint32 pageState= pagePtr.p->page_state;
     // skip empty page
     if (pageState == ZEMPTY_MM) {
-      ljam();
+      jam();
       buildPtr.p->m_pageId++;
       buildPtr.p->m_tupleNo= firstTupleNo;
       break;
@@ -530,7 +528,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     const Tuple_header* tuple_ptr = 0;
     pageIndex = buildPtr.p->m_tupleNo * tupheadsize;
     if (pageIndex + tupheadsize > Fix_page::DATA_WORDS) {
-      ljam();
+      jam();
       buildPtr.p->m_pageId++;
       buildPtr.p->m_tupleNo= firstTupleNo;
       break;
@@ -538,7 +536,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     tuple_ptr = (Tuple_header*)&pagePtr.p->m_data[pageIndex];
     // skip over free tuple
     if (tuple_ptr->m_header_bits & Tuple_header::FREE) {
-      ljam();
+      jam();
       buildPtr.p->m_tupleNo++;
       break;
     }
@@ -581,7 +579,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
       tuple as a copy tuple. The original tuple is stable and is thus
       preferrable to store in TUX.
       */
-      ljam();
+      jam();
 
       /**
        * Since copy tuples now can't be found on real pages.
@@ -610,11 +608,11 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
       } while(req->errorCode == 0 && pageOperPtr.i != RNIL);
     } 
     
-    ljamEntry();
+    jamEntry();
     if (req->errorCode != 0) {
       switch (req->errorCode) {
       case TuxMaintReq::NoMemError:
-        ljam();
+        jam();
         buildPtr.p->m_errorCode= BuildIndxRef::AllocationFailure;
         break;
       default:
@@ -666,7 +664,7 @@ Dbtup::buildIndexReply(Signal* signal, const BuildIndexRec* buildPtrP)
   rep->setIndexId(buildReq->getIndexId());
   // conf
   if (buildPtrP->m_errorCode == BuildIndxRef::NoError) {
-    ljam();
+    jam();
     sendSignal(rep->getUserRef(), GSN_BUILDINDXCONF,
         signal, BuildIndxConf::SignalLength, JBB);
     return;
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
index e51638b8a20..cb3ec632362 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
@@ -15,6 +15,7 @@
 
 
 #define DBTUP_C
+#define DBTUP_META_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -29,16 +30,13 @@
 #include "AttributeOffset.hpp"
 #include <my_sys.h>
 
-#define ljam() { jamLine(20000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(20000 + __LINE__); }
-
 void Dbtup::execTUPFRAGREQ(Signal* signal)
 {
-  ljamEntry();
+  jamEntry();
 
   TupFragReq* tupFragReq = (TupFragReq*)signal->getDataPtr();
   if (tupFragReq->userPtr == (Uint32)-1) {
-    ljam();
+    jam();
     abortAddFragOp(signal);
     return;
   }
@@ -69,7 +67,7 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
 #ifndef VM_TRACE
   // config mismatch - do not crash if release compiled
   if (regTabPtr.i >= cnoOfTablerec) {
-    ljam();
+    jam();
     tupFragReq->userPtr = userptr;
     tupFragReq->userRef = 800;
     sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB);
@@ -79,7 +77,7 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
 
   ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
   if (cfirstfreeFragopr == RNIL) {
-    ljam();
+    jam();
     tupFragReq->userPtr = userptr;
     tupFragReq->userRef = ZNOFREE_FRAGOP_ERROR;
     sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB);
@@ -108,29 +106,29 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
 
   getFragmentrec(regFragPtr, fragId, regTabPtr.p);
   if (regFragPtr.i != RNIL) {
-    ljam();
+    jam();
     terrorCode= ZEXIST_FRAG_ERROR;
     fragrefuse1Lab(signal, fragOperPtr);
     return;
   }
   if (cfirstfreefrag != RNIL) {
-    ljam();
+    jam();
     seizeFragrecord(regFragPtr);
   } else {
-    ljam();
+    jam();
     terrorCode= ZFULL_FRAGRECORD_ERROR;
     fragrefuse1Lab(signal, fragOperPtr);
     return;
   }
   initFragRange(regFragPtr.p);
   if (!addfragtotab(regTabPtr.p, fragId, regFragPtr.i)) {
-    ljam();
+    jam();
     terrorCode= ZNO_FREE_TAB_ENTRY_ERROR;
     fragrefuse2Lab(signal, fragOperPtr, regFragPtr);
     return;
   }
   if (cfirstfreerange == RNIL) {
-    ljam();
+    jam();
     terrorCode= ZNO_FREE_PAGE_RANGE_ERROR;
     fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
     return;
@@ -146,7 +144,7 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
 
   if (ERROR_INSERTED(4007) && regTabPtr.p->fragid[0] == fragId ||
       ERROR_INSERTED(4008) && regTabPtr.p->fragid[1] == fragId) {
-    ljam();
+    jam();
     terrorCode = 1;
     fragrefuse4Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
     CLEAR_ERROR_INSERT_VALUE;
@@ -154,7 +152,7 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
   }
 
   if (regTabPtr.p->tableStatus == NOT_DEFINED) {
-    ljam();
+    jam();
 //-----------------------------------------------------------------------------
 // We are setting up references to the header of the tuple.
 // Active operation  This word contains a reference to the operation active
@@ -200,13 +198,13 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
     Uint32 offset[10];
     Uint32 tableDescriptorRef= allocTabDescr(regTabPtr.p, offset);
     if (tableDescriptorRef == RNIL) {
-      ljam();
+      jam();
       fragrefuse4Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
       return;
     }
     setUpDescriptorReferences(tableDescriptorRef, regTabPtr.p, offset);
   } else {
-    ljam();
+    jam();
     fragOperPtr.p->definingFragment= false;
   }
   signal->theData[0]= fragOperPtr.p->lqhPtrFrag;
@@ -222,9 +220,9 @@ bool Dbtup::addfragtotab(Tablerec* const regTabPtr,
                          Uint32 fragIndex) 
 {
   for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
-    ljam();
+    jam();
     if (regTabPtr->fragid[i] == RNIL) {
-      ljam();
+      jam();
       regTabPtr->fragid[i]= fragId;
       regTabPtr->fragrec[i]= fragIndex;
       return true;
@@ -238,9 +236,9 @@ void Dbtup::getFragmentrec(FragrecordPtr& regFragPtr,
                            Tablerec* const regTabPtr) 
 {
   for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
-    ljam();
+    jam();
     if (regTabPtr->fragid[i] == fragId) {
-      ljam();
+      jam();
       regFragPtr.i= regTabPtr->fragrec[i];
       ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
       return;
@@ -276,7 +274,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
   FragoperrecPtr fragOperPtr;
   TablerecPtr regTabPtr;
 
-  ljamEntry();
+  jamEntry();
   fragOperPtr.i= signal->theData[0];
   ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec);
   Uint32 attrId = signal->theData[2];
@@ -337,7 +335,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
   
   Uint32 attrDes2= 0;
   if (!AttributeDescriptor::getDynamic(attrDescriptor)) {
-    ljam();
+    jam();
     Uint32 pos= 0, null_pos;
     Uint32 bytes= AttributeDescriptor::getSizeInBytes(attrDescriptor);
     Uint32 words= (bytes + 3) / 4;
@@ -347,7 +345,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
 
     if (AttributeDescriptor::getNullable(attrDescriptor)) 
     {
-      ljam();
+      jam();
       fragOperPtr.p->m_null_bits[ind]++;
     } 
     else 
@@ -362,17 +360,17 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
     switch (AttributeDescriptor::getArrayType(attrDescriptor)) {
     case NDB_ARRAYTYPE_FIXED:
     {
-      ljam();
+      jam();
       regTabPtr.p->m_attributes[ind].m_no_of_fixsize++;
       if(attrLen != 0)
       {
-	ljam();
+	jam();
 	pos= fragOperPtr.p->m_fix_attributes_size[ind];
 	fragOperPtr.p->m_fix_attributes_size[ind] += words;
       }
       else
       {
-	ljam();
+	jam();
 	Uint32 bitCount = AttributeDescriptor::getArraySize(attrDescriptor);
 	fragOperPtr.p->m_null_bits[ind] += bitCount;
       }
@@ -380,7 +378,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
     }
     default:
     {
-      ljam();
+      jam();
       fragOperPtr.p->m_var_attributes_size[ind] += bytes;
       pos= regTabPtr.p->m_attributes[ind].m_no_of_varsize++;
       break;
@@ -397,13 +395,13 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
     ndbrequire(cs != NULL);
     Uint32 i = 0;
     while (i < fragOperPtr.p->charsetIndex) {
-      ljam();
+      jam();
       if (regTabPtr.p->charsetArray[i] == cs)
 	break;
       i++;
     }
     if (i == fragOperPtr.p->charsetIndex) {
-      ljam();
+      jam();
       fragOperPtr.p->charsetIndex++;
     }
     ndbrequire(i < regTabPtr.p->noOfCharsets);
@@ -416,7 +414,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
       ERROR_INSERTED(4010) && regTabPtr.p->fragid[0] == fragId && lastAttr ||
       ERROR_INSERTED(4011) && regTabPtr.p->fragid[1] == fragId && attrId == 0||
       ERROR_INSERTED(4012) && regTabPtr.p->fragid[1] == fragId && lastAttr) {
-    ljam();
+    jam();
     terrorCode = 1;
     addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
     CLEAR_ERROR_INSERT_VALUE;
@@ -427,7 +425,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
 /* **************          TUP_ADD_ATTCONF       ****************** */
 /* **************************************************************** */
   if (! lastAttr) {
-    ljam();
+    jam();
     signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
     signal->theData[1] = lastAttr;
     sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTCONF, 
@@ -553,7 +551,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
     noAllocatedPages = allocFragPages(regFragPtr.p, noAllocatedPages);
 
     if (noAllocatedPages == 0) {
-      ljam();
+      jam();
       terrorCode = ZNO_PAGES_ALLOCATED_ERROR;
       addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
       return;
@@ -563,7 +561,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
   CreateFilegroupImplReq rep;
   if(regTabPtr.p->m_no_of_disk_attributes)
   {
-    ljam();
+    jam();
     Tablespace_client tsman(0, c_tsman, 0, 0, 
 			    regFragPtr.p->m_tablespace_id);
     ndbrequire(tsman.get_tablespace_info(&rep) == 0);
@@ -580,12 +578,12 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
   
   if (regTabPtr.p->m_no_of_disk_attributes)
   {
-    ljam();
+    jam();
     if(!(getNodeState().startLevel == NodeState::SL_STARTING && 
 	 getNodeState().starting.startPhase <= 4))
     {
       Callback cb;
-      ljam();
+      jam();
 
       cb.m_callbackData= fragOperPtr.i;
       cb.m_callbackFunction = 
@@ -599,7 +597,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
       int res= lgman.get_log_buffer(signal, sz, &cb);
       switch(res){
       case 0:
-        ljam();
+        jam();
 	signal->theData[0] = 1;
 	return;
       case -1:
@@ -718,11 +716,11 @@ void Dbtup::setUpKeyArray(Tablerec* const regTabPtr)
   Uint32* keyArray= &tableDescriptor[regTabPtr->readKeyArray].tabDescr;
   Uint32 countKeyAttr= 0;
   for (Uint32 i= 0; i < regTabPtr->m_no_of_attributes; i++) {
-    ljam();
+    jam();
     Uint32 refAttr= regTabPtr->tabDescriptor + (i * ZAD_SIZE);
     Uint32 attrDescriptor= getTabDescrWord(refAttr);
     if (AttributeDescriptor::getPrimaryKey(attrDescriptor)) {
-      ljam();
+      jam();
       AttributeHeader::init(&keyArray[countKeyAttr], i, 0);
       countKeyAttr++;
     }
@@ -742,7 +740,7 @@ void Dbtup::setUpKeyArray(Tablerec* const regTabPtr)
   {
     for (Uint32 i= 0; i < regTabPtr->m_no_of_attributes; i++) 
     {
-      ljam();
+      jam();
       Uint32 refAttr= regTabPtr->tabDescriptor + (i * ZAD_SIZE);
       Uint32 desc = getTabDescrWord(refAttr);
       Uint32 t = 0;
@@ -837,9 +835,9 @@ void Dbtup::releaseFragoperrec(FragoperrecPtr fragOperPtr)
 void Dbtup::deleteFragTab(Tablerec* const regTabPtr, Uint32 fragId) 
 {
   for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
-    ljam();
+    jam();
     if (regTabPtr->fragid[i] == fragId) {
-      ljam();
+      jam();
       regTabPtr->fragid[i]= RNIL;
       regTabPtr->fragrec[i]= RNIL;
       return;
@@ -865,7 +863,7 @@ void Dbtup::abortAddFragOp(Signal* signal)
 void
 Dbtup::execDROP_TAB_REQ(Signal* signal)
 {
-  ljamEntry();
+  jamEntry();
   if (ERROR_INSERTED(4013)) {
 #ifdef VM_TRACE
     verifytabdes();
@@ -891,7 +889,7 @@ void Dbtup::releaseTabDescr(Tablerec* const regTabPtr)
 {
   Uint32 descriptor= regTabPtr->readKeyArray;
   if (descriptor != RNIL) {
-    ljam();
+    jam();
     Uint32 offset[10];
     getTabDescrOffsets(regTabPtr, offset);
 
@@ -922,16 +920,16 @@ void Dbtup::releaseFragment(Signal* signal, Uint32 tableId,
   Uint32 fragId = RNIL;
   Uint32 i = 0;
   for (i = 0; i < MAX_FRAG_PER_NODE; i++) {
-    ljam();
+    jam();
     if (tabPtr.p->fragid[i] != RNIL) {
-      ljam();
+      jam();
       fragIndex= tabPtr.p->fragrec[i];
       fragId= tabPtr.p->fragid[i];
       break;
     }
   }
   if (fragIndex != RNIL) {
-    ljam();
+    jam();
     
     signal->theData[0] = ZUNMAP_PAGES;
     signal->theData[1] = tabPtr.i;
@@ -956,7 +954,7 @@ void Dbtup::releaseFragment(Signal* signal, Uint32 tableId,
     int res= lgman.get_log_buffer(signal, sz, &cb);
     switch(res){
     case 0:
-      ljam();
+      jam();
       return;
     case -1:
       ndbrequire("NOT YET IMPLEMENTED" == 0);
@@ -1087,7 +1085,7 @@ Dbtup::drop_fragment_free_extent(Signal *signal,
 	int res= lgman.get_log_buffer(signal, sz, &cb);
 	switch(res){
 	case 0:
-	  ljam();
+	  jam();
 	  return;
 	case -1:
 	  ndbrequire("NOT YET IMPLEMENTED" == 0);
@@ -1238,7 +1236,7 @@ Dbtup::drop_fragment_free_extent_log_buffer_callback(Signal* signal,
 void
 Dbtup::drop_fragment_free_var_pages(Signal* signal)
 {
-  ljam();
+  jam();
   Uint32 tableId = signal->theData[1];
   Uint32 fragPtrI = signal->theData[2];
   
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp
index 73755494207..d10fabf42da 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp
@@ -14,14 +14,12 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_PAG_MAN_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 
-#define ljam() { jamLine(16000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(16000 + __LINE__); }
-
 /* ---------------------------------------------------------------- */
 // 4) Page Memory Manager (buddy algorithm)
 //
@@ -121,7 +119,7 @@ void Dbtup::initializePage()
   }//for
   PagePtr pagePtr;
   for (pagePtr.i = 0; pagePtr.i < c_page_pool.getSize(); pagePtr.i++) {
-    ljam();
+    jam();
     refresh_watch_dog();
     c_page_pool.getPtr(pagePtr);
     pagePtr.p->physical_page_id= RNIL;
@@ -153,16 +151,16 @@ void Dbtup::allocConsPages(Uint32 noOfPagesToAllocate,
                            Uint32& allocPageRef)
 {
   if (noOfPagesToAllocate == 0){ 
-    ljam();
+    jam();
     noOfPagesAllocated = 0;
     return;
   }//if
 
   Uint32 firstListToCheck = nextHigherTwoLog(noOfPagesToAllocate - 1);
   for (Uint32 i = firstListToCheck; i < 16; i++) {
-    ljam();
+    jam();
     if (cfreepageList[i] != RNIL) {
-      ljam();
+      jam();
 /* ---------------------------------------------------------------- */
 /*       PROPER AMOUNT OF PAGES WERE FOUND. NOW SPLIT THE FOUND     */
 /*       AREA AND RETURN THE PART NOT NEEDED.                       */
@@ -182,11 +180,11 @@ void Dbtup::allocConsPages(Uint32 noOfPagesToAllocate,
 /* ---------------------------------------------------------------- */
   if (firstListToCheck)
   {
-    ljam();
+    jam();
     for (Uint32 j = firstListToCheck - 1; (Uint32)~j; j--) {
-      ljam();
+      jam();
       if (cfreepageList[j] != RNIL) {
-	ljam();
+	jam();
 /* ---------------------------------------------------------------- */
 /*       SOME AREA WAS FOUND, ALLOCATE ALL OF IT.                   */
 /* ---------------------------------------------------------------- */
@@ -212,9 +210,9 @@ void Dbtup::allocConsPages(Uint32 noOfPagesToAllocate,
 void Dbtup::returnCommonArea(Uint32 retPageRef, Uint32 retNo) 
 {
   do {
-    ljam();
+    jam();
     if (retNo == 0) {
-      ljam();
+      jam();
       return;
     }//if
     Uint32 list = nextHigherTwoLog(retNo) - 1;
@@ -231,28 +229,28 @@ void Dbtup::findFreeLeftNeighbours(Uint32& allocPageRef,
   PagePtr pageFirstPtr, pageLastPtr;
   Uint32 remainAllocate = noOfPagesToAllocate - noPagesAllocated;
   while (allocPageRef > 0) {
-    ljam();
+    jam();
     pageLastPtr.i = allocPageRef - 1;
     c_page_pool.getPtr(pageLastPtr);
     if (pageLastPtr.p->page_state != ZFREE_COMMON) {
-      ljam();
+      jam();
       return;
     } else {
-      ljam();
+      jam();
       pageFirstPtr.i = pageLastPtr.p->first_cluster_page;
       ndbrequire(pageFirstPtr.i != RNIL);
       Uint32 list = nextHigherTwoLog(pageLastPtr.i - pageFirstPtr.i);
       removeCommonArea(pageFirstPtr.i, list);
       Uint32 listSize = 1 << list;
       if (listSize > remainAllocate) {
-        ljam();
+        jam();
         Uint32 retNo = listSize - remainAllocate;
         returnCommonArea(pageFirstPtr.i, retNo);
         allocPageRef = pageFirstPtr.i + retNo;
         noPagesAllocated = noOfPagesToAllocate;
         return;
       } else {
-        ljam();
+        jam();
         allocPageRef = pageFirstPtr.i;
         noPagesAllocated += listSize;
         remainAllocate -= listSize;
@@ -268,32 +266,32 @@ void Dbtup::findFreeRightNeighbours(Uint32& allocPageRef,
   PagePtr pageFirstPtr, pageLastPtr;
   Uint32 remainAllocate = noOfPagesToAllocate - noPagesAllocated;
   if (remainAllocate == 0) {
-    ljam();
+    jam();
     return;
   }//if
   while ((allocPageRef + noPagesAllocated) < c_page_pool.getSize()) {
-    ljam();
+    jam();
     pageFirstPtr.i = allocPageRef + noPagesAllocated;
     c_page_pool.getPtr(pageFirstPtr);
     if (pageFirstPtr.p->page_state != ZFREE_COMMON) {
-      ljam();
+      jam();
       return;
     } else {
-      ljam();
+      jam();
       pageLastPtr.i = pageFirstPtr.p->last_cluster_page;
       ndbrequire(pageLastPtr.i != RNIL);
       Uint32 list = nextHigherTwoLog(pageLastPtr.i - pageFirstPtr.i);
       removeCommonArea(pageFirstPtr.i, list);
       Uint32 listSize = 1 << list;
       if (listSize > remainAllocate) {
-        ljam();
+        jam();
         Uint32 retPageRef = pageFirstPtr.i + remainAllocate;
         Uint32 retNo = listSize - remainAllocate;
         returnCommonArea(retPageRef, retNo);
         noPagesAllocated += remainAllocate;
         return;
       } else {
-        ljam();
+        jam();
         noPagesAllocated += listSize;
         remainAllocate -= listSize;
       }//if
@@ -328,30 +326,30 @@ void Dbtup::removeCommonArea(Uint32 remPageRef, Uint32 list)
   c_page_pool.getPtr(remPagePtr, remPageRef);
   ndbrequire(list < 16);
   if (cfreepageList[list] == remPagePtr.i) {
-    ljam();
+    jam();
     cfreepageList[list] = remPagePtr.p->next_cluster_page;
     pageNextPtr.i = cfreepageList[list];
     if (pageNextPtr.i != RNIL) {
-      ljam();
+      jam();
       c_page_pool.getPtr(pageNextPtr);
       pageNextPtr.p->prev_cluster_page = RNIL;
     }//if
   } else {
     pageSearchPtr.i = cfreepageList[list];
     while (true) {
-      ljam();
+      jam();
       c_page_pool.getPtr(pageSearchPtr);
       pagePrevPtr = pageSearchPtr;
       pageSearchPtr.i = pageSearchPtr.p->next_cluster_page;
       if (pageSearchPtr.i == remPagePtr.i) {
-        ljam();
+        jam();
         break;
       }//if
     }//while
     pageNextPtr.i = remPagePtr.p->next_cluster_page;
     pagePrevPtr.p->next_cluster_page = pageNextPtr.i;
     if (pageNextPtr.i != RNIL) {
-      ljam();
+      jam();
       c_page_pool.getPtr(pageNextPtr);
       pageNextPtr.p->prev_cluster_page = pagePrevPtr.i;
     }//if
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp
index 26373708b66..cbbbc1fa56c 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp
@@ -15,14 +15,12 @@
 
 
 #define DBTUP_C
+#define DBTUP_PAGE_MAP_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 
-#define ljam() { jamLine(14000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(14000 + __LINE__); }
-
 //
 // PageMap is a service used by Dbtup to map logical page id's to physical
 // page id's. The mapping is needs the fragment and the logical page id to
@@ -92,11 +90,11 @@ Uint32 Dbtup::getEmptyPage(Fragrecord* regFragPtr)
 {
   Uint32 pageId = regFragPtr->emptyPrimPage.firstItem;
   if (pageId == RNIL) {
-    ljam();
+    jam();
     allocMoreFragPages(regFragPtr);
     pageId = regFragPtr->emptyPrimPage.firstItem;
     if (pageId == RNIL) {
-      ljam();
+      jam();
       return RNIL;
     }//if
   }//if
@@ -122,11 +120,11 @@ Uint32 Dbtup::getRealpid(Fragrecord* regFragPtr, Uint32 logicalPageId)
     loopLimit = grpPageRangePtr.p->currentIndexPos;
     ndbrequire(loopLimit <= 3);
     for (Uint32 i = 0; i <= loopLimit; i++) {
-      ljam();
+      jam();
       if (grpPageRangePtr.p->startRange[i] <= logicalPageId) {
         if (grpPageRangePtr.p->endRange[i] >= logicalPageId) {
           if (grpPageRangePtr.p->type[i] == ZLEAF) {
-            ljam();
+            jam();
             Uint32 realPageId = (logicalPageId - grpPageRangePtr.p->startRange[i]) +
                                  grpPageRangePtr.p->basePageId[i];
             return realPageId;
@@ -167,12 +165,12 @@ bool Dbtup::insertPageRangeTab(Fragrecord*  const regFragPtr,
 {
   PageRangePtr currPageRangePtr;
   if (cfirstfreerange == RNIL) {
-    ljam();
+    jam();
     return false;
   }//if
   currPageRangePtr.i = regFragPtr->currentPageRange;
   if (currPageRangePtr.i == RNIL) {
-    ljam();
+    jam();
 /* ---------------------------------------------------------------- */
 /*       THE FIRST PAGE RANGE IS HANDLED WITH SPECIAL CODE          */
 /* ---------------------------------------------------------------- */
@@ -181,10 +179,10 @@ bool Dbtup::insertPageRangeTab(Fragrecord*  const regFragPtr,
     currPageRangePtr.p->currentIndexPos = 0;
     currPageRangePtr.p->parentPtr = RNIL;
   } else {
-    ljam();
+    jam();
     ptrCheckGuard(currPageRangePtr, cnoOfPageRangeRec, pageRange);
     if (currPageRangePtr.p->currentIndexPos < 3) {
-      ljam();
+      jam();
 /* ---------------------------------------------------------------- */
 /*       THE SIMPLE CASE WHEN IT IS ONLY NECESSARY TO FILL IN THE   */
 /*       NEXT EMPTY POSITION IN THE PAGE RANGE RECORD IS TREATED    */
@@ -192,7 +190,7 @@ bool Dbtup::insertPageRangeTab(Fragrecord*  const regFragPtr,
 /* ---------------------------------------------------------------- */
       currPageRangePtr.p->currentIndexPos++;
     } else {
-      ljam();
+      jam();
       ndbrequire(currPageRangePtr.p->currentIndexPos == 3);
       currPageRangePtr.i = leafPageRangeFull(regFragPtr, currPageRangePtr);
       if (currPageRangePtr.i == RNIL) {
@@ -223,15 +221,15 @@ bool Dbtup::insertPageRangeTab(Fragrecord*  const regFragPtr,
   PageRangePtr loopPageRangePtr;
   loopPageRangePtr = currPageRangePtr;
   while (true) {
-    ljam();
+    jam();
     loopPageRangePtr.i = loopPageRangePtr.p->parentPtr;
     if (loopPageRangePtr.i != RNIL) {
-      ljam();
+      jam();
       ptrCheckGuard(loopPageRangePtr, cnoOfPageRangeRec, pageRange);
       ndbrequire(loopPageRangePtr.p->currentIndexPos < 4);
       loopPageRangePtr.p->endRange[loopPageRangePtr.p->currentIndexPos] += noPages;
     } else {
-      ljam();
+      jam();
       break;
     }//if
   }//while
@@ -243,26 +241,26 @@ bool Dbtup::insertPageRangeTab(Fragrecord*  const regFragPtr,
 void Dbtup::releaseFragPages(Fragrecord* regFragPtr) 
 {
   if (regFragPtr->rootPageRange == RNIL) {
-    ljam();
+    jam();
     return;
   }//if
   PageRangePtr regPRPtr;
   regPRPtr.i = regFragPtr->rootPageRange;
   ptrCheckGuard(regPRPtr, cnoOfPageRangeRec, pageRange);
   while (true) {
-    ljam();
+    jam();
     const Uint32 indexPos = regPRPtr.p->currentIndexPos;
     ndbrequire(indexPos < 4);
 
     const Uint32 basePageId = regPRPtr.p->basePageId[indexPos];
     regPRPtr.p->basePageId[indexPos] = RNIL;
     if (basePageId == RNIL) {
-      ljam();
+      jam();
       /**
        * Finished with indexPos continue with next
        */
       if (indexPos > 0) {
-        ljam();
+        jam();
 	regPRPtr.p->currentIndexPos--;
 	continue;
       }//if
@@ -274,13 +272,13 @@ void Dbtup::releaseFragPages(Fragrecord* regFragPtr)
       releasePagerange(regPRPtr);
       
       if (parentPtr != RNIL) {
-	ljam();
+	jam();
 	regPRPtr.i = parentPtr;
 	ptrCheckGuard(regPRPtr, cnoOfPageRangeRec, pageRange);
 	continue;
       }//if
 
-      ljam();
+      jam();
       ndbrequire(regPRPtr.i == regFragPtr->rootPageRange);
       initFragRange(regFragPtr);
       for (Uint32 i = 0; i<MAX_FREE_LIST; i++)
@@ -364,7 +362,7 @@ Uint32 Dbtup::allocFragPages(Fragrecord* regFragPtr, Uint32 tafpNoAllocRequested
     Uint32 retPageRef = RNIL;
     allocConsPages(noPagesToAllocate, noOfPagesAllocated, retPageRef);
     if (noOfPagesAllocated == 0) {
-      ljam();
+      jam();
       return tafpPagesAllocated;
     }//if
 /* ---------------------------------------------------------------- */
@@ -373,7 +371,7 @@ Uint32 Dbtup::allocFragPages(Fragrecord* regFragPtr, Uint32 tafpNoAllocRequested
 /* ---------------------------------------------------------------- */
     Uint32 startRange = regFragPtr->nextStartRange;
     if (!insertPageRangeTab(regFragPtr, retPageRef, noOfPagesAllocated)) {
-      ljam();
+      jam();
       returnCommonArea(retPageRef, noOfPagesAllocated);
       return tafpPagesAllocated;
     }//if
@@ -388,7 +386,7 @@ Uint32 Dbtup::allocFragPages(Fragrecord* regFragPtr, Uint32 tafpNoAllocRequested
 /* ---------------------------------------------------------------- */
     Uint32 prev = RNIL;
     for (loopPagePtr.i = retPageRef; loopPagePtr.i < loopLimit; loopPagePtr.i++) {
-      ljam();
+      jam();
       c_page_pool.getPtr(loopPagePtr);
       loopPagePtr.p->page_state = ZEMPTY_MM;
       loopPagePtr.p->frag_page_id = startRange +
@@ -416,10 +414,10 @@ Uint32 Dbtup::allocFragPages(Fragrecord* regFragPtr, Uint32 tafpNoAllocRequested
 /*       WAS ENOUGH PAGES ALLOCATED OR ARE MORE NEEDED.             */
 /* ---------------------------------------------------------------- */
     if (tafpPagesAllocated < tafpNoAllocRequested) {
-      ljam();
+      jam();
     } else {
       ndbrequire(tafpPagesAllocated == tafpNoAllocRequested);
-      ljam();
+      jam();
       return tafpNoAllocRequested;
     }//if
   }//while
@@ -451,15 +449,15 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr curr
   parentPageRangePtr = currPageRangePtr;
   Uint32 tiprNoLevels = 1;
   while (true) {
-    ljam();
+    jam();
     parentPageRangePtr.i = parentPageRangePtr.p->parentPtr;
     if (parentPageRangePtr.i == RNIL) {
-      ljam();
+      jam();
 /* ---------------------------------------------------------------- */
 /*       WE HAVE REACHED THE ROOT. A NEW ROOT MUST BE ALLOCATED.    */
 /* ---------------------------------------------------------------- */
       if (c_noOfFreePageRanges < tiprNoLevels) {
-        ljam();
+        jam();
         return RNIL;
       }//if
       PageRangePtr oldRootPRPtr;
@@ -482,10 +480,10 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr curr
       foundPageRangePtr = newRootPRPtr;
       break;
     } else {
-      ljam();
+      jam();
       ptrCheckGuard(parentPageRangePtr, cnoOfPageRangeRec, pageRange);
       if (parentPageRangePtr.p->currentIndexPos < 3) {
-        ljam();
+        jam();
 /* ---------------------------------------------------------------- */
 /*       WE HAVE FOUND AN EMPTY ENTRY IN A PAGE RANGE RECORD.       */
 /*       ALLOCATE A NEW PAGE RANGE RECORD, FILL IN THE START RANGE, */
@@ -498,7 +496,7 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr curr
         foundPageRangePtr = parentPageRangePtr;
         break;
       } else {
-        ljam();
+        jam();
         ndbrequire(parentPageRangePtr.p->currentIndexPos == 3);
 /* ---------------------------------------------------------------- */
 /*       THE PAGE RANGE RECORD WAS FULL. FIND THE PARENT RECORD     */
@@ -516,7 +514,7 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr curr
   PageRangePtr prevPageRangePtr;
   prevPageRangePtr = foundPageRangePtr;
   if (c_noOfFreePageRanges < tiprNoLevels) {
-    ljam();
+    jam();
     return RNIL;
   }//if
 /* ---------------------------------------------------------------- */
@@ -527,7 +525,7 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr curr
 /*       ARE ALSO PROPERLY UPDATED ON THE PATH TO THE LEAF LEVEL.   */
 /* ---------------------------------------------------------------- */
   while (true) {
-    ljam();
+    jam();
     seizePagerange(newPageRangePtr);
     tiprNoLevels--;
     ndbrequire(prevPageRangePtr.p->currentIndexPos < 4);
@@ -535,13 +533,13 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr curr
     newPageRangePtr.p->parentPtr = prevPageRangePtr.i;
     newPageRangePtr.p->currentIndexPos = 0;
     if (tiprNoLevels > 0) {
-      ljam();
+      jam();
       newPageRangePtr.p->startRange[0] = regFragPtr->nextStartRange;
       newPageRangePtr.p->endRange[0] = regFragPtr->nextStartRange - 1;
       newPageRangePtr.p->type[0] = ZNON_LEAF;
       prevPageRangePtr = newPageRangePtr;
     } else {
-      ljam();
+      jam();
       break;
     }//if
   }//while
@@ -576,16 +574,16 @@ void Dbtup::errorHandler(Uint32 errorCode)
 {
   switch (errorCode) {
   case 0:
-    ljam();
+    jam();
     break;
   case 1:
-    ljam();
+    jam();
     break;
   case 2:
-    ljam();
+    jam();
     break;
   default:
-    ljam();
+    jam();
   }
   ndbrequire(false);
 }//Dbtup::errorHandler()
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp
index 28f66c5620a..6e932f8a058 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp
@@ -15,6 +15,7 @@
 
 
 #define DBTUP_C
+#define DBTUP_ROUTINES_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -23,9 +24,6 @@
 #include "AttributeOffset.hpp"
 #include <AttributeHeader.hpp>
 
-#define ljam() { jamLine(3000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(3000 + __LINE__); }
-
 void
 Dbtup::setUpQueryRoutines(Tablerec *regTabPtr)
 {
@@ -40,23 +38,23 @@ Dbtup::setUpQueryRoutines(Tablerec *regTabPtr)
       if (AttributeDescriptor::getArrayType(attrDescr) == NDB_ARRAYTYPE_FIXED){
         if (!AttributeDescriptor::getNullable(attrDescr)) {
           if (AttributeDescriptor::getSize(attrDescr) == 0){
-            ljam(); 
+            jam(); 
             regTabPtr->readFunctionArray[i] = &Dbtup::readBitsNotNULL;
             regTabPtr->updateFunctionArray[i] = &Dbtup::updateBitsNotNULL;
           } else if (AttributeDescriptor::getSizeInBytes(attrDescr) == 4) {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i]=
 	      &Dbtup::readFixedSizeTHOneWordNotNULL;
             regTabPtr->updateFunctionArray[i]=
 	      &Dbtup::updateFixedSizeTHOneWordNotNULL;
           } else if (AttributeDescriptor::getSizeInBytes(attrDescr) == 8) {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i]=
                     &Dbtup::readFixedSizeTHTwoWordNotNULL;
             regTabPtr->updateFunctionArray[i]=
                     &Dbtup::updateFixedSizeTHTwoWordNotNULL;
           } else {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i]=
 	      &Dbtup::readFixedSizeTHManyWordNotNULL;
             regTabPtr->updateFunctionArray[i]=
@@ -64,27 +62,27 @@ Dbtup::setUpQueryRoutines(Tablerec *regTabPtr)
           }
           // replace functions for char attribute
           if (AttributeOffset::getCharsetFlag(attrOffset)) {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHManyWordNotNULL;
             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNotNULL;
           }
         } else {
 	  if (AttributeDescriptor::getSize(attrDescr) == 0){
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i] = &Dbtup::readBitsNULLable;
             regTabPtr->updateFunctionArray[i] = &Dbtup::updateBitsNULLable;
 	  } else if (AttributeDescriptor::getSizeInBytes(attrDescr) == 4){
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHOneWordNULLable;
             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable;
           } else if (AttributeDescriptor::getSizeInBytes(attrDescr) == 8) {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i]=
                     &Dbtup::readFixedSizeTHTwoWordNULLable;
             regTabPtr->updateFunctionArray[i]=
                     &Dbtup::updateFixedSizeTHManyWordNULLable;
           } else {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i]=
 	      &Dbtup::readFixedSizeTHManyWordNULLable;
             regTabPtr->updateFunctionArray[i]=
@@ -92,7 +90,7 @@ Dbtup::setUpQueryRoutines(Tablerec *regTabPtr)
           }
           // replace functions for char attribute
           if (AttributeOffset::getCharsetFlag(attrOffset)) {
-            ljam();
+            jam();
             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHManyWordNULLable;
             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable;
           }
@@ -144,7 +142,7 @@ Dbtup::setUpQueryRoutines(Tablerec *regTabPtr)
       }
       } else {
       if (AttributeDescriptor::getArrayType(attrDescr) == NDB_ARRAYTYPE_FIXED){
-        ljam();
+        jam();
         regTabPtr->readFunctionArray[i]= &Dbtup::readDynFixedSize;
         regTabPtr->updateFunctionArray[i]= &Dbtup::updateDynFixedSize;
       } else {
@@ -204,7 +202,7 @@ int Dbtup::readAttributes(KeyReqStruct *req_struct,
     inBufIndex++;
     attributeId= ahIn.getAttributeId();
     descr_index= attributeId << ZAD_LOG_SIZE;
-    ljam();
+    jam();
 
     AttributeHeader::init(&outBuffer[tmpAttrBufIndex], attributeId, 0);
     ahOut= (AttributeHeader*)&outBuffer[tmpAttrBufIndex];
@@ -223,7 +221,7 @@ int Dbtup::readAttributes(KeyReqStruct *req_struct,
         return -1;
       }
     } else if(attributeId & AttributeHeader::PSEUDO) {
-      ljam();
+      jam();
       Uint32 sz= read_pseudo(attributeId,
                              req_struct,
 			     outBuffer+tmpAttrBufIndex+1);
@@ -252,13 +250,13 @@ Dbtup::readFixedSizeTHOneWordNotNULL(Uint32* outBuffer,
 
   ndbrequire(readOffset < req_struct->check_offset[MM]);
   if (newIndexBuf <= maxRead) {
-    ljam();
+    jam();
     outBuffer[indexBuf]= wordRead;
     ahOut->setDataSize(1);
     req_struct->out_buf_index= newIndexBuf;
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode= ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }
@@ -280,14 +278,14 @@ Dbtup::readFixedSizeTHTwoWordNotNULL(Uint32* outBuffer,
 
   ndbrequire(readOffset + 1 < req_struct->check_offset[MM]);
   if (newIndexBuf <= maxRead) {
-    ljam();
+    jam();
     ahOut->setDataSize(2);
     outBuffer[indexBuf]= wordReadFirst;
     outBuffer[indexBuf + 1]= wordReadSecond;
     req_struct->out_buf_index= newIndexBuf;
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode= ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }
@@ -311,7 +309,7 @@ Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer,
   if (! charsetFlag || ! req_struct->xfrm_flag) {
     Uint32 newIndexBuf = indexBuf + attrNoOfWords;
     if (newIndexBuf <= maxRead) {
-      ljam();
+      jam();
       ahOut->setByteSize(AttributeDescriptor::getSizeInBytes(attrDescriptor));
       MEMCOPY_NO_WORDS(&outBuffer[indexBuf],
                        &tuple_header[readOffset],
@@ -319,11 +317,11 @@ Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer,
       req_struct->out_buf_index = newIndexBuf;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     }//if
   } else {
-    ljam();
+    jam();
     Tablerec* regTabPtr = tabptr.p;
     Uint32 srcBytes = AttributeDescriptor::getSizeInBytes(attrDescriptor);
     uchar* dstPtr = (uchar*)&outBuffer[indexBuf];
@@ -340,7 +338,7 @@ Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer,
     Uint32 dstLen = xmul * (srcBytes - lb);
     Uint32 maxIndexBuf = indexBuf + (dstLen >> 2);
     if (maxIndexBuf <= maxRead && ok) {
-      ljam();
+      jam();
       int n = NdbSqlUtil::strnxfrm_bug7284(cs, dstPtr, dstLen, srcPtr + lb, len);
       ndbrequire(n != -1);
       int m = n;
@@ -353,7 +351,7 @@ Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer,
       req_struct->out_buf_index = newIndexBuf;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     }
   } 
@@ -367,13 +365,13 @@ Dbtup::readFixedSizeTHOneWordNULLable(Uint32* outBuffer,
                                       Uint32  attrDes2)
 {
   if (!nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     return readFixedSizeTHOneWordNotNULL(outBuffer,
                                          req_struct,
                                          ahOut,
                                          attrDes2);
   } else {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
@@ -386,13 +384,13 @@ Dbtup::readFixedSizeTHTwoWordNULLable(Uint32* outBuffer,
                                       Uint32  attrDes2)
 {
   if (!nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     return readFixedSizeTHTwoWordNotNULL(outBuffer,
                                          req_struct,
                                          ahOut,
                                          attrDes2);
   } else {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
@@ -405,13 +403,13 @@ Dbtup::readFixedSizeTHManyWordNULLable(Uint32* outBuffer,
                                        Uint32  attrDes2)
 {
   if (!nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     return readFixedSizeTHManyWordNotNULL(outBuffer,
                                           req_struct,
                                           ahOut,
                                           attrDes2);
   } else {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
@@ -423,9 +421,9 @@ Dbtup::readFixedSizeTHZeroWordNULLable(Uint32* outBuffer,
                                        AttributeHeader* ahOut,
                                        Uint32  attrDes2)
 {
-  ljam();
+  jam();
   if (nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     ahOut->setNULL();
   }
   return true;
@@ -477,7 +475,7 @@ Dbtup::readVarSizeNotNULL(Uint32* out_buffer,
   if (! charsetFlag || ! req_struct->xfrm_flag)
   {
     if (new_index <= max_read) {
-      ljam();
+      jam();
       ah_out->setByteSize(vsize_in_bytes);
       out_buffer[index_buf + (vsize_in_bytes >> 2)] = 0;
       memcpy(out_buffer+index_buf,
@@ -489,7 +487,7 @@ Dbtup::readVarSizeNotNULL(Uint32* out_buffer,
   }
   else
   {
-    ljam();
+    jam();
     Tablerec* regTabPtr = tabptr.p;
     Uint32 maxBytes = AttributeDescriptor::getSizeInBytes(attr_descriptor);
     Uint32 srcBytes = vsize_in_bytes;
@@ -508,7 +506,7 @@ Dbtup::readVarSizeNotNULL(Uint32* out_buffer,
     Uint32 dstLen = xmul * (maxBytes - lb);
     Uint32 maxIndexBuf = index_buf + (dstLen >> 2);
     if (maxIndexBuf <= max_read && ok) {
-      ljam();
+      jam();
       int n = NdbSqlUtil::strnxfrm_bug7284(cs, dstPtr, dstLen, srcPtr + lb, len);
       ndbrequire(n != -1);
       int m = n;
@@ -522,7 +520,7 @@ Dbtup::readVarSizeNotNULL(Uint32* out_buffer,
       return true;
     }
   }
-  ljam();
+  jam();
   terrorCode= ZTRY_TO_READ_TOO_MUCH_ERROR;
   return false;
 }
@@ -534,13 +532,13 @@ Dbtup::readVarSizeNULLable(Uint32* outBuffer,
                            Uint32  attrDes2)
 {
   if (!nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     return readVarSizeNotNULL(outBuffer,
                               req_struct,
                               ahOut,
                               attrDes2);
   } else {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
@@ -552,7 +550,7 @@ Dbtup::readDynFixedSize(Uint32* outBuffer,
                         AttributeHeader* ahOut,
                         Uint32  attrDes2)
 {
-  ljam();
+  jam();
   terrorCode= ZVAR_SIZED_NOT_SUPPORTED;
   return false;
 }
@@ -563,7 +561,7 @@ Dbtup::readDynVarSize(Uint32* outBuffer,
                       AttributeHeader* ahOut,
                       Uint32  attrDes2)
 {
-  ljam();
+  jam();
   terrorCode= ZVAR_SIZED_NOT_SUPPORTED;
   return false;
 }//Dbtup::readDynBigVarSize()
@@ -586,7 +584,7 @@ Dbtup::readDiskFixedSizeNotNULL(Uint32* outBuffer,
   if (! charsetFlag || ! req_struct->xfrm_flag) {
     Uint32 newIndexBuf = indexBuf + attrNoOfWords;
     if (newIndexBuf <= maxRead) {
-      ljam();
+      jam();
       ahOut->setByteSize(AttributeDescriptor::getSizeInBytes(attrDescriptor));
       MEMCOPY_NO_WORDS(&outBuffer[indexBuf],
                        &tuple_header[readOffset],
@@ -594,11 +592,11 @@ Dbtup::readDiskFixedSizeNotNULL(Uint32* outBuffer,
       req_struct->out_buf_index = newIndexBuf;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     }//if
   } else {
-    ljam();
+    jam();
     Tablerec* regTabPtr = tabptr.p;
     Uint32 srcBytes = AttributeDescriptor::getSizeInBytes(attrDescriptor);
     uchar* dstPtr = (uchar*)&outBuffer[indexBuf];
@@ -615,7 +613,7 @@ Dbtup::readDiskFixedSizeNotNULL(Uint32* outBuffer,
     Uint32 dstLen = xmul * (srcBytes - lb);
     Uint32 maxIndexBuf = indexBuf + (dstLen >> 2);
     if (maxIndexBuf <= maxRead && ok) {
-      ljam();
+      jam();
       int n = NdbSqlUtil::strnxfrm_bug7284(cs, dstPtr, dstLen, srcPtr + lb, len);
       ndbrequire(n != -1);
       int m = n;
@@ -628,7 +626,7 @@ Dbtup::readDiskFixedSizeNotNULL(Uint32* outBuffer,
       req_struct->out_buf_index = newIndexBuf;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     }
   } 
@@ -642,13 +640,13 @@ Dbtup::readDiskFixedSizeNULLable(Uint32* outBuffer,
 				 Uint32  attrDes2)
 {
   if (!disk_nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     return readDiskFixedSizeNotNULL(outBuffer,
 				    req_struct,
 				    ahOut,
 				    attrDes2);
   } else {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
@@ -677,7 +675,7 @@ Dbtup::readDiskVarSizeNotNULL(Uint32* out_buffer,
 
   ndbrequire(vsize_in_words <= max_var_size);
   if (new_index <= max_read) {
-    ljam();
+    jam();
     ah_out->setByteSize(vsize_in_bytes);
     memcpy(out_buffer+index_buf,
 	   req_struct->m_var_data[DD].m_data_ptr+var_attr_pos,
@@ -685,7 +683,7 @@ Dbtup::readDiskVarSizeNotNULL(Uint32* out_buffer,
     req_struct->out_buf_index= new_index;
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode= ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }
@@ -698,13 +696,13 @@ Dbtup::readDiskVarSizeNULLable(Uint32* outBuffer,
 			       Uint32  attrDes2)
 {
   if (!disk_nullFlagCheck(req_struct, attrDes2)) {
-    ljam();
+    jam();
     return readDiskVarSizeNotNULL(outBuffer,
 				  req_struct,
 				  ahOut,
 				  attrDes2);
   } else {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
@@ -746,13 +744,13 @@ int Dbtup::updateAttributes(KeyReqStruct *req_struct,
         if (checkUpdateOfPrimaryKey(req_struct,
                                     &inBuffer[inBufIndex],
                                     regTabPtr)) {
-          ljam();
+          jam();
           terrorCode= ZTRY_UPDATE_PRIMARY_KEY;
           return -1;
         }
       }
       UpdateFunction f= regTabPtr->updateFunctionArray[attributeId];
-      ljam();
+      jam();
       req_struct->attr_descriptor= attrDescriptor;
       req_struct->changeMask.set(attributeId);
       if (attributeId >= 64) {
@@ -768,13 +766,13 @@ int Dbtup::updateAttributes(KeyReqStruct *req_struct,
         inBufIndex= req_struct->in_buf_index;
         continue;
       } else {
-        ljam();
+        jam();
         return -1;
       }
     } 
     else if(attributeId == AttributeHeader::DISK_REF)
     {
-      ljam();
+      jam();
       Uint32 sz= ahIn.getDataSize();
       ndbrequire(sz == 2);
       req_struct->m_tuple_ptr->m_header_bits |= Tuple_header::DISK_PART;
@@ -785,7 +783,7 @@ int Dbtup::updateAttributes(KeyReqStruct *req_struct,
     }
     else
     {
-      ljam();
+      jam();
       terrorCode= ZATTRIBUTE_ID_ERROR;
       return -1;
     }
@@ -839,13 +837,13 @@ Dbtup::checkUpdateOfPrimaryKey(KeyReqStruct* req_struct,
   
   ndbrequire(req_struct->out_buf_index == ahOut->getDataSize());
   if (ahIn.getDataSize() != ahOut->getDataSize()) {
-    ljam();
+    jam();
     return true;
   }
   if (memcmp(&keyReadBuffer[0],
              &updateBuffer[1],
              req_struct->out_buf_index << 2) != 0) {
-    ljam();
+    jam();
     return true;
   }
   return false;
@@ -868,17 +866,17 @@ Dbtup::updateFixedSizeTHOneWordNotNULL(Uint32* inBuffer,
   if (newIndex <= inBufLen) {
     Uint32 updateWord= inBuffer[indexBuf + 1];
     if (!nullIndicator) {
-      ljam();
+      jam();
       req_struct->in_buf_index= newIndex;
       tuple_header[updateOffset]= updateWord;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZNOT_NULL_ATTR;
       return false;
     }
   } else {
-    ljam();
+    jam();
     terrorCode= ZAI_INCONSISTENCY_ERROR;
     return false;
   }
@@ -903,18 +901,18 @@ Dbtup::updateFixedSizeTHTwoWordNotNULL(Uint32* inBuffer,
     Uint32 updateWord1= inBuffer[indexBuf + 1];
     Uint32 updateWord2= inBuffer[indexBuf + 2];
     if (!nullIndicator) {
-      ljam();
+      jam();
       req_struct->in_buf_index= newIndex;
       tuple_header[updateOffset]= updateWord1;
       tuple_header[updateOffset + 1]= updateWord2;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZNOT_NULL_ATTR;
       return false;
     }
   } else {
-    ljam();
+    jam();
     terrorCode= ZAI_INCONSISTENCY_ERROR;
     return false;
   }
@@ -940,9 +938,9 @@ Dbtup::updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer,
 
   if (newIndex <= inBufLen) {
     if (!nullIndicator) {
-      ljam();
+      jam();
       if (charsetFlag) {
-        ljam();
+        jam();
         Tablerec* regTabPtr = tabptr.p;
 	Uint32 typeId = AttributeDescriptor::getType(attrDescriptor);
         Uint32 bytes = AttributeDescriptor::getSizeInBytes(attrDescriptor);
@@ -954,14 +952,14 @@ Dbtup::updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer,
         const char* ssrc = (const char*)&inBuffer[indexBuf + 1];
         Uint32 lb, len;
         if (! NdbSqlUtil::get_var_length(typeId, ssrc, bytes, lb, len)) {
-          ljam();
+          jam();
           terrorCode = ZINVALID_CHAR_FORMAT;
           return false;
         }
 	// fast fix bug#7340
         if (typeId != NDB_TYPE_TEXT &&
 	    (*cs->cset->well_formed_len)(cs, ssrc + lb, ssrc + lb + len, ZNIL, &not_used) != len) {
-          ljam();
+          jam();
           terrorCode = ZINVALID_CHAR_FORMAT;
           return false;
         }
@@ -973,12 +971,12 @@ Dbtup::updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer,
       
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZNOT_NULL_ATTR;
       return false;
     }
   } else {
-    ljam();
+    jam();
     terrorCode= ZAI_INCONSISTENCY_ERROR;
     return false;
   }
@@ -996,7 +994,7 @@ Dbtup::updateFixedSizeTHManyWordNULLable(Uint32* inBuffer,
   Uint32 *bits= req_struct->m_tuple_ptr->get_null_bits(regTabPtr);
   
   if (!nullIndicator) {
-    ljam();
+    jam();
     BitmaskImpl::clear(regTabPtr->m_offsets[MM].m_null_words, bits, pos);
     return updateFixedSizeTHManyWordNotNULL(inBuffer,
                                             req_struct,
@@ -1005,11 +1003,11 @@ Dbtup::updateFixedSizeTHManyWordNULLable(Uint32* inBuffer,
     Uint32 newIndex= req_struct->in_buf_index + 1;
     if (newIndex <= req_struct->in_buf_len) {
       BitmaskImpl::set(regTabPtr->m_offsets[MM].m_null_words, bits, pos);
-      ljam();
+      jam();
       req_struct->in_buf_index= newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZAI_INCONSISTENCY_ERROR;
       return false;
     }
@@ -1043,7 +1041,7 @@ Dbtup::updateVarSizeNotNULL(Uint32* in_buffer,
   
   if (new_index <= in_buf_len && vsize_in_words <= max_var_size) {
     if (!null_ind) {
-      ljam();
+      jam();
       var_attr_pos= vpos_array[var_index];
       var_data_start= req_struct->m_var_data[MM].m_data_ptr;
       vpos_array[var_index+idx]= var_attr_pos+size_in_bytes;
@@ -1054,12 +1052,12 @@ Dbtup::updateVarSizeNotNULL(Uint32* in_buffer,
 	     size_in_bytes);
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZNOT_NULL_ATTR;
       return false;
     }
   } else {
-    ljam();
+    jam();
     terrorCode= ZAI_INCONSISTENCY_ERROR;
     return false;
   }
@@ -1079,7 +1077,7 @@ Dbtup::updateVarSizeNULLable(Uint32* inBuffer,
   Uint32 idx= req_struct->m_var_data[MM].m_var_len_offset;
   
   if (!nullIndicator) {
-    ljam();
+    jam();
     BitmaskImpl::clear(regTabPtr->m_offsets[MM].m_null_words, bits, pos);
     return updateVarSizeNotNULL(inBuffer,
                                 req_struct,
@@ -1089,13 +1087,13 @@ Dbtup::updateVarSizeNULLable(Uint32* inBuffer,
     Uint32 var_index= AttributeOffset::getOffset(attrDes2);
     Uint32 var_pos= req_struct->var_pos_array[var_index];
     if (newIndex <= req_struct->in_buf_len) {
-      ljam();
+      jam();
       BitmaskImpl::set(regTabPtr->m_offsets[MM].m_null_words, bits, pos);
       req_struct->var_pos_array[var_index+idx]= var_pos;
       req_struct->in_buf_index= newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZAI_INCONSISTENCY_ERROR;
       return false;
     }
@@ -1107,7 +1105,7 @@ Dbtup::updateDynFixedSize(Uint32* inBuffer,
                           KeyReqStruct *req_struct,
                           Uint32  attrDes2)
 {
-  ljam();
+  jam();
   terrorCode= ZVAR_SIZED_NOT_SUPPORTED;
   return false;
 }
@@ -1117,7 +1115,7 @@ Dbtup::updateDynVarSize(Uint32* inBuffer,
                         KeyReqStruct *req_struct,
                         Uint32  attrDes2)
 {
-  ljam();
+  jam();
   terrorCode= ZVAR_SIZED_NOT_SUPPORTED;
   return false;
 }
@@ -1215,7 +1213,7 @@ Dbtup::readBitsNotNULL(Uint32* outBuffer,
   Uint32 maxRead = req_struct->max_read;
   Uint32 *bits= req_struct->m_tuple_ptr->get_null_bits(regTabPtr);
   if (newIndexBuf <= maxRead) {
-    ljam();
+    jam();
     ahOut->setDataSize((bitCount + 31) >> 5);
     req_struct->out_buf_index = newIndexBuf;
     
@@ -1224,7 +1222,7 @@ Dbtup::readBitsNotNULL(Uint32* outBuffer,
     
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }//if
@@ -1248,20 +1246,20 @@ Dbtup::readBitsNULLable(Uint32* outBuffer,
   
   if(BitmaskImpl::get(regTabPtr->m_offsets[MM].m_null_words, bits, pos))
   {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
 
   if (newIndexBuf <= maxRead) {
-    ljam();
+    jam();
     ahOut->setDataSize((bitCount + 31) >> 5);
     req_struct->out_buf_index = newIndexBuf;
     BitmaskImpl::getField(regTabPtr->m_offsets[MM].m_null_words, bits, pos+1, 
 			  bitCount, outBuffer+indexBuf);
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }//if
@@ -1290,12 +1288,12 @@ Dbtup::updateBitsNotNULL(Uint32* inBuffer,
       req_struct->in_buf_index = newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZNOT_NULL_ATTR;
       return false;
     }//if
   } else {
-    ljam();
+    jam();
     terrorCode = ZAI_INCONSISTENCY_ERROR;
     return false;
   }//if
@@ -1328,13 +1326,13 @@ Dbtup::updateBitsNULLable(Uint32* inBuffer,
     Uint32 newIndex = indexBuf + 1;
     if (newIndex <= req_struct->in_buf_len)
     {
-      ljam();
+      jam();
       BitmaskImpl::set(regTabPtr->m_offsets[MM].m_null_words, bits, pos);
       
       req_struct->in_buf_index = newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZAI_INCONSISTENCY_ERROR;
       return false;
     }//if
@@ -1361,9 +1359,9 @@ Dbtup::updateDiskFixedSizeNotNULL(Uint32* inBuffer,
 
   if (newIndex <= inBufLen) {
     if (!nullIndicator) {
-      ljam();
+      jam();
       if (charsetFlag) {
-        ljam();
+        jam();
         Tablerec* regTabPtr = tabptr.p;
 	Uint32 typeId = AttributeDescriptor::getType(attrDescriptor);
         Uint32 bytes = AttributeDescriptor::getSizeInBytes(attrDescriptor);
@@ -1375,14 +1373,14 @@ Dbtup::updateDiskFixedSizeNotNULL(Uint32* inBuffer,
         const char* ssrc = (const char*)&inBuffer[indexBuf + 1];
         Uint32 lb, len;
         if (! NdbSqlUtil::get_var_length(typeId, ssrc, bytes, lb, len)) {
-          ljam();
+          jam();
           terrorCode = ZINVALID_CHAR_FORMAT;
           return false;
         }
 	// fast fix bug#7340
         if (typeId != NDB_TYPE_TEXT &&
 	    (*cs->cset->well_formed_len)(cs, ssrc + lb, ssrc + lb + len, ZNIL, &not_used) != len) {
-          ljam();
+          jam();
           terrorCode = ZINVALID_CHAR_FORMAT;
           return false;
         }
@@ -1393,12 +1391,12 @@ Dbtup::updateDiskFixedSizeNotNULL(Uint32* inBuffer,
                        noOfWords);
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZNOT_NULL_ATTR;
       return false;
     }
   } else {
-    ljam();
+    jam();
     terrorCode= ZAI_INCONSISTENCY_ERROR;
     return false;
   }
@@ -1416,7 +1414,7 @@ Dbtup::updateDiskFixedSizeNULLable(Uint32* inBuffer,
   Uint32 *bits= req_struct->m_disk_ptr->get_null_bits(regTabPtr, DD);
   
   if (!nullIndicator) {
-    ljam();
+    jam();
     BitmaskImpl::clear(regTabPtr->m_offsets[DD].m_null_words, bits, pos);
     return updateDiskFixedSizeNotNULL(inBuffer,
 				      req_struct,
@@ -1425,11 +1423,11 @@ Dbtup::updateDiskFixedSizeNULLable(Uint32* inBuffer,
     Uint32 newIndex= req_struct->in_buf_index + 1;
     if (newIndex <= req_struct->in_buf_len) {
       BitmaskImpl::set(regTabPtr->m_offsets[DD].m_null_words, bits, pos);
-      ljam();
+      jam();
       req_struct->in_buf_index= newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZAI_INCONSISTENCY_ERROR;
       return false;
     }
@@ -1463,7 +1461,7 @@ Dbtup::updateDiskVarSizeNotNULL(Uint32* in_buffer,
   
   if (new_index <= in_buf_len && vsize_in_words <= max_var_size) {
     if (!null_ind) {
-      ljam();
+      jam();
       var_attr_pos= vpos_array[var_index];
       var_data_start= req_struct->m_var_data[DD].m_data_ptr;
       vpos_array[var_index+idx]= var_attr_pos+size_in_bytes;
@@ -1474,12 +1472,12 @@ Dbtup::updateDiskVarSizeNotNULL(Uint32* in_buffer,
 	     size_in_bytes);
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZNOT_NULL_ATTR;
       return false;
     }
   } else {
-    ljam();
+    jam();
     terrorCode= ZAI_INCONSISTENCY_ERROR;
     return false;
   }
@@ -1499,7 +1497,7 @@ Dbtup::updateDiskVarSizeNULLable(Uint32* inBuffer,
   Uint32 idx= req_struct->m_var_data[DD].m_var_len_offset;
   
   if (!nullIndicator) {
-    ljam();
+    jam();
     BitmaskImpl::clear(regTabPtr->m_offsets[DD].m_null_words, bits, pos);
     return updateDiskVarSizeNotNULL(inBuffer,
 				    req_struct,
@@ -1509,13 +1507,13 @@ Dbtup::updateDiskVarSizeNULLable(Uint32* inBuffer,
     Uint32 var_index= AttributeOffset::getOffset(attrDes2);
     Uint32 var_pos= req_struct->var_pos_array[var_index];
     if (newIndex <= req_struct->in_buf_len) {
-      ljam();
+      jam();
       BitmaskImpl::set(regTabPtr->m_offsets[DD].m_null_words, bits, pos);
       req_struct->var_pos_array[var_index+idx]= var_pos;
       req_struct->in_buf_index= newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode= ZAI_INCONSISTENCY_ERROR;
       return false;
     }
@@ -1537,7 +1535,7 @@ Dbtup::readDiskBitsNotNULL(Uint32* outBuffer,
   Uint32 maxRead = req_struct->max_read;
   Uint32 *bits= req_struct->m_disk_ptr->get_null_bits(regTabPtr, DD);
   if (newIndexBuf <= maxRead) {
-    ljam();
+    jam();
     ahOut->setDataSize((bitCount + 31) >> 5);
     req_struct->out_buf_index = newIndexBuf;
     
@@ -1546,7 +1544,7 @@ Dbtup::readDiskBitsNotNULL(Uint32* outBuffer,
     
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }//if
@@ -1570,20 +1568,20 @@ Dbtup::readDiskBitsNULLable(Uint32* outBuffer,
   
   if(BitmaskImpl::get(regTabPtr->m_offsets[DD].m_null_words, bits, pos))
   {
-    ljam();
+    jam();
     ahOut->setNULL();
     return true;
   }
 
   if (newIndexBuf <= maxRead) {
-    ljam();
+    jam();
     ahOut->setDataSize((bitCount + 31) >> 5);
     req_struct->out_buf_index = newIndexBuf;
     BitmaskImpl::getField(regTabPtr->m_offsets[DD].m_null_words, bits, pos+1, 
 			  bitCount, outBuffer+indexBuf);
     return true;
   } else {
-    ljam();
+    jam();
     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
     return false;
   }//if
@@ -1612,12 +1610,12 @@ Dbtup::updateDiskBitsNotNULL(Uint32* inBuffer,
       req_struct->in_buf_index = newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZNOT_NULL_ATTR;
       return false;
     }//if
   } else {
-    ljam();
+    jam();
     terrorCode = ZAI_INCONSISTENCY_ERROR;
     return false;
   }//if
@@ -1650,13 +1648,13 @@ Dbtup::updateDiskBitsNULLable(Uint32* inBuffer,
     Uint32 newIndex = indexBuf + 1;
     if (newIndex <= req_struct->in_buf_len)
     {
-      ljam();
+      jam();
       BitmaskImpl::set(regTabPtr->m_offsets[DD].m_null_words, bits, pos);
       
       req_struct->in_buf_index = newIndex;
       return true;
     } else {
-      ljam();
+      jam();
       terrorCode = ZAI_INCONSISTENCY_ERROR;
       return false;
     }//if
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp
index aad68c5ed17..9026a76d869 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp
@@ -14,6 +14,7 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_SCAN_CPP
 #include "Dbtup.hpp"
 #include <signaldata/AccScan.hpp>
 #include <signaldata/NextScan.hpp>
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp
index b2c42418418..c1ccf5952da 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp
@@ -15,14 +15,12 @@
 
 
 #define DBTUP_C
+#define DBTUP_STORE_PROC_DEF_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 
-#define ljam() { jamLine(18000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(18000 + __LINE__); }
-
 /* ---------------------------------------------------------------- */
 /* ---------------------------------------------------------------- */
 /* ------------ADD/DROP STORED PROCEDURE MODULE ------------------- */
@@ -32,7 +30,7 @@ void Dbtup::execSTORED_PROCREQ(Signal* signal)
 {
   OperationrecPtr regOperPtr;
   TablerecPtr regTabPtr;
-  ljamEntry();
+  jamEntry();
   regOperPtr.i = signal->theData[0];
   c_operation_pool.getPtr(regOperPtr);
   regTabPtr.i = signal->theData[1];
@@ -46,17 +44,17 @@ void Dbtup::execSTORED_PROCREQ(Signal* signal)
   ndbrequire(regTabPtr.p->tableStatus == DEFINED);
   switch (requestInfo) {
   case ZSCAN_PROCEDURE:
-    ljam();
+    jam();
     scanProcedure(signal,
                   regOperPtr.p,
                   signal->theData[4]);
     break;
   case ZCOPY_PROCEDURE:
-    ljam();
+    jam();
     copyProcedure(signal, regTabPtr, regOperPtr.p);
     break;
   case ZSTORED_PROCEDURE_DELETE:
-    ljam();
+    jam();
     deleteScanProcedure(signal, regOperPtr.p);
     break;
   default:
@@ -124,14 +122,14 @@ void Dbtup::copyProcedure(Signal* signal,
     AttributeHeader::init(&signal->theData[length + 1], Ti, 0);
     length++;
     if (length == 24) {
-      ljam();
+      jam();
       ndbrequire(storedProcedureAttrInfo(signal, regOperPtr, 
 					 signal->theData+1, length, true));
       length = 0;
     }//if
   }//for
   if (length != 0) {
-    ljam();
+    jam();
     ndbrequire(storedProcedureAttrInfo(signal, regOperPtr, 
 				       signal->theData+1, length, true));
   }//if
@@ -155,7 +153,7 @@ bool Dbtup::storedProcedureAttrInfo(Signal* signal,
   ndbrequire(regOperPtr->currentAttrinbufLen <= regOperPtr->attrinbufLen);
   if ((RnoFree > MIN_ATTRBUF) ||
       (copyProcedure)) {
-    ljam();
+    jam();
     regAttrPtr.i = cfirstfreeAttrbufrec;
     ptrCheckGuard(regAttrPtr, cnoOfAttrbufrec, attrbufrec);
     regAttrPtr.p->attrbuf[ZBUF_DATA_LEN] = 0;
@@ -163,18 +161,18 @@ bool Dbtup::storedProcedureAttrInfo(Signal* signal,
     cnoFreeAttrbufrec = RnoFree - 1;
     regAttrPtr.p->attrbuf[ZBUF_NEXT] = RNIL;
   } else {
-    ljam();
+    jam();
     storedSeizeAttrinbufrecErrorLab(signal, regOperPtr);
     return false;
   }//if
   if (regOperPtr->firstAttrinbufrec == RNIL) {
-    ljam();
+    jam();
     regOperPtr->firstAttrinbufrec = regAttrPtr.i;
   }//if
   regAttrPtr.p->attrbuf[ZBUF_NEXT] = RNIL;
   if (regOperPtr->lastAttrinbufrec != RNIL) {
     AttrbufrecPtr tempAttrinbufptr;
-    ljam();
+    jam();
     tempAttrinbufptr.i = regOperPtr->lastAttrinbufrec;  
     ptrCheckGuard(tempAttrinbufptr, cnoOfAttrbufrec, attrbufrec);
     tempAttrinbufptr.p->attrbuf[ZBUF_NEXT] = regAttrPtr.i;
@@ -187,7 +185,7 @@ bool Dbtup::storedProcedureAttrInfo(Signal* signal,
                    length);
 
   if (regOperPtr->currentAttrinbufLen < regOperPtr->attrinbufLen) {
-    ljam();
+    jam();
     return true;
   }//if
   if (ERROR_INSERTED(4005) && !copyProcedure) {
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp
index b85a2a8394d..6406bdefe1e 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp
@@ -15,14 +15,12 @@
 
 
 #define DBTUP_C
+#define DBTUP_TAB_DES_MAN_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
 #include <pc.hpp>
 
-#define ljam() { jamLine(22000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(22000 + __LINE__); }
-
 /*
  * TABLE DESCRIPTOR MEMORY MANAGER
  *
@@ -65,30 +63,30 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset)
   allocSize = (((allocSize - 1) >> 4) + 1) << 4;
   Uint32 list = nextHigherTwoLog(allocSize - 1);	/* CALCULATE WHICH LIST IT BELONGS TO     */
   for (Uint32 i = list; i < 16; i++) {
-    ljam();
+    jam();
     if (cfreeTdList[i] != RNIL) {
-      ljam();
+      jam();
       reference = cfreeTdList[i];
       removeTdArea(reference, i);	                /* REMOVE THE AREA FROM THE FREELIST      */
       Uint32 retNo = (1 << i) - allocSize;	        /* CALCULATE THE DIFFERENCE               */
       if (retNo >= ZTD_FREE_SIZE) {
-        ljam();
+        jam();
         // return unused words, of course without attempting left merge
         Uint32 retRef = reference + allocSize;
         freeTabDescr(retRef, retNo, false);
       } else {
-        ljam();
+        jam();
         allocSize = 1 << i;
       }//if
       break;
     }//if
   }//for
   if (reference == RNIL) {
-    ljam();
+    jam();
     terrorCode = ZMEM_NOTABDESCR_ERROR;
     return RNIL;
   } else {
-    ljam();
+    jam();
     setTabDescrWord((reference + allocSize) - ZTD_TR_TYPE, ZTD_TYPE_NORMAL);
     setTabDescrWord(reference + ZTD_DATASIZE, allocSize);
 
@@ -105,7 +103,7 @@ void Dbtup::freeTabDescr(Uint32 retRef, Uint32 retNo, bool normal)
 {
   itdaMergeTabDescr(retRef, retNo, normal);       /* MERGE WITH POSSIBLE NEIGHBOURS   */
   while (retNo >= ZTD_FREE_SIZE) {
-    ljam();
+    jam();
     Uint32 list = nextHigherTwoLog(retNo);
     list--;	/* RETURN TO NEXT LOWER LIST    */
     Uint32 sizeOfChunk = 1 << list;
@@ -136,7 +134,7 @@ void Dbtup::insertTdArea(Uint32 tabDesRef, Uint32 list)
   setTabDescrWord(tabDesRef + ZTD_FL_HEADER, ZTD_TYPE_FREE);
   setTabDescrWord(tabDesRef + ZTD_FL_NEXT, cfreeTdList[list]);
   if (cfreeTdList[list] != RNIL) {
-    ljam();                                                /* PREVIOUSLY EMPTY SLOT     */
+    jam();                                                /* PREVIOUSLY EMPTY SLOT     */
     setTabDescrWord(cfreeTdList[list] + ZTD_FL_PREV, tabDesRef);
   }//if
   cfreeTdList[list] = tabDesRef;	/* RELINK THE LIST           */
@@ -156,28 +154,28 @@ void Dbtup::itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal)
 {
   // merge right
   while ((retRef + retNo) < cnoOfTabDescrRec) {
-    ljam();
+    jam();
     Uint32 tabDesRef = retRef + retNo;
     Uint32 headerWord = getTabDescrWord(tabDesRef + ZTD_FL_HEADER);
     if (headerWord == ZTD_TYPE_FREE) {
-      ljam();
+      jam();
       Uint32 sizeOfMergedPart = getTabDescrWord(tabDesRef + ZTD_FL_SIZE);
 
       retNo += sizeOfMergedPart;
       Uint32 list = nextHigherTwoLog(sizeOfMergedPart - 1);
       removeTdArea(tabDesRef, list);
     } else {
-      ljam();
+      jam();
       break;
     }
   }
   // merge left
   const bool mergeLeft = normal;
   while (mergeLeft && retRef > 0) {
-    ljam();
+    jam();
     Uint32 trailerWord = getTabDescrWord(retRef - ZTD_TR_TYPE);
     if (trailerWord == ZTD_TYPE_FREE) {
-      ljam();
+      jam();
       Uint32 sizeOfMergedPart = getTabDescrWord(retRef - ZTD_TR_SIZE);
       ndbrequire(retRef >= sizeOfMergedPart);
       retRef -= sizeOfMergedPart;
@@ -185,7 +183,7 @@ void Dbtup::itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal)
       Uint32 list = nextHigherTwoLog(sizeOfMergedPart - 1);
       removeTdArea(retRef, list);
     } else {
-      ljam();
+      jam();
       break;
     }
   }
@@ -213,15 +211,15 @@ void Dbtup::removeTdArea(Uint32 tabDesRef, Uint32 list)
   setTabDescrWord((tabDesRef + (1 << list)) - ZTD_TR_TYPE, ZTD_TYPE_NORMAL);
 
   if (tabDesRef == cfreeTdList[list]) {
-    ljam();
+    jam();
     cfreeTdList[list] = tabDescrNextPtr;	/* RELINK THE LIST           */
   }//if
   if (tabDescrNextPtr != RNIL) {
-    ljam();
+    jam();
     setTabDescrWord(tabDescrNextPtr + ZTD_FL_PREV, tabDescrPrevPtr);
   }//if
   if (tabDescrPrevPtr != RNIL) {
-    ljam();
+    jam();
     setTabDescrWord(tabDescrPrevPtr + ZTD_FL_NEXT, tabDescrNextPtr);
   }//if
 }//Dbtup::removeTdArea()
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
index 9615047540b..0c6a1491543 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
@@ -15,6 +15,7 @@
 
 
 #define DBTUP_C
+#define DBTUP_TRIGGER_CPP
 #include "Dbtup.hpp"
 #include <RefConvert.hpp>
 #include <ndb_limits.h>
@@ -26,9 +27,6 @@
 #include <signaldata/CreateTrig.hpp>
 #include <signaldata/TuxMaint.hpp>
 
-#define ljam() { jamLine(7000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(7000 + __LINE__); }
-
 /* **************************************************************** */
 /* ---------------------------------------------------------------- */
 /* ----------------------- TRIGGER HANDLING ----------------------- */
@@ -47,17 +45,17 @@ Dbtup::findTriggerList(Tablerec* table,
   case TriggerType::SUBSCRIPTION_BEFORE:
     switch (tevent) {
     case TriggerEvent::TE_INSERT:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_DETACHED)
         tlist = &table->subscriptionInsertTriggers;
       break;
     case TriggerEvent::TE_UPDATE:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_DETACHED)
         tlist = &table->subscriptionUpdateTriggers;
       break;
     case TriggerEvent::TE_DELETE:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_DETACHED)
         tlist = &table->subscriptionDeleteTriggers;
       break;
@@ -68,17 +66,17 @@ Dbtup::findTriggerList(Tablerec* table,
   case TriggerType::SECONDARY_INDEX:
     switch (tevent) {
     case TriggerEvent::TE_INSERT:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_AFTER)
         tlist = &table->afterInsertTriggers;
       break;
     case TriggerEvent::TE_UPDATE:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_AFTER)
         tlist = &table->afterUpdateTriggers;
       break;
     case TriggerEvent::TE_DELETE:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_AFTER)
         tlist = &table->afterDeleteTriggers;
       break;
@@ -89,7 +87,7 @@ Dbtup::findTriggerList(Tablerec* table,
   case TriggerType::ORDERED_INDEX:
     switch (tevent) {
     case TriggerEvent::TE_CUSTOM:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_CUSTOM)
         tlist = &table->tuxCustomTriggers;
       break;
@@ -100,7 +98,7 @@ Dbtup::findTriggerList(Tablerec* table,
   case TriggerType::READ_ONLY_CONSTRAINT:
     switch (tevent) {
     case TriggerEvent::TE_UPDATE:
-      ljam();
+      jam();
       if (ttime == TriggerActionTime::TA_AFTER)
         tlist = &table->constraintUpdateTriggers;
       break;
@@ -118,7 +116,7 @@ Dbtup::findTriggerList(Tablerec* table,
 void
 Dbtup::execCREATE_TRIG_REQ(Signal* signal)
 {
-  ljamEntry();
+  jamEntry();
   BlockReference senderRef = signal->getSendersBlockRef();
   const CreateTrigReq reqCopy = *(const CreateTrigReq*)signal->getDataPtr();
   const CreateTrigReq* const req = &reqCopy;
@@ -131,13 +129,13 @@ Dbtup::execCREATE_TRIG_REQ(Signal* signal)
 
   if (tabPtr.p->tableStatus != DEFINED )
   {
-    ljam();
+    jam();
     error= CreateTrigRef::InvalidTable;
   }
   // Create trigger and associate it with the table
   else if (createTrigger(tabPtr.p, req))
   {
-    ljam();
+    jam();
     // Send conf
     CreateTrigConf* const conf = (CreateTrigConf*)signal->getDataPtrSend();
     conf->setUserRef(reference());
@@ -153,7 +151,7 @@ Dbtup::execCREATE_TRIG_REQ(Signal* signal)
   }
   else
   {
-    ljam();
+    jam();
     error= CreateTrigRef::TooManyTriggers;
   }
   ndbassert(error != CreateTrigRef::NoError);
@@ -174,7 +172,7 @@ Dbtup::execCREATE_TRIG_REQ(Signal* signal)
 void
 Dbtup::execDROP_TRIG_REQ(Signal* signal)
 {
-  ljamEntry();
+  jamEntry();
   BlockReference senderRef = signal->getSendersBlockRef();
   const DropTrigReq reqCopy = *(const DropTrigReq*)signal->getDataPtr();
   const DropTrigReq* const req = &reqCopy;
@@ -262,7 +260,7 @@ Dbtup::createTrigger(Tablerec* table, const CreateTrigReq* req)
   if ((tptr.p->triggerType == TriggerType::SUBSCRIPTION) &&
       ((tptr.p->triggerEvent == TriggerEvent::TE_UPDATE) ||
        (tptr.p->triggerEvent == TriggerEvent::TE_DELETE))) {
-    ljam();
+    jam();
     tptr.p->sendBeforeValues = false;
   }
   /*
@@ -270,7 +268,7 @@ Dbtup::createTrigger(Tablerec* table, const CreateTrigReq* req)
   if (((tptr.p->triggerType == TriggerType::SUBSCRIPTION) ||
       (tptr.p->triggerType == TriggerType::SUBSCRIPTION_BEFORE)) &&
       (tptr.p->triggerEvent == TriggerEvent::TE_UPDATE)) {
-    ljam();
+    jam();
     tptr.p->sendOnlyChangedAttributes = true;
   }
   */
@@ -282,16 +280,16 @@ Dbtup::createTrigger(Tablerec* table, const CreateTrigReq* req)
 
   tptr.p->attributeMask.clear();
   if (tptr.p->monitorAllAttributes) {
-    ljam();
+    jam();
     for(Uint32 i = 0; i < table->m_no_of_attributes; i++) {
       if (!primaryKey(table, i)) {
-        ljam();
+        jam();
         tptr.p->attributeMask.set(i);
       }
     }
   } else {
     // Set attribute mask
-    ljam();
+    jam();
     tptr.p->attributeMask = req->getAttributeMask();
   }
   return true;
@@ -336,7 +334,7 @@ Dbtup::dropTrigger(Tablerec* table, const DropTrigReq* req, BlockNumber sender)
 
   Ptr<TupTriggerData> ptr;
   for (tlist->first(ptr); !ptr.isNull(); tlist->next(ptr)) {
-    ljam();
+    jam();
     if (ptr.p->triggerId == triggerId) {
       if(ttype==TriggerType::SUBSCRIPTION && sender != ptr.p->m_receiverBlock)
       {
@@ -348,10 +346,10 @@ Dbtup::dropTrigger(Tablerec* table, const DropTrigReq* req, BlockNumber sender)
 	 *
 	 * Backup doesn't really care about the Ids though.
 	 */
-	ljam();
+	jam();
 	continue;
       }
-      ljam();
+      jam();
       tlist->release(ptr.i);
       return 0;
     }
@@ -379,7 +377,7 @@ Dbtup::checkImmediateTriggersAfterInsert(KeyReqStruct *req_struct,
 
   if ((regOperPtr->op_struct.primary_replica) &&
       (!(regTablePtr->afterInsertTriggers.isEmpty()))) {
-    ljam();
+    jam();
     fireImmediateTriggers(req_struct,
                           regTablePtr->afterInsertTriggers,
                           regOperPtr);
@@ -397,14 +395,14 @@ Dbtup::checkImmediateTriggersAfterUpdate(KeyReqStruct *req_struct,
 
   if ((regOperPtr->op_struct.primary_replica) &&
       (!(regTablePtr->afterUpdateTriggers.isEmpty()))) {
-    ljam();
+    jam();
     fireImmediateTriggers(req_struct,
                           regTablePtr->afterUpdateTriggers,
                           regOperPtr);
   }
   if ((regOperPtr->op_struct.primary_replica) &&
       (!(regTablePtr->constraintUpdateTriggers.isEmpty()))) {
-    ljam();
+    jam();
     fireImmediateTriggers(req_struct,
                           regTablePtr->constraintUpdateTriggers,
                           regOperPtr);
@@ -422,7 +420,7 @@ Dbtup::checkImmediateTriggersAfterDelete(KeyReqStruct *req_struct,
 
   if ((regOperPtr->op_struct.primary_replica) &&
       (!(regTablePtr->afterDeleteTriggers.isEmpty()))) {
-    ljam();
+    jam();
     executeTriggers(req_struct,
                     regTablePtr->afterDeleteTriggers,
                     regOperPtr);
@@ -443,7 +441,7 @@ void Dbtup::checkDeferredTriggers(Signal* signal,
                                   Operationrec* const regOperPtr,
                                   Tablerec* const regTablePtr)
 {
-  ljam();
+  jam();
   // NYI
 }//Dbtup::checkDeferredTriggers()
 #endif
@@ -479,7 +477,7 @@ void Dbtup::checkDetachedTriggers(KeyReqStruct *req_struct,
   if (save_ptr->m_header_bits & Tuple_header::ALLOC) {
     if (save_type == ZDELETE) {
       // insert + delete = nothing
-      ljam();
+      jam();
       return;
       goto end;
     }
@@ -495,10 +493,10 @@ void Dbtup::checkDetachedTriggers(KeyReqStruct *req_struct,
   
   switch(regOperPtr->op_struct.op_type) {
   case(ZINSERT):
-    ljam();
+    jam();
     if (regTablePtr->subscriptionInsertTriggers.isEmpty()) {
       // Table has no active triggers monitoring inserts at commit
-      ljam();
+      jam();
       goto end;
     }
 
@@ -508,10 +506,10 @@ void Dbtup::checkDetachedTriggers(KeyReqStruct *req_struct,
                          regOperPtr);
     break;
   case(ZDELETE):
-    ljam();
+    jam();
     if (regTablePtr->subscriptionDeleteTriggers.isEmpty()) {
       // Table has no active triggers monitoring deletes at commit
-      ljam();
+      jam();
       goto end;
     }
 
@@ -522,10 +520,10 @@ void Dbtup::checkDetachedTriggers(KeyReqStruct *req_struct,
 			 regOperPtr);
     break;
   case(ZUPDATE):
-    ljam();
+    jam();
     if (regTablePtr->subscriptionUpdateTriggers.isEmpty()) {
       // Table has no active triggers monitoring updates at commit
-      ljam();
+      jam();
       goto end;
     }
 
@@ -553,10 +551,10 @@ Dbtup::fireImmediateTriggers(KeyReqStruct *req_struct,
   TriggerPtr trigPtr;
   triggerList.first(trigPtr);
   while (trigPtr.i != RNIL) {
-    ljam();
+    jam();
     if (trigPtr.p->monitorAllAttributes ||
         trigPtr.p->attributeMask.overlaps(req_struct->changeMask)) {
-      ljam();
+      jam();
       executeTrigger(req_struct,
                      trigPtr.p,
                      regOperPtr);
@@ -575,10 +573,10 @@ Dbtup::fireDeferredTriggers(Signal* signal,
   TriggerPtr trigPtr;
   triggerList.first(trigPtr);
   while (trigPtr.i != RNIL) {
-    ljam();
+    jam();
     if (trigPtr.p->monitorAllAttributes ||
         trigPtr.p->attributeMask.overlaps(req_struct->changeMask)) {
-      ljam();
+      jam();
       executeTrigger(req_struct,
                      trigPtr,
                      regOperPtr);
@@ -604,12 +602,12 @@ Dbtup::fireDetachedTriggers(KeyReqStruct *req_struct,
   ndbrequire(regOperPtr->is_first_operation());
   triggerList.first(trigPtr);
   while (trigPtr.i != RNIL) {
-    ljam();
+    jam();
     if ((trigPtr.p->monitorReplicas ||
          regOperPtr->op_struct.primary_replica) &&
         (trigPtr.p->monitorAllAttributes ||
          trigPtr.p->attributeMask.overlaps(req_struct->changeMask))) {
-      ljam();
+      jam();
       executeTrigger(req_struct,
                      trigPtr.p,
                      regOperPtr);
@@ -625,7 +623,7 @@ void Dbtup::executeTriggers(KeyReqStruct *req_struct,
   TriggerPtr trigPtr;
   triggerList.first(trigPtr);
   while (trigPtr.i != RNIL) {
-    ljam();
+    jam();
     executeTrigger(req_struct,
                    trigPtr.p,
                    regOperPtr);
@@ -675,7 +673,7 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct,
   ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
 
   if (ref == BACKUP) {
-    ljam();
+    jam();
     /*
     In order for the implementation of BACKUP to work even when changing
     primaries in the middle of the backup we need to set the trigger on
@@ -688,9 +686,9 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct,
     signal->theData[0] = trigPtr->triggerId;
     signal->theData[1] = regFragPtr.p->fragmentId;
     EXECUTE_DIRECT(BACKUP, GSN_BACKUP_TRIG_REQ, signal, 2);
-    ljamEntry();
+    jamEntry();
     if (signal->theData[0] == 0) {
-      ljam();
+      jam();
       return;
     }
   }
@@ -704,7 +702,7 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct,
                        noAfterWords,
                        beforeBuffer,
                        noBeforeWords)) {
-    ljam();
+    jam();
     return;
   }
 //--------------------------------------------------------------------
@@ -720,13 +718,13 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct,
 
   switch(trigPtr->triggerType) {
   case (TriggerType::SECONDARY_INDEX):
-    ljam();
+    jam();
     ref = req_struct->TC_ref;
     executeDirect = false;
     break;
   case (TriggerType::SUBSCRIPTION):
   case (TriggerType::SUBSCRIPTION_BEFORE):
-    ljam();
+    jam();
     // Since only backup uses subscription triggers we send to backup directly for now
     ref = trigPtr->m_receiverBlock;
     executeDirect = true;
@@ -747,22 +745,22 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct,
 
   switch(regOperPtr->op_struct.op_type) {
   case(ZINSERT):
-    ljam();
+    jam();
     // Send AttrInfo signals with new attribute values
     trigAttrInfo->setAttrInfoType(TrigAttrInfo::AFTER_VALUES);
     sendTrigAttrInfo(signal, afterBuffer, noAfterWords, executeDirect, ref);
     break;
   case(ZDELETE):
     if (trigPtr->sendBeforeValues) {
-      ljam();
+      jam();
       trigAttrInfo->setAttrInfoType(TrigAttrInfo::BEFORE_VALUES);
       sendTrigAttrInfo(signal, beforeBuffer, noBeforeWords, executeDirect,ref);
     }
     break;
   case(ZUPDATE):
-    ljam();
+    jam();
     if (trigPtr->sendBeforeValues) {
-      ljam();
+      jam();
       trigAttrInfo->setAttrInfoType(TrigAttrInfo::BEFORE_VALUES);
       sendTrigAttrInfo(signal, beforeBuffer, noBeforeWords, executeDirect,ref);
     }
@@ -788,9 +786,9 @@ Uint32 Dbtup::setAttrIds(Bitmask<MAXNROFATTRIBUTESINWORDS>& attributeMask,
 {
   Uint32 bufIndx = 0;
   for (Uint32 i = 0; i < m_no_of_attributesibutes; i++) {
-    ljam();
+    jam();
     if (attributeMask.get(i)) {
-      ljam();
+      jam();
       AttributeHeader::init(&inBuffer[bufIndx++], i, 0);
     }
   }
@@ -858,7 +856,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
   Uint32 numAttrsToRead;
   if ((regOperPtr->op_struct.op_type == ZUPDATE) &&
       (trigPtr->sendOnlyChangedAttributes)) {
-    ljam();
+    jam();
 //--------------------------------------------------------------------
 // Update that sends only changed information
 //--------------------------------------------------------------------
@@ -870,13 +868,13 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
     
   } else if ((regOperPtr->op_struct.op_type == ZDELETE) &&
              (!trigPtr->sendBeforeValues)) {
-    ljam();
+    jam();
 //--------------------------------------------------------------------
 // Delete without sending before values only read Primary Key
 //--------------------------------------------------------------------
     return true;
   } else {
-    ljam();
+    jam();
 //--------------------------------------------------------------------
 // All others send all attributes that are monitored, except:
 // Omit unchanged blob inlines on update i.e.
@@ -898,7 +896,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
 //--------------------------------------------------------------------
   if (regOperPtr->op_struct.op_type != ZDELETE)
   {
-    ljam();
+    jam();
     int ret = readAttributes(req_struct,
 			     &readBuffer[0],
 			     numAttrsToRead,
@@ -908,7 +906,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
     ndbrequire(ret != -1);
     noAfterWords= ret;
   } else {
-    ljam();
+    jam();
     noAfterWords = 0;
   }
 
@@ -920,7 +918,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
   if ((regOperPtr->op_struct.op_type == ZUPDATE || 
        regOperPtr->op_struct.op_type == ZDELETE) &&
       (trigPtr->sendBeforeValues)) {
-    ljam();
+    jam();
     
     Tuple_header *save= req_struct->m_tuple_ptr;
     PagePtr tmp;
@@ -956,7 +954,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
 // Although a trigger was fired it was not necessary since the old
 // value and the new value was exactly the same
 //--------------------------------------------------------------------
-      ljam();
+      jam();
       //XXX does this work with collations?
       return false;
     }
@@ -976,21 +974,21 @@ void Dbtup::sendTrigAttrInfo(Signal* signal,
   do {
     sigLen = dataLen - dataIndex;
     if (sigLen > TrigAttrInfo::DataLength) {
-      ljam();
+      jam();
       sigLen = TrigAttrInfo::DataLength;
     }
     MEMCOPY_NO_WORDS(trigAttrInfo->getData(), 
                      data + dataIndex,
                      sigLen);
     if (executeDirect) {
-      ljam();
+      jam();
       EXECUTE_DIRECT(receiverReference, 
                      GSN_TRIG_ATTRINFO,
                      signal,
 		     TrigAttrInfo::StaticLength + sigLen);
-      ljamEntry();
+      jamEntry();
     } else {
-      ljam();
+      jam();
       sendSignal(receiverReference, 
                  GSN_TRIG_ATTRINFO, 
                  signal, 
@@ -1018,15 +1016,15 @@ void Dbtup::sendFireTrigOrd(Signal* signal,
 
   switch(regOperPtr->op_struct.op_type) {
   case(ZINSERT):
-    ljam();
+    jam();
     fireTrigOrd->setTriggerEvent(TriggerEvent::TE_INSERT);
     break;
   case(ZDELETE):
-    ljam();
+    jam();
     fireTrigOrd->setTriggerEvent(TriggerEvent::TE_DELETE);
     break;
   case(ZUPDATE):
-    ljam();
+    jam();
     fireTrigOrd->setTriggerEvent(TriggerEvent::TE_UPDATE);
     break;
   default:
@@ -1040,12 +1038,12 @@ void Dbtup::sendFireTrigOrd(Signal* signal,
 
   switch(trigPtr->triggerType) {
   case (TriggerType::SECONDARY_INDEX):
-    ljam();
+    jam();
     sendSignal(req_struct->TC_ref, GSN_FIRE_TRIG_ORD, 
                signal, FireTrigOrd::SignalLength, JBB);
     break;
   case (TriggerType::SUBSCRIPTION_BEFORE): // Only Suma
-    ljam();
+    jam();
     // Since only backup uses subscription triggers we 
     // send to backup directly for now
     fireTrigOrd->setGCI(req_struct->gci);
@@ -1056,7 +1054,7 @@ void Dbtup::sendFireTrigOrd(Signal* signal,
 		   FireTrigOrd::SignalWithHashValueLength);
     break;
   case (TriggerType::SUBSCRIPTION):
-    ljam();
+    jam();
     // Since only backup uses subscription triggers we 
     // send to backup directly for now
     fireTrigOrd->setGCI(req_struct->gci);
@@ -1123,7 +1121,7 @@ Dbtup::addTuxEntries(Signal* signal,
                      Tablerec* regTabPtr)
 {
   if (ERROR_INSERTED(4022)) {
-    ljam();
+    jam();
     CLEAR_ERROR_INSERT_VALUE;
     terrorCode = 9999;
     return -1;
@@ -1134,12 +1132,12 @@ Dbtup::addTuxEntries(Signal* signal,
   Uint32 failPtrI;
   triggerList.first(triggerPtr);
   while (triggerPtr.i != RNIL) {
-    ljam();
+    jam();
     req->indexId = triggerPtr.p->indexId;
     req->errorCode = RNIL;
     if (ERROR_INSERTED(4023) &&
         ! triggerList.hasNext(triggerPtr)) {
-      ljam();
+      jam();
       CLEAR_ERROR_INSERT_VALUE;
       terrorCode = 9999;
       failPtrI = triggerPtr.i;
@@ -1147,9 +1145,9 @@ Dbtup::addTuxEntries(Signal* signal,
     }
     EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
         signal, TuxMaintReq::SignalLength);
-    ljamEntry();
+    jamEntry();
     if (req->errorCode != 0) {
-      ljam();
+      jam();
       terrorCode = req->errorCode;
       failPtrI = triggerPtr.i;
       goto fail;
@@ -1161,12 +1159,12 @@ fail:
   req->opInfo = TuxMaintReq::OpRemove;
   triggerList.first(triggerPtr);
   while (triggerPtr.i != failPtrI) {
-    ljam();
+    jam();
     req->indexId = triggerPtr.p->indexId;
     req->errorCode = RNIL;
     EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
         signal, TuxMaintReq::SignalLength);
-    ljamEntry();
+    jamEntry();
     ndbrequire(req->errorCode == 0);
     triggerList.next(triggerPtr);
   }
@@ -1197,15 +1195,15 @@ Dbtup::executeTuxCommitTriggers(Signal* signal,
   if (regOperPtr->op_struct.op_type == ZINSERT) {
     if (! regOperPtr->op_struct.delete_insert_flag)
       return;
-    ljam();
+    jam();
     tupVersion= decr_tup_version(regOperPtr->tupVersion);
   } else if (regOperPtr->op_struct.op_type == ZUPDATE) {
-    ljam();
+    jam();
     tupVersion= decr_tup_version(regOperPtr->tupVersion);
   } else if (regOperPtr->op_struct.op_type == ZDELETE) {
     if (regOperPtr->op_struct.delete_insert_flag)
       return;
-    ljam();
+    jam();
     tupVersion= regOperPtr->tupVersion;
   } else {
     ndbrequire(false);
@@ -1231,13 +1229,13 @@ Dbtup::executeTuxAbortTriggers(Signal* signal,
   // get version
   Uint32 tupVersion;
   if (regOperPtr->op_struct.op_type == ZINSERT) {
-    ljam();
+    jam();
     tupVersion = regOperPtr->tupVersion;
   } else if (regOperPtr->op_struct.op_type == ZUPDATE) {
-    ljam();
+    jam();
     tupVersion = regOperPtr->tupVersion;
   } else if (regOperPtr->op_struct.op_type == ZDELETE) {
-    ljam();
+    jam();
     return;
   } else {
     ndbrequire(false);
@@ -1262,12 +1260,12 @@ Dbtup::removeTuxEntries(Signal* signal,
   TriggerPtr triggerPtr;
   triggerList.first(triggerPtr);
   while (triggerPtr.i != RNIL) {
-    ljam();
+    jam();
     req->indexId = triggerPtr.p->indexId;
     req->errorCode = RNIL,
     EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
         signal, TuxMaintReq::SignalLength);
-    ljamEntry();
+    jamEntry();
     // must succeed
     ndbrequire(req->errorCode == 0);
     triggerList.next(triggerPtr);
diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp
index 072bd69da97..763bbaf9906 100644
--- a/storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp
+++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp
@@ -14,12 +14,9 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 #define DBTUP_C
+#define DBTUP_VAR_ALLOC_CPP
 #include "Dbtup.hpp"
 
-#define ljam() { jamLine(32000 + __LINE__); }
-#define ljamEntry() { jamEntryLine(32000 + __LINE__); }
-
-
 void Dbtup::init_list_sizes(void)
 {
   c_min_list_size[0]= 200;
@@ -109,9 +106,9 @@ Dbtup::alloc_var_part(Fragrecord* fragPtr,
   PagePtr pagePtr;
   pagePtr.i= get_alloc_page(fragPtr, (alloc_size + 1));
   if (pagePtr.i == RNIL) { 
-    ljam();
+    jam();
     if ((pagePtr.i= get_empty_var_page(fragPtr)) == RNIL) {
-      ljam();
+      jam();
       return 0;
     }
     c_page_pool.getPtr(pagePtr);
@@ -127,7 +124,7 @@ Dbtup::alloc_var_part(Fragrecord* fragPtr,
     pagePtr.p->page_state = ZTH_MM_FREE;
   } else {
     c_page_pool.getPtr(pagePtr);
-    ljam();
+    jam();
   }
   Uint32 idx= ((Var_page*)pagePtr.p)
     ->alloc_record(alloc_size, (Var_page*)ctemp_page, Var_page::CHAIN);
@@ -177,7 +174,7 @@ void Dbtup::free_var_rec(Fragrecord* fragPtr,
   ndbassert(pagePtr.p->free_space <= Var_page::DATA_WORDS);
   if (pagePtr.p->free_space == Var_page::DATA_WORDS - 1)
   {
-    ljam();
+    jam();
     /*
       This code could be used when we release pages.
       remove_free_page(signal,fragPtr,page_header,page_header->list_index);
@@ -185,7 +182,7 @@ void Dbtup::free_var_rec(Fragrecord* fragPtr,
     */
     update_free_page_list(fragPtr, pagePtr);
   } else {
-    ljam();
+    jam();
     update_free_page_list(fragPtr, pagePtr);
   }
   return;
@@ -259,16 +256,16 @@ Dbtup::get_alloc_page(Fragrecord* fragPtr, Uint32 alloc_size)
   
   start_index= calculate_free_list_impl(alloc_size);
   if (start_index == (MAX_FREE_LIST - 1)) {
-    ljam();
+    jam();
   } else {
-    ljam();
+    jam();
     ndbrequire(start_index < (MAX_FREE_LIST - 1));
     start_index++;
   }
   for (i= start_index; i < MAX_FREE_LIST; i++) {
-    ljam();
+    jam();
     if (!fragPtr->free_var_page_array[i].isEmpty()) {
-      ljam();
+      jam();
       return fragPtr->free_var_page_array[i].firstItem;
     }
   }
@@ -277,9 +274,9 @@ Dbtup::get_alloc_page(Fragrecord* fragPtr, Uint32 alloc_size)
   LocalDLList<Page> list(c_page_pool, fragPtr->free_var_page_array[i]);
   for(list.first(pagePtr); !pagePtr.isNull() && loop < 16; )
   {
-    ljam();
+    jam();
     if (pagePtr.p->free_space >= alloc_size) {
-      ljam();
+      jam();
       return pagePtr.i;
     }
     loop++;
@@ -346,7 +343,7 @@ void Dbtup::update_free_page_list(Fragrecord* fragPtr,
       (free_space > c_max_list_size[list_index])) {
     Uint32 new_list_index= calculate_free_list_impl(free_space);
     if (list_index != MAX_FREE_LIST) {
-      ljam();
+      jam();
       /*
        * Only remove it from its list if it is in a list
        */
@@ -361,11 +358,11 @@ void Dbtup::update_free_page_list(Fragrecord* fragPtr,
 	This can only happen for the free list with least guaranteed 
 	free space.
       */
-      ljam();
+      jam();
       ndbrequire(new_list_index == 0);
       pagePtr.p->list_index= MAX_FREE_LIST;
     } else {
-      ljam();
+      jam();
       LocalDLList<Page> list(c_page_pool, 
 			     fragPtr->free_var_page_array[new_list_index]);
       list.add(pagePtr);
@@ -381,9 +378,9 @@ Uint32 Dbtup::calculate_free_list_impl(Uint32 free_space_size) const
 {
   Uint32 i;
   for (i = 0; i < MAX_FREE_LIST; i++) {
-    ljam();
+    jam();
     if (free_space_size <= c_max_list_size[i]) {
-      ljam();
+      jam();
       return i;
     }
   }
diff --git a/storage/ndb/src/kernel/blocks/lgman.cpp b/storage/ndb/src/kernel/blocks/lgman.cpp
index 90c72fe7010..82fed94f62e 100644
--- a/storage/ndb/src/kernel/blocks/lgman.cpp
+++ b/storage/ndb/src/kernel/blocks/lgman.cpp
@@ -2918,6 +2918,25 @@ Lgman::stop_run_undo_log(Signal* signal)
       ptr.p->m_file_pos[TAIL] = tail;
 
       init_logbuffer_pointers(ptr);
+
+      {
+	Buffer_idx head= ptr.p->m_file_pos[HEAD];
+	Ptr<Undofile> file;
+	m_file_pool.getPtr(file, head.m_ptr_i);
+	if (head.m_idx == file.p->m_file_size - 1)
+	{
+	  Local_undofile_list files(m_file_pool, ptr.p->m_files);
+	  if(!files.next(file))
+	  {
+	    jam();
+	    files.first(file);
+	  }
+	  head.m_idx = 0;
+	  head.m_ptr_i = file.i;
+	  ptr.p->m_file_pos[HEAD] = head;
+	}
+      }
+      
       ptr.p->m_free_file_words = (Uint64)File_formats::UNDO_PAGE_WORDS * 
 	(Uint64)compute_free_file_pages(ptr);
       ptr.p->m_next_reply_ptr_i = ptr.p->m_file_pos[HEAD].m_ptr_i;
diff --git a/storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp b/storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp
index 8fc9e870b80..672c11f32e1 100644
--- a/storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp
+++ b/storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp
@@ -197,6 +197,7 @@ void Ndbcntr::execSYSTEM_ERROR(Signal* signal)
     break;
 
   case SystemError::CopyFragRefError:
+    CRASH_INSERTION(1000);
     BaseString::snprintf(buf, sizeof(buf), 
 			 "Killed by node %d as "
 			 "copyfrag failed, error: %u",
diff --git a/storage/ndb/src/kernel/blocks/restore.cpp b/storage/ndb/src/kernel/blocks/restore.cpp
index 695f393c3b6..d4a2414ef2f 100644
--- a/storage/ndb/src/kernel/blocks/restore.cpp
+++ b/storage/ndb/src/kernel/blocks/restore.cpp
@@ -1151,8 +1151,23 @@ Restore::calulate_hash(Uint32 tableId, const Uint32 *src)
 }
 
 void
-Restore::execLQHKEYREF(Signal*)
+Restore::execLQHKEYREF(Signal* signal)
 {
+  FilePtr file_ptr;
+  LqhKeyRef* ref = (LqhKeyRef*)signal->getDataPtr();
+  m_file_pool.getPtr(file_ptr, ref->connectPtr);
+  
+  char buf[255], name[100];
+  BaseString::snprintf(name, sizeof(name), "%u/T%dF%d",
+		       file_ptr.p->m_lcp_no,
+		       file_ptr.p->m_table_id,
+		       file_ptr.p->m_fragment_id);
+  
+  BaseString::snprintf(buf, sizeof(buf),
+		       "Error %d during restore of  %s",
+		       ref->errorCode, name);
+  
+  progError(__LINE__, NDBD_EXIT_INVALID_LCP_FILE, buf);  
   ndbrequire(false);
 }
 
diff --git a/storage/ndb/src/kernel/blocks/suma/Suma.cpp b/storage/ndb/src/kernel/blocks/suma/Suma.cpp
index cb5ec0f6adf..4206613f66e 100644
--- a/storage/ndb/src/kernel/blocks/suma/Suma.cpp
+++ b/storage/ndb/src/kernel/blocks/suma/Suma.cpp
@@ -578,6 +578,18 @@ void Suma::execAPI_FAILREQ(Signal* signal)
     return;
   }
 
+  if (c_failedApiNodes.get(failedApiNode))
+  {
+    jam();
+    return;
+  }
+
+  if (!c_subscriber_nodes.get(failedApiNode))
+  {
+    jam();
+    return;
+  }
+
   c_failedApiNodes.set(failedApiNode);
   c_connected_nodes.clear(failedApiNode);
   bool found = removeSubscribersOnNode(signal, failedApiNode);
@@ -591,9 +603,12 @@ void Suma::execAPI_FAILREQ(Signal* signal)
   Ptr<Gcp_record> gcp;
   for(c_gcp_list.first(gcp); !gcp.isNull(); c_gcp_list.next(gcp))
   {
+    jam();
     ack->rep.gci = gcp.p->m_gci;
     if(gcp.p->m_subscribers.get(failedApiNode))
     {
+      jam();
+      gcp.p->m_subscribers.clear(failedApiNode);
       ack->rep.senderRef = numberToRef(0, failedApiNode);
       sendSignal(SUMA_REF, GSN_SUB_GCP_COMPLETE_ACK, signal, 
 		 SubGcpCompleteAck::SignalLength, JBB);
@@ -743,6 +758,17 @@ Suma::execNODE_FAILREP(Signal* signal){
     Restart.resetRestart(signal);
   }
 
+  if (ERROR_INSERTED(13032))
+  {
+    Uint32 node = c_subscriber_nodes.find(0);
+    if (node != NodeBitmask::NotFound)
+    {
+      ndbout_c("Inserting API_FAILREQ node: %u", node);
+      signal->theData[0] = node;
+      EXECUTE_DIRECT(QMGR, GSN_API_FAILREQ, signal, 1);
+    }
+  }
+  
   signal->theData[0] = SumaContinueB::RESEND_BUCKET;
 
   NdbNodeBitmask tmp;
@@ -3447,7 +3473,10 @@ Suma::execFIRE_TRIG_ORD(Signal* signal)
    */
   f_bufferLock = 0;
   b_bufferLock = 0;
-
+  
+  ndbrequire((tabPtr.p = c_tablePool.getPtr(tabPtr.i)) != 0);
+  Uint32 tableId = tabPtr.p->m_tableId;
+  
   Uint32 bucket= hashValue % c_no_of_buckets;
   m_max_seen_gci = (gci > m_max_seen_gci ? gci : m_max_seen_gci);
   if(m_active_buckets.get(bucket) || 
@@ -3470,7 +3499,7 @@ Suma::execFIRE_TRIG_ORD(Signal* signal)
     
     SubTableData * data = (SubTableData*)signal->getDataPtrSend();//trg;
     data->gci            = gci;
-    data->tableId        = tabPtr.p->m_tableId;
+    data->tableId        = tableId;
     data->requestInfo    = 0;
     SubTableData::setOperation(data->requestInfo, event);
     data->logType        = 0;
@@ -3493,10 +3522,11 @@ Suma::execFIRE_TRIG_ORD(Signal* signal)
   else 
   {
     Uint32* dst;
-    Uint32 sz = f_trigBufferSize + b_trigBufferSize + 2;
+    Uint32 sz = f_trigBufferSize + b_trigBufferSize + 3;
     if((dst = get_buffer_ptr(signal, bucket, gci, sz)))
     {
-      * dst++ = tabPtr.i;
+      * dst++ = tableId;
+      * dst++ = tabPtr.p->m_schemaVersion;
       * dst++ = (event << 16) | f_trigBufferSize;
       memcpy(dst, f_buffer, f_trigBufferSize << 2);
       dst += f_trigBufferSize;
@@ -3628,6 +3658,7 @@ Suma::execSUB_GCP_COMPLETE_REP(Signal* signal)
     
     if(c_buckets[i].m_buffer_tail != RNIL)
     {
+      //Uint32* dst;
       get_buffer_ptr(signal, i, gci, 0);
     }
   }
@@ -3972,6 +4003,9 @@ void
 Suma::completeSubRemove(SubscriptionPtr subPtr)
 {
   DBUG_ENTER("Suma::completeSubRemove");
+  //Uint32 subscriptionId  = subPtr.p->m_subscriptionId;
+  //Uint32 subscriptionKey = subPtr.p->m_subscriptionKey;
+
   c_subscriptions.release(subPtr);
   DBUG_PRINT("info",("c_subscriptionPool  size: %d free: %d",
 		     c_subscriptionPool.getSize(),
@@ -4967,8 +5001,11 @@ Suma::resend_bucket(Signal* signal, Uint32 buck, Uint32 min_gci,
     {
       continue;
     }
+
+    ndbrequire(sz);
+    sz --; // remove *len* part of sz
     
-    if(sz == 1)
+    if(sz == 0)
     {
       SubGcpCompleteRep * rep = (SubGcpCompleteRep*)signal->getDataPtrSend();
       rep->gci = last_gci;
@@ -4988,43 +5025,48 @@ Suma::resend_bucket(Signal* signal, Uint32 buck, Uint32 min_gci,
     {
       g_cnt++;
       Uint32 table = * src++ ;
+      Uint32 schemaVersion = * src++;
       Uint32 event = * src >> 16;
       Uint32 sz_1 = (* src ++) & 0xFFFF;
-
-      ndbassert(sz - 2 >= sz_1);
+      
+      ndbassert(sz - 3 >= sz_1);
       
       LinearSectionPtr ptr[3];
       const Uint32 nptr= reformat(signal, ptr, 
 				  src, sz_1, 
-				  src + sz_1, sz - 2 - sz_1);
+				  src + sz_1, sz - 3 - sz_1);
       Uint32 ptrLen= 0;
       for(Uint32 i =0; i < nptr; i++)
         ptrLen+= ptr[i].sz;
+
       /**
        * Signal to subscriber(s)
        */
       Ptr<Table> tabPtr;
-      ndbrequire((tabPtr.p = c_tablePool.getPtr(table)) != 0);
-      
-      SubTableData * data = (SubTableData*)signal->getDataPtrSend();//trg;
-      data->gci            = last_gci;
-      data->tableId        = tabPtr.p->m_tableId;
-      data->requestInfo    = 0;
-      SubTableData::setOperation(data->requestInfo, event);
-      data->logType        = 0;
-      data->changeMask     = 0;
-      data->totalLen       = ptrLen;
-      
+      if (c_tables.find(tabPtr, table) && 
+	  tabPtr.p->m_schemaVersion == schemaVersion)
       {
-	LocalDLList<Subscriber> list(c_subscriberPool,tabPtr.p->c_subscribers);
-	SubscriberPtr subbPtr;
-	for(list.first(subbPtr); !subbPtr.isNull(); list.next(subbPtr))
+	SubTableData * data = (SubTableData*)signal->getDataPtrSend();//trg;
+	data->gci            = last_gci;
+	data->tableId        = table;
+	data->requestInfo    = 0;
+	SubTableData::setOperation(data->requestInfo, event);
+	data->logType        = 0;
+	data->changeMask     = 0;
+	data->totalLen       = ptrLen;
+	
 	{
-	  DBUG_PRINT("info",("GSN_SUB_TABLE_DATA to node %d",
-			     refToNode(subbPtr.p->m_senderRef)));
-	  data->senderData = subbPtr.p->m_senderData;
-	  sendSignal(subbPtr.p->m_senderRef, GSN_SUB_TABLE_DATA, signal,
-		     SubTableData::SignalLength, JBB, ptr, nptr);
+	  LocalDLList<Subscriber> 
+	    list(c_subscriberPool,tabPtr.p->c_subscribers);
+	  SubscriberPtr subbPtr;
+	  for(list.first(subbPtr); !subbPtr.isNull(); list.next(subbPtr))
+	  {
+	    DBUG_PRINT("info",("GSN_SUB_TABLE_DATA to node %d",
+			       refToNode(subbPtr.p->m_senderRef)));
+	    data->senderData = subbPtr.p->m_senderData;
+	    sendSignal(subbPtr.p->m_senderRef, GSN_SUB_TABLE_DATA, signal,
+		       SubTableData::SignalLength, JBB, ptr, nptr);
+	  }
 	}
       }
     }
diff --git a/storage/ndb/src/kernel/error/ErrorReporter.cpp b/storage/ndb/src/kernel/error/ErrorReporter.cpp
index 3d1b7fad7f3..43307d43139 100644
--- a/storage/ndb/src/kernel/error/ErrorReporter.cpp
+++ b/storage/ndb/src/kernel/error/ErrorReporter.cpp
@@ -24,6 +24,7 @@
 #include <NdbHost.h>
 #include <NdbConfig.h>
 #include <Configuration.hpp>
+#include "EventLogger.hpp"
 
 #include <NdbAutoPtr.hpp>
 
@@ -39,7 +40,7 @@ static void dumpJam(FILE* jamStream,
 		    Uint32 thrdTheEmulatedJamIndex, 
 		    Uint8 thrdTheEmulatedJam[]);
 
-
+extern EventLogger g_eventLogger;
 const char*
 ErrorReporter::formatTimeStampString(){
   TimeModule DateTime;          /* To create "theDateTimeString" */
@@ -196,6 +197,9 @@ ErrorReporter::handleError(int messageID,
   WriteMessage(messageID, problemData,
 	       objRef, theEmulatedJamIndex, theEmulatedJam);
 
+  g_eventLogger.info(problemData);
+  g_eventLogger.info(objRef);
+
   childReportError(messageID);
 
   if(messageID == NDBD_EXIT_ERROR_INSERT){
diff --git a/storage/ndb/src/mgmclient/CommandInterpreter.cpp b/storage/ndb/src/mgmclient/CommandInterpreter.cpp
index 7c57d9eabbc..fdcea63640c 100644
--- a/storage/ndb/src/mgmclient/CommandInterpreter.cpp
+++ b/storage/ndb/src/mgmclient/CommandInterpreter.cpp
@@ -2056,6 +2056,7 @@ CommandInterpreter::executeStatus(int processId,
   }
   if (cl->node_states[i].node_type != NDB_MGM_NODE_TYPE_NDB){
     if (cl->node_states[i].version != 0){
+      version = cl->node_states[i].version;
       ndbout << "Node "<< cl->node_states[i].node_id <<": connected" ;
       ndbout_c(" (Version %d.%d.%d)",
              getMajor(version) ,
@@ -2065,7 +2066,7 @@ CommandInterpreter::executeStatus(int processId,
     }else
      ndbout << "Node "<< cl->node_states[i].node_id <<": not connected" << endl;
     return 0;
-  } 
+  }
   status = cl->node_states[i].node_status;
   startPhase = cl->node_states[i].start_phase;
   version = cl->node_states[i].version;
diff --git a/storage/ndb/src/mgmsrv/ConfigInfo.cpp b/storage/ndb/src/mgmsrv/ConfigInfo.cpp
index e7c6122d846..6351af7246e 100644
--- a/storage/ndb/src/mgmsrv/ConfigInfo.cpp
+++ b/storage/ndb/src/mgmsrv/ConfigInfo.cpp
@@ -449,7 +449,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
     ConfigInfo::CI_INT,
     "128",
     "8",
-    STR_VALUE(MAX_INT_RNIL) },
+    STR_VALUE(MAX_TABLES) },
   
   {
     CFG_DB_NO_ORDERED_INDEXES,
diff --git a/storage/ndb/src/mgmsrv/ParamInfo.cpp b/storage/ndb/src/mgmsrv/ParamInfo.cpp
index 4a4e80eb079..888b7948c05 100644
--- a/storage/ndb/src/mgmsrv/ParamInfo.cpp
+++ b/storage/ndb/src/mgmsrv/ParamInfo.cpp
@@ -275,7 +275,7 @@ const ParamInfo ParamInfoArray[] = {
     CI_INT,
     "128",
     "8",
-    STR_VALUE(MAX_INT_RNIL) },
+    STR_VALUE(MAX_TABLES) },
   
   {
     CFG_DB_NO_ORDERED_INDEXES,
diff --git a/storage/ndb/src/ndbapi/NdbBlob.cpp b/storage/ndb/src/ndbapi/NdbBlob.cpp
index ee3a1cfd66a..98ba28c8d2e 100644
--- a/storage/ndb/src/ndbapi/NdbBlob.cpp
+++ b/storage/ndb/src/ndbapi/NdbBlob.cpp
@@ -1031,7 +1031,9 @@ NdbBlob::writeDataPrivate(const char* buf, Uint32 bytes)
         DBUG_RETURN(-1);
       Uint32 n = thePartSize - off;
       if (n > len) {
-        memset(thePartBuf.data + off + len, theFillChar, n - len);
+        /* If we are adding data at the end, fill rest of part. */
+        if (pos + len >= theLength)
+          memset(thePartBuf.data + off + len, theFillChar, n - len);
         n = len;
       }
       memcpy(thePartBuf.data + off, buf, n);
diff --git a/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp b/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp
index 1f4a9838c91..917f4e17051 100644
--- a/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp
+++ b/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp
@@ -1753,6 +1753,7 @@ NdbDictInterface::dictSignal(NdbApiSignal* sig,
 	       m_transporter->sendSignal(sig, node));
     if(res != 0){
       DBUG_PRINT("info", ("dictSignal failed to send signal"));
+      m_error.code = 4007;
       continue;
     }    
     
@@ -1770,6 +1771,7 @@ NdbDictInterface::dictSignal(NdbApiSignal* sig,
      */
     if(ret_val == -2) //WAIT_NODE_FAILURE
     {
+      m_error.code = 4013;
       continue;
     }
     if(m_waiter.m_state == WST_WAIT_TIMEOUT)
diff --git a/storage/ndb/src/ndbapi/NdbOperation.cpp b/storage/ndb/src/ndbapi/NdbOperation.cpp
index ff9c50da77c..9b3d20a1c33 100644
--- a/storage/ndb/src/ndbapi/NdbOperation.cpp
+++ b/storage/ndb/src/ndbapi/NdbOperation.cpp
@@ -368,12 +368,24 @@ NdbOperation::subValue( const char* anAttrName, Uint32 aValue)
   return subValue(m_currentTable->getColumn(anAttrName), aValue);
 }
 
+int
+NdbOperation::subValue( const char* anAttrName, Uint64 aValue)
+{
+  return subValue(m_currentTable->getColumn(anAttrName), aValue);
+}
+
 int
 NdbOperation::subValue(Uint32 anAttrId, Uint32 aValue)
 {
   return subValue(m_currentTable->getColumn(anAttrId), aValue);
 }
 
+int
+NdbOperation::subValue(Uint32 anAttrId, Uint64 aValue)
+{
+  return subValue(m_currentTable->getColumn(anAttrId), aValue);
+}
+
 int
 NdbOperation::read_attr(const char* anAttrName, Uint32 RegDest)
 {
diff --git a/storage/ndb/src/ndbapi/NdbScanFilter.cpp b/storage/ndb/src/ndbapi/NdbScanFilter.cpp
index 6ff7485416b..89abba2eddc 100644
--- a/storage/ndb/src/ndbapi/NdbScanFilter.cpp
+++ b/storage/ndb/src/ndbapi/NdbScanFilter.cpp
@@ -42,7 +42,9 @@ public:
 
   int m_label;
   State m_current;
+  Uint32 m_negative;    //used for translating NAND/NOR to AND/OR, equal 0 or 1 
   Vector<State> m_stack;
+  Vector<Uint32> m_stack2;    //to store info of m_negative
   NdbOperation * m_operation;
   Uint32 m_latestAttrib;
 
@@ -66,6 +68,7 @@ NdbScanFilter::NdbScanFilter(class NdbOperation * op)
   m_impl.m_label = 0;
   m_impl.m_latestAttrib = ~0;
   m_impl.m_operation = op;
+  m_impl.m_negative = 0;
 }
 
 NdbScanFilter::~NdbScanFilter(){
@@ -75,18 +78,39 @@ NdbScanFilter::~NdbScanFilter(){
 int
 NdbScanFilter::begin(Group group){
 
+  m_impl.m_stack2.push_back(m_impl.m_negative);
   switch(group){
   case NdbScanFilter::AND:
     INT_DEBUG(("Begin(AND)"));
+    if(m_impl.m_negative == 1){
+      group = NdbScanFilter::OR;
+    }
     break;
   case NdbScanFilter::OR:
     INT_DEBUG(("Begin(OR)"));
+    if(m_impl.m_negative == 1){
+      group = NdbScanFilter::AND;
+    }
     break;
   case NdbScanFilter::NAND:
     INT_DEBUG(("Begin(NAND)"));
+    if(m_impl.m_negative == 0){
+      group = NdbScanFilter::OR;
+      m_impl.m_negative = 1; 
+    }else{
+      group = NdbScanFilter::AND;
+      m_impl.m_negative = 0; 
+    }
     break;
   case NdbScanFilter::NOR:
     INT_DEBUG(("Begin(NOR)"));
+    if(m_impl.m_negative == 0){
+      group = NdbScanFilter::AND;
+      m_impl.m_negative = 1; 
+    }else{
+      group = NdbScanFilter::OR;
+      m_impl.m_negative = 0; 
+    }
     break;
   }
 
@@ -130,6 +154,13 @@ NdbScanFilter::begin(Group group){
 int
 NdbScanFilter::end(){
 
+  if(m_impl.m_stack2.size() == 0){
+    m_impl.m_operation->setErrorCodeAbort(4259);
+    return -1;
+  }
+  m_impl.m_negative = m_impl.m_stack2.back();
+  m_impl.m_stack2.erase(m_impl.m_stack2.size() - 1);
+
   switch(m_impl.m_current.m_group){
   case NdbScanFilter::AND:
     INT_DEBUG(("End(AND pc=%d)", m_impl.m_current.m_popCount));
@@ -151,6 +182,10 @@ NdbScanFilter::end(){
   }
   
   NdbScanFilterImpl::State tmp = m_impl.m_current;  
+  if(m_impl.m_stack.size() == 0){
+    m_impl.m_operation->setErrorCodeAbort(4259);
+    return -1;
+  }
   m_impl.m_current = m_impl.m_stack.back();
   m_impl.m_stack.erase(m_impl.m_stack.size() - 1);
   
@@ -395,8 +430,17 @@ NdbScanFilterImpl::cond_col_const(Interpreter::BinaryCondition op,
     m_operation->setErrorCodeAbort(4260);
     return -1;
   }
+
+  StrBranch2 branch;
+  if(m_negative == 1){  //change NdbOperation to its negative
+    if(m_current.m_group == NdbScanFilter::AND)
+      branch = table3[op].m_branches[(Uint32)(m_current.m_group) + 1];
+    if(m_current.m_group == NdbScanFilter::OR)
+      branch = table3[op].m_branches[(Uint32)(m_current.m_group) - 1];
+  }else{
+    branch = table3[op].m_branches[(Uint32)(m_current.m_group)];
+  }
   
-  StrBranch2 branch = table3[op].m_branches[m_current.m_group];
   const NdbDictionary::Column * col = 
     m_operation->m_currentTable->getColumn(AttrId);
   
diff --git a/storage/ndb/src/ndbapi/ndberror.c b/storage/ndb/src/ndbapi/ndberror.c
index 193177fbd54..7dd16f2d57f 100644
--- a/storage/ndb/src/ndbapi/ndberror.c
+++ b/storage/ndb/src/ndbapi/ndberror.c
@@ -149,10 +149,12 @@ ErrorBundle ErrorCodes[] = {
   /**
    * Unknown result
    */
+  { 4007, DMEC, UR, "Send to ndbd node failed" },
   { 4008, DMEC, UR, "Receive from NDB failed" },
   { 4009, DMEC, UR, "Cluster Failure" },
   { 4012, DMEC, UR, 
     "Request ndbd time-out, maybe due to high load or communication problems"}, 
+  { 4013, DMEC, UR, "Request timed out in waiting for node failure"}, 
   { 4024, DMEC, UR, 
     "Time-out, most likely caused by simple read or cluster failure" }, 
   
diff --git a/storage/ndb/test/include/NDBT_Test.hpp b/storage/ndb/test/include/NDBT_Test.hpp
index 46d27ec1c3c..ad09f04e814 100644
--- a/storage/ndb/test/include/NDBT_Test.hpp
+++ b/storage/ndb/test/include/NDBT_Test.hpp
@@ -333,6 +333,12 @@ public:
   // supply argc and argv as parameters
   int execute(int, const char**);
 
+  // NDBT's test tables are fixed and it always create 
+  // and drop fixed table when execute, add this method 
+  // in order to run CTX only and adapt to some new 
+  // customized testsuite
+  int executeOneCtx(Ndb_cluster_connection&,
+		 const NdbDictionary::Table* ptab, const char* testname = NULL);
 
   // These function can be used from main in the test program 
   // to control the behaviour of the testsuite
diff --git a/storage/ndb/test/ndbapi/Makefile.am b/storage/ndb/test/ndbapi/Makefile.am
index 3209a8be523..ad509dbbafe 100644
--- a/storage/ndb/test/ndbapi/Makefile.am
+++ b/storage/ndb/test/ndbapi/Makefile.am
@@ -39,6 +39,7 @@ testOperations \
 testRestartGci \
 testScan \
 testInterpreter \
+testScanFilter \
 testScanInterpreter \
 testScanPerf \
 testSystemRestart \
@@ -85,6 +86,7 @@ testOperations_SOURCES = testOperations.cpp
 testRestartGci_SOURCES = testRestartGci.cpp
 testScan_SOURCES = testScan.cpp ScanFunctions.hpp
 testInterpreter_SOURCES = testInterpreter.cpp
+testScanFilter_SOURCES = testScanFilter.cpp
 testScanInterpreter_SOURCES = testScanInterpreter.cpp ScanFilter.hpp ScanInterpretTest.hpp 
 testScanPerf_SOURCES = testScanPerf.cpp
 testSystemRestart_SOURCES = testSystemRestart.cpp
diff --git a/storage/ndb/test/ndbapi/testBlobs.cpp b/storage/ndb/test/ndbapi/testBlobs.cpp
index 5d2552220f9..e26910a64ad 100644
--- a/storage/ndb/test/ndbapi/testBlobs.cpp
+++ b/storage/ndb/test/ndbapi/testBlobs.cpp
@@ -138,6 +138,7 @@ printusage()
     << "  2           readData / writeData" << endl
     << "bug tests (no blob test)" << endl
     << "  -bug 4088   ndb api hang with mixed ops on index table" << endl
+    << "  -bug 27018  middle partial part write clobbers rest of part" << endl
     << "  -bug nnnn   delete + write gives 626" << endl
     << "  -bug nnnn   acc crash on delete and long key" << endl
     ;
@@ -1807,6 +1808,56 @@ bugtest_4088()
   return 0;
 }
 
+static int
+bugtest_27018()
+{
+  DBG("bug test 27018 - middle partial part write clobbers rest of part");
+
+  // insert rows
+  calcTups(false);
+  CHK(insertPk(false) == 0);
+  // new trans
+  for (unsigned k= 0; k < g_opt.m_rows; k++)
+  {
+    Tup& tup= g_tups[k];
+
+    CHK((g_con= g_ndb->startTransaction()) != 0);
+    CHK((g_opr= g_con->getNdbOperation(g_opt.m_tname)) != 0);
+    CHK(g_opr->updateTuple() == 0);
+    CHK(g_opr->equal("PK1", tup.m_pk1) == 0);
+    if (g_opt.m_pk2len != 0)
+      CHK(g_opr->equal("PK2", tup.m_pk2) == 0);
+    CHK(getBlobHandles(g_opr) == 0);
+    CHK(g_con->execute(NoCommit) == 0);
+
+    /* Update one byte in random position. */
+    Uint32 offset= urandom(tup.m_blob1.m_len);
+    tup.m_blob1.m_buf[0]= 0xff ^ tup.m_blob1.m_val[offset];
+    CHK(g_bh1->setPos(offset) == 0);
+    CHK(g_bh1->writeData(&(tup.m_blob1.m_buf[0]), 1) == 0);
+    CHK(g_con->execute(Commit) == 0);
+    g_ndb->closeTransaction(g_con);
+
+    CHK((g_con= g_ndb->startTransaction()) != 0);
+    CHK((g_opr= g_con->getNdbOperation(g_opt.m_tname)) != 0);
+    CHK(g_opr->readTuple() == 0);
+    CHK(g_opr->equal("PK1", tup.m_pk1) == 0);
+    if (g_opt.m_pk2len != 0)
+      CHK(g_opr->equal("PK2", tup.m_pk2) == 0);
+    CHK(getBlobHandles(g_opr) == 0);
+
+    CHK(g_bh1->getValue(tup.m_blob1.m_buf, tup.m_blob1.m_len) == 0);
+    CHK(g_con->execute(Commit) == 0);
+    Uint64 len= ~0;
+    CHK(g_bh1->getLength(len) == 0 && len == tup.m_blob1.m_len);
+    tup.m_blob1.m_buf[offset]^= 0xff;
+    CHK(memcmp(tup.m_blob1.m_buf, tup.m_blob1.m_val, tup.m_blob1.m_len) == 0);
+    g_ndb->closeTransaction(g_con);
+  }
+
+  return 0;
+}
+
 static int
 bugtest_2222()
 {
@@ -1823,7 +1874,8 @@ static struct {
   int m_bug;
   int (*m_test)();
 } g_bugtest[] = {
-  { 4088, bugtest_4088 }
+  { 4088, bugtest_4088 },
+  { 27018, bugtest_27018 }
 };
 
 NDB_COMMAND(testOdbcDriver, "testBlobs", "testBlobs", "testBlobs", 65535)
diff --git a/storage/ndb/test/ndbapi/testNodeRestart.cpp b/storage/ndb/test/ndbapi/testNodeRestart.cpp
index b4ae95567eb..9816675eb57 100644
--- a/storage/ndb/test/ndbapi/testNodeRestart.cpp
+++ b/storage/ndb/test/ndbapi/testNodeRestart.cpp
@@ -1415,6 +1415,58 @@ runBug26450(NDBT_Context* ctx, NDBT_Step* step)
   return NDBT_OK;
 }
 
+int
+runBug27003(NDBT_Context* ctx, NDBT_Step* step)
+{
+  int result = NDBT_OK;
+  int loops = ctx->getNumLoops();
+  int records = ctx->getNumRecords();
+  NdbRestarter res;
+  
+  static const int errnos[] = { 4025, 4026, 4027, 4028, 0 };
+
+  int node = res.getRandomNotMasterNodeId(rand());
+  ndbout_c("node: %d", node);
+  if (res.restartOneDbNode(node, true, true, true))
+    return NDBT_FAILED;
+
+  Uint32 pos = 0;
+  for (Uint32 i = 0; i<loops; i++)
+  {
+    while (errnos[pos] != 0)
+    {
+      ndbout_c("Tesing err: %d", errnos[pos]);
+      
+      if (res.waitNodesNoStart(&node, 1))
+	return NDBT_FAILED;
+
+      if (res.insertErrorInNode(node, 1000))
+	return NDBT_FAILED;
+      
+      if (res.insertErrorInNode(node, errnos[pos]))
+	return NDBT_FAILED;
+      
+      int val2[] = { DumpStateOrd::CmvmiSetRestartOnErrorInsert, 3 };
+      if (res.dumpStateOneNode(node, val2, 2))
+	return NDBT_FAILED;
+      
+      res.startNodes(&node, 1);
+      res.waitNodesStartPhase(&node, 1, 2);
+      pos++;
+    }
+    pos = 0;
+  }
+
+  if (res.waitNodesNoStart(&node, 1))
+    return NDBT_FAILED;
+  
+  res.startNodes(&node, 1);
+  if (res.waitClusterStarted())
+    return NDBT_FAILED;
+  
+  return NDBT_OK;
+}
+
 NDBT_TESTSUITE(testNodeRestart);
 TESTCASE("NoLoad", 
 	 "Test that one node at a time can be stopped and then restarted "\
@@ -1763,6 +1815,9 @@ TESTCASE("Bug26450", ""){
   INITIALIZER(runLoadTable);
   INITIALIZER(runBug26450);
 }
+TESTCASE("Bug27003", ""){
+  INITIALIZER(runBug27003);
+}
 NDBT_TESTSUITE_END(testNodeRestart);
 
 int main(int argc, const char** argv){
diff --git a/storage/ndb/test/ndbapi/testScanFilter.cpp b/storage/ndb/test/ndbapi/testScanFilter.cpp
new file mode 100644
index 00000000000..ba869dc8ce4
--- /dev/null
+++ b/storage/ndb/test/ndbapi/testScanFilter.cpp
@@ -0,0 +1,851 @@
+/* Copyright (C) 2007, Justin He, MySQL AB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#include <NDBT.hpp>
+#include <NDBT_Test.hpp>
+
+#define ERR_EXIT(obj, msg) \
+do \
+{ \
+fprintf(stderr, "%s: %s (%d) in %s:%d\n", \
+msg, obj->getNdbError().message, obj->getNdbError().code, __FILE__, __LINE__); \
+exit(-1); \
+} \
+while (0);
+
+#define PRINT_ERROR(code,msg) \
+do \
+{ \
+fprintf(stderr, "Error in %s, line: %d, code: %d, msg: %s.\n", __FILE__, __LINE__, code, msg); \
+} \
+while (0);
+
+#define MYSQLERROR(mysql) { \
+  PRINT_ERROR(mysql_errno(&mysql),mysql_error(&mysql)); \
+  exit(-1); }
+#define APIERROR(error) { \
+  PRINT_ERROR(error.code,error.message); \
+  exit(-1); }
+
+#define TEST_NAME "TestScanFilter" 
+#define TABLE_NAME "TABLE_SCAN"
+
+const char *COL_NAME[] = {"id", "i", "j", "k", "l", "m", "n"}; 
+const char COL_LEN = 7;
+/*
+* Not to change TUPLE_NUM, because the column in TABLE_NAME is fixed,
+* there are six columns, 'i', 'j', 'k', 'l', 'm', 'n', and each on is equal to 1 or 1,
+* Since each tuple should be unique in this case, then TUPLE_NUM = 2 power 6 = 64 
+*/
+const int TUPLE_NUM = (int)pow(2, COL_LEN-1);    
+
+/*
+* the recursive level of random scan filter, can 
+* modify this parameter more or less, range from 
+* 1 to 100, larger num consumes more scan time
+*/
+const int RECURSIVE_LEVEL = 10;
+
+const int MAX_STR_LEN = (RECURSIVE_LEVEL * (COL_LEN+1) * 4);
+
+/*
+* Each time stands for one test, it will produce a random 
+* filter string, and scan through ndb api and through 
+* calculation with tuples' data, then compare the result, 
+* if they are equal, this test passed, or failed.
+* Only all TEST_NUM times tests passed, we can believe 
+* the suite of test cases are okay.
+* Change TEST_NUM to larger will need more time to test
+*/
+const int TEST_NUM = 5000;
+
+
+/* Table definition*/
+static
+const
+NDBT_Attribute MYTAB1Attribs[] = {
+  NDBT_Attribute("id", NdbDictionary::Column::Unsigned, 1, true), 
+  NDBT_Attribute("i", NdbDictionary::Column::Unsigned),
+  NDBT_Attribute("j", NdbDictionary::Column::Unsigned),
+  NDBT_Attribute("k", NdbDictionary::Column::Unsigned),
+  NDBT_Attribute("l", NdbDictionary::Column::Unsigned),
+  NDBT_Attribute("m", NdbDictionary::Column::Unsigned),
+  NDBT_Attribute("n", NdbDictionary::Column::Unsigned),
+};
+static
+const
+NDBT_Table MYTAB1(TABLE_NAME, sizeof(MYTAB1Attribs)/sizeof(NDBT_Attribute), MYTAB1Attribs);
+
+
+int createTable(Ndb* pNdb, const NdbDictionary::Table* tab, bool _temp, 
+			 bool existsOk, NDBT_CreateTableHook f)
+{
+  int r = 0;
+  do{
+    NdbDictionary::Table tmpTab(* tab);
+    tmpTab.setStoredTable(_temp ? 0 : 1);
+    if(f != 0 && f(pNdb, tmpTab, 0, NULL))
+    {
+      ndbout << "Failed to create table" << endl;
+      return NDBT_FAILED;
+    }      
+    r = pNdb->getDictionary()->createTable(tmpTab);
+    if(r == -1){
+      if(!existsOk){
+	ndbout << "Error: " << pNdb->getDictionary()->getNdbError() << endl;
+	break;
+      }
+      if(pNdb->getDictionary()->getNdbError().code != 721){
+	ndbout << "Error: " << pNdb->getDictionary()->getNdbError() << endl;
+	break;
+      }
+      r = 0;
+    }
+  }while(false);
+  
+  return r;
+}
+
+/*
+* Function to produce the tuples' data
+*/
+int runPopulate(NDBT_Context* ctx, NDBT_Step* step)
+{
+  Ndb *myNdb = GETNDB(step);
+  const NdbDictionary::Dictionary* myDict= myNdb->getDictionary();
+  const NdbDictionary::Table *myTable= myDict->getTable(TABLE_NAME);
+  if(myTable == NULL) 
+    APIERROR(myDict->getNdbError());
+
+  NdbTransaction* myTrans = myNdb->startTransaction();
+  if (myTrans == NULL)
+    APIERROR(myNdb->getNdbError());
+
+  for(int num = 0; num < TUPLE_NUM; num++) 
+  {
+    NdbOperation* myNdbOperation = myTrans->getNdbOperation(myTable);
+    if(myNdbOperation == NULL) 
+    {
+      APIERROR(myTrans->getNdbError());
+    }
+
+/* the tuples' data in TABLE_NAME
++----+---+---+---+---+---+---+
+| id | i | j | k | l | m | n |
++----+---+---+---+---+---+---+
+|  0 | 0 | 0 | 0 | 0 | 0 | 0 |
+|  1 | 0 | 0 | 0 | 0 | 0 | 1 |
+|  2 | 0 | 0 | 0 | 0 | 1 | 0 |
+|  3 | 0 | 0 | 0 | 0 | 1 | 1 |
+|  4 | 0 | 0 | 0 | 1 | 0 | 0 |
+|  5 | 0 | 0 | 0 | 1 | 0 | 1 |
+|  6 | 0 | 0 | 0 | 1 | 1 | 0 |
+|  7 | 0 | 0 | 0 | 1 | 1 | 1 |
+|  8 | 0 | 0 | 1 | 0 | 0 | 0 |
+|  9 | 0 | 0 | 1 | 0 | 0 | 1 |
+| 10 | 0 | 0 | 1 | 0 | 1 | 0 |
+| 11 | 0 | 0 | 1 | 0 | 1 | 1 |
+| 12 | 0 | 0 | 1 | 1 | 0 | 0 |
+| 13 | 0 | 0 | 1 | 1 | 0 | 1 |
+| 14 | 0 | 0 | 1 | 1 | 1 | 0 |
+| 15 | 0 | 0 | 1 | 1 | 1 | 1 |
+| 16 | 0 | 1 | 0 | 0 | 0 | 0 |
+| 17 | 0 | 1 | 0 | 0 | 0 | 1 |
+| 18 | 0 | 1 | 0 | 0 | 1 | 0 |
+| 19 | 0 | 1 | 0 | 0 | 1 | 1 |
+| 20 | 0 | 1 | 0 | 1 | 0 | 0 |
+| 21 | 0 | 1 | 0 | 1 | 0 | 1 |
+| 22 | 0 | 1 | 0 | 1 | 1 | 0 |
+| 23 | 0 | 1 | 0 | 1 | 1 | 1 |
+| 24 | 0 | 1 | 1 | 0 | 0 | 0 |
+| 25 | 0 | 1 | 1 | 0 | 0 | 1 |
+| 26 | 0 | 1 | 1 | 0 | 1 | 0 |
+| 27 | 0 | 1 | 1 | 0 | 1 | 1 |
+| 28 | 0 | 1 | 1 | 1 | 0 | 0 |
+| 29 | 0 | 1 | 1 | 1 | 0 | 1 |
+| 30 | 0 | 1 | 1 | 1 | 1 | 0 |
+| 31 | 0 | 1 | 1 | 1 | 1 | 1 |
+| 32 | 1 | 0 | 0 | 0 | 0 | 0 |
+| 33 | 1 | 0 | 0 | 0 | 0 | 1 |
+| 34 | 1 | 0 | 0 | 0 | 1 | 0 |
+| 35 | 1 | 0 | 0 | 0 | 1 | 1 |
+| 36 | 1 | 0 | 0 | 1 | 0 | 0 |
+| 37 | 1 | 0 | 0 | 1 | 0 | 1 |
+| 38 | 1 | 0 | 0 | 1 | 1 | 0 |
+| 39 | 1 | 0 | 0 | 1 | 1 | 1 |
+| 40 | 1 | 0 | 1 | 0 | 0 | 0 |
+| 41 | 1 | 0 | 1 | 0 | 0 | 1 |
+| 42 | 1 | 0 | 1 | 0 | 1 | 0 |
+| 43 | 1 | 0 | 1 | 0 | 1 | 1 |
+| 44 | 1 | 0 | 1 | 1 | 0 | 0 |
+| 45 | 1 | 0 | 1 | 1 | 0 | 1 |
+| 46 | 1 | 0 | 1 | 1 | 1 | 0 |
+| 47 | 1 | 0 | 1 | 1 | 1 | 1 |
+| 48 | 1 | 1 | 0 | 0 | 0 | 0 |
+| 49 | 1 | 1 | 0 | 0 | 0 | 1 |
+| 50 | 1 | 1 | 0 | 0 | 1 | 0 |
+| 51 | 1 | 1 | 0 | 0 | 1 | 1 |
+| 52 | 1 | 1 | 0 | 1 | 0 | 0 |
+| 53 | 1 | 1 | 0 | 1 | 0 | 1 |
+| 54 | 1 | 1 | 0 | 1 | 1 | 0 |
+| 55 | 1 | 1 | 0 | 1 | 1 | 1 |
+| 56 | 1 | 1 | 1 | 0 | 0 | 0 |
+| 57 | 1 | 1 | 1 | 0 | 0 | 1 |
+| 58 | 1 | 1 | 1 | 0 | 1 | 0 |
+| 59 | 1 | 1 | 1 | 0 | 1 | 1 |
+| 60 | 1 | 1 | 1 | 1 | 0 | 0 |
+| 61 | 1 | 1 | 1 | 1 | 0 | 1 |
+| 62 | 1 | 1 | 1 | 1 | 1 | 0 |
+| 63 | 1 | 1 | 1 | 1 | 1 | 1 |
++----+---+---+---+---+---+---+
+*/
+    myNdbOperation->insertTuple();
+    myNdbOperation->equal(COL_NAME[0], num);
+    for(int col = 1; col < COL_LEN; col++)
+    {
+      myNdbOperation->setValue(COL_NAME[col], (num>>(COL_LEN-1-col))&1);
+    }
+  }
+
+  int check = myTrans->execute(NdbTransaction::Commit);
+
+  myTrans->close();
+
+  if (check == -1)
+    return NDBT_FAILED;
+  else
+    return NDBT_OK;
+
+}
+
+
+
+/*
+* a=AND, o=OR, A=NAND, O=NOR
+*/
+char op_string[] = "aoAO";
+/*
+* the six columns' name of test table
+*/
+char col_string[] = "ijklmn";
+const int op_len = strlen(op_string);
+const int col_len = strlen(col_string);
+
+/*
+* get a random op from "aoAO"
+*/
+int get_rand_op_ch(char *ch)
+{
+  static unsigned int num = 0;
+  if(++num == 0) 
+    num = 1;
+  srand(num*time(NULL));
+  *ch = op_string[rand() % op_len];
+  return 1;
+}
+
+/*
+* get a random order form of "ijklmn" trough exchanging letter
+*/
+void change_col_order()
+{
+  int pos1,pos2;
+  char temp;
+  for (int i = 0; i < 10; i++)  //exchange for 10 times
+  {
+    srand(time(NULL)/(i+1));
+    pos1 = rand() % col_len;
+    srand((i+1)*time(NULL));
+    pos2 = rand() % col_len;
+    if (pos1 == pos2)
+      continue;
+    temp = col_string[pos1];
+    col_string[pos1] = col_string[pos2];
+    col_string[pos2] = temp; 
+  }
+}
+
+/*
+* get a random sub string of "ijklmn" 
+*/
+int get_rand_col_str(char *str)
+{
+  int len;
+  static unsigned int num = 0;
+  if(++num == 0) 
+    num = 1;
+  srand(num*time(NULL));
+  len = rand() % col_len + 1;
+  change_col_order();
+  snprintf(str, len+1, "%s", col_string);  //len+1, including '\0'
+  return len;
+}
+
+/*
+* get a random string including operation and column 
+* eg, Alnikx
+*/
+int get_rand_op_str(char *str)
+{
+  char temp[256];
+  int len1, len2, len;
+  len1 = get_rand_op_ch(temp);
+  len2 = get_rand_col_str(temp+len1);
+  len = len1 + len2;
+  temp[len] = 'x';
+  snprintf(str, len+1+1, "%s", temp);  //len+1, including '\0'
+  return len+1;
+}
+
+/*
+* replace a letter of source string with a new string 
+* e.g., source string: 'Aijkx', replace i with new string 'olmx'
+* then source string is changed to 'Aolmxjkx'
+* source: its format should be produced from get_rand_op_str() 
+* pos: range from 1 to strlen(source)-2
+*/
+int replace_a_to_str(char *source, int pos, char *newstr)
+{
+  char temp[MAX_STR_LEN];
+  snprintf(temp, pos+1, "%s", source);
+  snprintf(temp+pos, strlen(newstr)+1, "%s", newstr);
+  snprintf(temp+pos+strlen(newstr), strlen(source)-pos, "%s", source+pos+1);
+  snprintf(source, strlen(temp)+1, "%s", temp); 
+  return strlen(source);
+}
+
+/*
+* check whether the inputed char is an operation 
+*/
+bool check_op(char ch)
+{
+  if( ch == 'a' || ch == 'A' || ch == 'o' || ch == 'O')
+    return true;
+  else
+    return false;
+}
+
+/*
+* check whether the inputed char is end flag 
+*/
+bool check_end(char ch)
+{
+  return (ch == 'x');
+}
+
+/*
+* check whether the inputed char is end flag 
+*/
+bool check_col(char ch)
+{
+  if( ch == 'i' || ch == 'j' || ch == 'k' 
+    || ch == 'l' || ch == 'm' || ch == 'n' )
+    return true;
+  else
+    return false;
+}
+
+/*
+* To ensure we can get a random string with RECURSIVE_LEVEL,
+* we need a position where can replace a letter with a new string. 
+*/
+int get_rand_replace_pos(char *str, int len)
+{
+  int pos_op = 0;
+  int pos_x = 0;
+  int pos_col = 0;
+  int span = 0;
+  static int num = 0;
+  char temp;
+
+  for(int i = 0; i < len; i++)
+  {
+    temp = str[i];
+    if(! check_end(temp))
+    {
+      if(check_op(temp))  
+        pos_op = i;
+    }
+    else
+    {
+      pos_x = i;
+      break;
+    }
+  }
+
+  if(++num == 0) 
+    num = 1;
+
+  span = pos_x - pos_op - 1;
+  if(span <= 1)
+  {
+    pos_col = pos_op + 1;
+  }
+  else
+  {
+    srand(num*time(NULL));
+    pos_col = pos_op + rand() % span + 1;
+  }
+  return pos_col;
+}
+
+/*
+* Check whether the given random string is valid
+* and applicable for this test case
+*/
+bool check_random_str(char *str)
+{
+  char *p;
+  int op_num = 0;
+  int end_num = 0;
+
+  for(p = str; *p; p++)
+  {
+    bool tmp1 = false, tmp2 = false;
+    if(tmp1 = check_op(*p))
+      op_num++;
+    if(tmp2 = check_end(*p))
+      end_num++;
+    if(!(tmp1 || tmp2 || check_col(*p)))   //there are illegal letters
+      return false;
+  }
+
+  if(op_num != end_num)     //begins are not equal to ends
+    return false;
+
+  return true;
+}
+
+/*
+* Get a random string with RECURSIVE_LEVEL 
+*/
+void get_rand_op_str_compound(char *str)
+{
+  char small_str[256];
+  int pos;
+  int tmp;
+  int level;
+  static int num = 0;
+
+  if(++num == 0)
+    num = 1;
+
+  srand(num*time(NULL));
+  level = 1 + rand() % RECURSIVE_LEVEL;
+ 
+  get_rand_op_str(str);
+
+  for(int i = 0; i < level; i++)
+  {
+    get_rand_op_str(small_str);
+    tmp = strlen(small_str);
+    get_rand_op_str(small_str + tmp);   //get two operations
+    pos = get_rand_replace_pos(str, strlen(str));
+    replace_a_to_str(str, pos, small_str);
+  }
+
+  //check the random string
+  if(!check_random_str(str))
+  {
+    fprintf(stderr, "Error random string! \n");
+    exit(-1);
+  }
+}
+
+/*
+* get column id of i,j,k,l,m,n
+*/
+int get_column_id(char ch)
+{
+  return (ch - 'i' + 1);  //from 1 to 6
+}
+
+/*
+* check whether column value of the NO. tuple is equal to 1
+* col_id: column id, range from 1 to 6
+* tuple_no: record NO., range from 0 to 63 
+*/
+bool check_col_equal_one(int tuple_no, int col_id)
+{
+  int i = (int)pow(2, 6 - col_id);
+  int j = tuple_no / i;
+  if(j % 2)
+    return true;
+  else
+    return false;
+}
+
+/*
+* get a result after all elements in the array with AND
+* value: pointer to a bool array
+* len: length of the bool array
+*/
+bool AND_op(bool *value, int len)
+{
+  for(int i = 0; i < len; i++)
+  {
+    if(! value[i])
+      return false;
+  }
+  return true;
+}
+
+/*
+* get a result after all elements in the array with OR
+* value: pointer to a bool array
+* len: length of the bool array
+*/
+bool OR_op(bool *value, int len)
+{
+  for(int i = 0; i < len; i++)
+  {
+    if(value[i])
+      return true;
+  }
+  return false;
+}
+
+/*
+* get a result after all elements in the array with NAND
+* value: pointer to a bool array
+* len: length of the bool array
+*/
+bool NAND_op(bool *value, int len)
+{
+  return (! AND_op(value, len));
+}
+
+/*
+* get a result after all elements in the array with NOR
+* value: pointer to a bool array
+* len: length of the bool array
+*/
+bool NOR_op(bool *value, int len)
+{
+  return (! OR_op(value, len));
+}
+
+/*
+* AND/NAND/OR/NOR operation for a bool array 
+*/
+bool calculate_one_op(char op_type, bool *value, int len)
+{
+  switch(op_type)
+  {
+    case 'a':
+      return AND_op(value, len);
+      break;
+    case 'o':
+      return OR_op(value, len);
+      break;
+    case 'A':
+      return NAND_op(value, len);
+      break;
+    case 'O':
+      return NOR_op(value, len);
+      break;
+  }
+  return false;   //make gcc happy
+}
+
+typedef struct _stack_element
+{
+  char type;
+  int num;
+}stack_element;
+
+/*
+* stack_op, store info for AND,OR,NAND,NOR
+* stack_col, store value of column(i,j,k,l,m,n) and temporary result for an operation
+*/
+stack_element stack_op[RECURSIVE_LEVEL * COL_LEN];
+bool stack_col[RECURSIVE_LEVEL * COL_LEN * 2];
+
+/*
+* check whether the given tuple is chosen by judgement condition 
+* tuple_no, the NO of tuple in TABLE_NAME, range from 0 to TUPLE_NUM
+* str: a random string of scan opearation and condition
+* len: length of str
+*/
+bool check_one_tuple(int tuple_no, char *str, int len)
+{
+  int pop_op = 0;
+  int pop_col = 0;
+  for(int i = 0; i < len; i++)
+  {
+    char letter = *(str + i);
+    if(check_op(letter))    //push
+    {
+      stack_op[pop_op].type = letter;
+      stack_op[pop_op].num = 0;
+      pop_op++;
+    }
+    if(check_col(letter))   //push
+    {
+      stack_col[pop_col] = check_col_equal_one(tuple_no, get_column_id(letter));  
+      pop_col++;
+      stack_op[pop_op-1].num += 1;
+    }
+    if(check_end(letter))
+    {
+      if(pop_op <= 1)
+      {
+        return calculate_one_op(stack_op[pop_op-1].type, 
+                                stack_col, 
+                                stack_op[pop_op-1].num);
+      }
+      else
+      {
+        bool tmp1 = calculate_one_op(stack_op[pop_op-1].type, 
+                                    stack_col + pop_col - stack_op[pop_op-1].num, 
+                                    stack_op[pop_op-1].num);
+        pop_col -= stack_op[pop_op-1].num;    //pop
+        pop_op--;
+        stack_col[pop_col] = tmp1;    //push
+        pop_col++;
+        stack_op[pop_op-1].num += 1;
+      }
+    }
+  }
+  return false;   //make gcc happy
+}
+
+/*
+* get lists of tuples which match the scan condiction through calculating
+* str: a random string of scan opearation and condition
+*/
+void check_all_tuples(char *str, bool *res)
+{    
+  for (int i = 0; i < TUPLE_NUM; i++)
+  {
+    if(check_one_tuple(i, str, strlen(str)))
+      res[i] = true;
+  }
+}
+
+/*
+* convert a letter to group number what ndbapi need
+*/
+NdbScanFilter::Group get_api_group(char op_name)
+{
+  switch (op_name) {
+  case 'a': return NdbScanFilter::AND;
+  case 'o': return NdbScanFilter::OR;
+  case 'A': return NdbScanFilter::NAND;
+  case 'O': return NdbScanFilter::NOR;
+  default: 
+    fprintf(stderr, "Invalid group name %c !\n", op_name);
+    exit(3);
+  }
+}
+
+/*
+* with ndbapi, call begin, eq/ne/lt/gt/le/ge..., end
+*/
+NdbScanFilter * call_ndbapi(char *str, NdbTransaction *transaction, 
+  NdbScanOperation *scan, NdbDictionary::Column const *col[])
+{
+  NdbScanFilter *scanfilter = new NdbScanFilter(scan);
+  char *p;
+
+  for (p = str; *p; p++) 
+  {
+    if(check_op(*p))
+    {
+       if(scanfilter->begin(get_api_group(*p))) 
+          ERR_EXIT(transaction, "filter begin() failed");
+    }
+    if(check_col(*p))
+    {
+       if(scanfilter->eq(col[*p-'i'+1]->getColumnNo(), (Uint32)1)) 
+          ERR_EXIT(transaction, "filter eq() failed"); 
+    }
+    if(check_end(*p))
+    {
+      if(scanfilter->end()) 
+        ERR_EXIT(transaction, "filter end() failed");
+    }
+  }
+  
+  return scanfilter;
+}
+
+/*
+* get the tuples through ndbapi, and save the tuples NO.
+* str: a random string of scan opearation and condition
+*/
+void ndbapi_tuples(Ndb *ndb, char *str, bool *res)
+{
+	const NdbDictionary::Dictionary *dict  = ndb->getDictionary();
+	if (!dict) 
+    ERR_EXIT(ndb, "Can't get dict");
+
+	const NdbDictionary::Table *table = dict->getTable(TABLE_NAME);
+	if (!table) 
+    ERR_EXIT(dict, "Can't get table"TABLE_NAME);
+	
+	const NdbDictionary::Column *col[COL_LEN];
+  for(int i = 0; i < COL_LEN; i++)
+  {
+    char tmp[128];
+    col[i] = table->getColumn(COL_NAME[i]);
+	  if(!col[i]) 
+    {
+      snprintf(tmp, 128, "Can't get column %s", COL_NAME[i]);
+      ERR_EXIT(dict, tmp);
+    }
+  }
+
+  NdbTransaction *transaction;
+  NdbScanOperation *scan;
+  NdbScanFilter *filter;
+
+  transaction = ndb->startTransaction();
+  if (!transaction) 
+    ERR_EXIT(ndb, "Can't start transaction");
+
+  scan = transaction->getNdbScanOperation(table);	
+  if (!scan) 
+    ERR_EXIT(transaction, "Can't get scan op");
+	  
+  if (scan->readTuples(NdbOperation::LM_Exclusive)) 
+    ERR_EXIT(scan, "Can't set up read");
+  
+  NdbRecAttr *rec[COL_LEN];
+  for(int i = 0; i < COL_LEN; i++)
+  {
+    char tmp[128];
+    rec[i] = scan->getValue(COL_NAME[i]);
+	  if(!rec[i]) 
+    {
+      snprintf(tmp, 128, "Can't get rec of %s", COL_NAME[i]);
+      ERR_EXIT(scan, tmp);
+    }
+  }
+
+  filter = call_ndbapi(str, transaction, scan, col);
+	  
+  if (transaction->execute(NdbTransaction::NoCommit)) 
+    ERR_EXIT(transaction, "Can't execute");
+	  
+  int i,j,k,l,m,n;
+  while (scan->nextResult(true) == 0) 
+  {
+    do 
+    {
+      i = rec[1]->u_32_value();
+      j = rec[2]->u_32_value();
+      k = rec[3]->u_32_value();
+      l = rec[4]->u_32_value();
+      m = rec[5]->u_32_value();
+      n = rec[6]->u_32_value();
+      res[32*i+16*j+8*k+4*l+2*m+n] = true;
+    } while (scan->nextResult(false) == 0);
+  }
+	  
+  delete filter;
+  transaction->close();
+}
+
+/*
+* compare the result between calculation and NDBAPI
+* str: a random string of scan opearation and condition
+* return: true stands for ndbapi ok, false stands for ndbapi failed
+*/
+bool compare_cal_ndb(char *str, Ndb *ndb)
+{
+  bool res_cal[TUPLE_NUM], res_ndb[TUPLE_NUM];
+
+  for(int i = 0; i < TUPLE_NUM; i++)
+  {
+    res_cal[i] = false;
+    res_ndb[i] = false;
+  }
+
+  check_all_tuples(str, res_cal);
+  ndbapi_tuples(ndb, str, res_ndb);
+
+  for(int i = 0; i < TUPLE_NUM; i++)
+  {
+    if(res_cal[i] != res_ndb[i])
+      return false;
+  }
+  return true;
+}
+
+
+int runCreateTables(NDBT_Context* ctx, NDBT_Step* step)
+{
+  Ndb *pNdb = GETNDB(step);
+  pNdb->getDictionary()->dropTable(MYTAB1.getName());
+  int ret = createTable(pNdb, &MYTAB1, false, true, 0); 
+  if(ret)
+    return ret;
+  return NDBT_OK;
+}
+
+
+int runDropTables(NDBT_Context* ctx, NDBT_Step* step)
+{
+ int ret = GETNDB(step)->getDictionary()->dropTable(MYTAB1.getName());
+ if(ret == -1)
+   return NDBT_FAILED;
+  
+  return NDBT_OK;
+}
+
+int runScanRandomFilterTest(NDBT_Context* ctx, NDBT_Step* step)
+{
+  char random_str[MAX_STR_LEN];
+  Ndb *myNdb = GETNDB(step);
+  bool res = true;
+
+  for(int i = 0; i < TEST_NUM; i++)
+  {
+    get_rand_op_str_compound(random_str);
+    if( !compare_cal_ndb(random_str, myNdb)) 
+      return NDBT_FAILED;
+  }
+
+  return NDBT_OK;
+}
+
+NDBT_TESTSUITE(testScanFilter);
+TESTCASE(TEST_NAME, 
+	 "Scan table TABLE_NAME for the records which accord with \
+   conditions of logical scan operations: AND/OR/NAND/NOR")
+{
+  INITIALIZER(runCreateTables);
+  INITIALIZER(runPopulate);
+  INITIALIZER(runScanRandomFilterTest);
+  FINALIZER(runDropTables);
+}
+
+NDBT_TESTSUITE_END(testScanFilter);
+
+
+int main(int argc, const char** argv)
+{
+  ndb_init();
+
+  Ndb_cluster_connection con;
+  if(con.connect(12, 5, 1))
+  {
+    return NDBT_ProgramExit(NDBT_FAILED);
+  }
+  
+  return testScanFilter.executeOneCtx(con, &MYTAB1, TEST_NAME);
+}
diff --git a/storage/ndb/test/ndbapi/test_event.cpp b/storage/ndb/test/ndbapi/test_event.cpp
index 5af3ff77df8..563819689a8 100644
--- a/storage/ndb/test/ndbapi/test_event.cpp
+++ b/storage/ndb/test/ndbapi/test_event.cpp
@@ -500,6 +500,12 @@ int runEventMixedLoad(NDBT_Context* ctx, NDBT_Step* step)
   int records = ctx->getNumRecords();
   HugoTransactions hugoTrans(*ctx->getTab());
   
+  if(ctx->getPropertyWait("LastGCI", ~(Uint32)0))
+  {
+    g_err << "FAIL " << __LINE__ << endl;
+    return NDBT_FAILED;
+  }
+
   while(loops -- && !ctx->isTestStopped())
   {
     hugoTrans.clearTable(GETNDB(step), 0);
@@ -606,9 +612,11 @@ int runEventApplier(NDBT_Context* ctx, NDBT_Step* step)
     goto end;
   }
 
+  ctx->setProperty("LastGCI", ~(Uint32)0);
+  ctx->broadcast();
+
   while(!ctx->isTestStopped())
   {
-    int r;
     int count= 0;
     Uint32 stop_gci= ~0;
     Uint64 curr_gci = 0;
@@ -778,7 +786,7 @@ int runEventApplier(NDBT_Context* ctx, NDBT_Step* step)
 
 	  if (trans->getNdbError().status == NdbError::PermanentError)
 	  {
-	    g_err << "Ignoring execute " << r << " failed "
+	    g_err << "Ignoring execute failed "
 		  << trans->getNdbError().code << " "
 		  << trans->getNdbError().message << endl;
 	  
@@ -788,7 +796,7 @@ int runEventApplier(NDBT_Context* ctx, NDBT_Step* step)
 	  }
 	  else if (noRetries++ == 10)
 	  {
-	    g_err << "execute " << r << " failed "
+	    g_err << "execute failed "
 		  << trans->getNdbError().code << " "
 		  << trans->getNdbError().message << endl;
 	    trans->close();
@@ -828,6 +836,67 @@ end:
   DBUG_RETURN(result);
 }
 
+int runEventListenerUntilStopped(NDBT_Context* ctx, NDBT_Step* step)
+{
+  
+  int result = NDBT_OK;
+  const NdbDictionary::Table * table= ctx->getTab();
+  HugoTransactions hugoTrans(* table);
+
+  char buf[1024];
+  sprintf(buf, "%s_EVENT", table->getName());
+  NdbEventOperation *pOp, *pCreate = 0;
+  pCreate = pOp = GETNDB(step)->createEventOperation(buf);
+  if ( pOp == NULL ) {
+    g_err << "Event operation creation failed on %s" << buf << endl;
+    return NDBT_FAILED;
+  }
+  
+  int i;
+  int n_columns= table->getNoOfColumns();
+  NdbRecAttr* recAttr[1024];
+  NdbRecAttr* recAttrPre[1024];
+  for (i = 0; i < n_columns; i++) {
+    recAttr[i]    = pOp->getValue(table->getColumn(i)->getName());
+    recAttrPre[i] = pOp->getPreValue(table->getColumn(i)->getName());
+  }
+
+  if (pOp->execute()) 
+  { // This starts changes to "start flowing"
+    g_err << "execute operation execution failed: \n";
+    g_err << pOp->getNdbError().code << " "
+	  << pOp->getNdbError().message << endl;
+    result = NDBT_FAILED;
+    goto end;
+  }
+  
+  Ndb* ndb= GETNDB(step);
+  while(!ctx->isTestStopped())
+  {
+    Uint64 curr_gci = 0;
+    while(!ctx->isTestStopped())
+    {
+      ndb->pollEvents(100, &curr_gci);
+      while ((pOp= ndb->nextEvent()) != 0)
+      {
+	assert(pOp == pCreate);
+      } 
+    }
+  }
+  
+end:
+  if(pCreate)
+  {
+    if (GETNDB(step)->dropEventOperation(pCreate)) {
+      g_err << "dropEventOperation execution failed "
+	    << GETNDB(step)->getNdbError().code << " "
+	    << GETNDB(step)->getNdbError().message << endl;
+      result = NDBT_FAILED;
+    }
+  }
+  return result;
+}
+
 int runRestarter(NDBT_Context* ctx, NDBT_Step* step){
   int result = NDBT_OK;
   int loops = ctx->getNumLoops();
@@ -869,6 +938,51 @@ int runRestarter(NDBT_Context* ctx, NDBT_Step* step){
   return result;
 }
 
+int runRestarterLoop(NDBT_Context* ctx, NDBT_Step* step)
+{
+  int result = NDBT_OK;
+  int loops = ctx->getNumLoops();
+  NdbRestarter restarter;
+  int i = 0;
+  int lastId = 0;
+
+  if (restarter.getNumDbNodes() < 2){
+    ctx->stopTest();
+    return NDBT_OK;
+  }
+
+  if(restarter.waitClusterStarted(60) != 0){
+    g_err << "Cluster failed to start" << endl;
+    return NDBT_FAILED;
+  }
+  
+  while(result != NDBT_FAILED 
+	&& !ctx->isTestStopped() 
+	&& i < loops)
+  {
+    int id = lastId % restarter.getNumDbNodes();
+    int nodeId = restarter.getDbNodeId(id);
+    ndbout << "Restart node " << nodeId << endl; 
+    if(restarter.restartOneDbNode(nodeId, false, false, true) != 0){
+      g_err << "Failed to restartNextDbNode" << endl;
+      result = NDBT_FAILED;
+      break;
+    }    
+    
+    if(restarter.waitClusterStarted(60) != 0){
+      g_err << "Cluster failed to start" << endl;
+      result = NDBT_FAILED;
+      break;
+    }
+    
+    lastId++;
+    i++;
+  }
+
+  ctx->stopTest();
+  return result;
+}
+
 Vector<const NdbDictionary::Table*> pTabs;
 Vector<const NdbDictionary::Table*> pShadowTabs;
 
@@ -1608,6 +1722,42 @@ runSubscribeUnsubscribe(NDBT_Context* ctx, NDBT_Step* step)
   return NDBT_OK;
 }
 
+int 
+runScanUpdateUntilStopped(NDBT_Context* ctx, NDBT_Step* step){
+  int records = ctx->getNumRecords();
+  int parallelism = ctx->getProperty("Parallelism", (Uint32)0);
+  int abort = ctx->getProperty("AbortProb", (Uint32)0);
+  HugoTransactions hugoTrans(*ctx->getTab());
+  while (ctx->isTestStopped() == false) 
+  {
+    if (hugoTrans.scanUpdateRecords(GETNDB(step), records, abort, 
+				    parallelism) == NDBT_FAILED){
+      return NDBT_FAILED;
+    }
+  }
+  return NDBT_OK;
+}
+
+int 
+runInsertDeleteUntilStopped(NDBT_Context* ctx, NDBT_Step* step)
+{
+  int result = NDBT_OK;
+  int records = ctx->getNumRecords();
+  HugoTransactions hugoTrans(*ctx->getTab());
+  UtilTransactions utilTrans(*ctx->getTab());
+  while (ctx->isTestStopped() == false) 
+  {
+    if (hugoTrans.loadTable(GETNDB(step), records, 1) != 0){
+      return NDBT_FAILED;
+    }
+    if (utilTrans.clearTable(GETNDB(step),  records) != 0){
+      return NDBT_FAILED;
+    }
+  }
+  
+  return NDBT_OK;
+}
+
 NDBT_TESTSUITE(test_event);
 TESTCASE("BasicEventOperation", 
 	 "Verify that we can listen to Events"
@@ -1729,6 +1879,14 @@ TESTCASE("SubscribeUnsubscribe",
   STEPS(runSubscribeUnsubscribe, 16);
   FINALIZER(runDropEvent);
 }
+TESTCASE("Bug27169", ""){
+  INITIALIZER(runCreateEvent);
+  STEP(runEventListenerUntilStopped);
+  STEP(runInsertDeleteUntilStopped);
+  STEP(runScanUpdateUntilStopped);
+  STEP(runRestarterLoop);
+  FINALIZER(runDropEvent);
+}
 NDBT_TESTSUITE_END(test_event);
 
 int main(int argc, const char** argv){
diff --git a/storage/ndb/test/run-test/daily-basic-tests.txt b/storage/ndb/test/run-test/daily-basic-tests.txt
index 4022dffa258..5bea7d43f1a 100644
--- a/storage/ndb/test/run-test/daily-basic-tests.txt
+++ b/storage/ndb/test/run-test/daily-basic-tests.txt
@@ -469,6 +469,10 @@ max-time: 1000
 cmd: testScan
 args: -n ScanVariants
 
+max-time: 1000
+cmd: testNodeRestart
+args: -n Bug27003 T1
+
 max-time: 500
 cmd: testNodeRestart
 args: -n Bug15587 T1
@@ -792,6 +796,10 @@ max-time: 1000
 cmd: testNodeRestart
 args: -n Bug25468 T1
 
+max-time: 1000
+cmd: test_event
+args: -l 10 -n Bug27169 T1
+
 # OLD FLEX
 max-time: 500
 cmd: flexBench
diff --git a/storage/ndb/test/src/HugoCalculator.cpp b/storage/ndb/test/src/HugoCalculator.cpp
index 4d05c99738f..1589d4a9eb0 100644
--- a/storage/ndb/test/src/HugoCalculator.cpp
+++ b/storage/ndb/test/src/HugoCalculator.cpp
@@ -89,6 +89,27 @@ HugoCalculator::float calcValue(int record, int attrib, int updates) const;
 HugoCalculator::double calcValue(int record, int attrib, int updates) const;
 #endif
 
+static
+Uint32
+calc_len(Uint32 rvalue, int maxlen)
+{
+  Uint32 minlen = 25;
+  
+  if ((rvalue >> 16) < 4096)
+    minlen = 15;
+  else if ((rvalue >> 16) < 8192)
+    minlen = 25;
+  else if ((rvalue >> 16) < 16384)
+    minlen = 35;
+  else
+    minlen = 64;
+
+  if (maxlen <= minlen)
+    return maxlen;
+
+  return minlen + (rvalue % (maxlen - minlen));
+}
+
 const char* 
 HugoCalculator::calcValue(int record, 
 			  int attrib, 
@@ -178,7 +199,7 @@ HugoCalculator::calcValue(int record,
     break;
   case NdbDictionary::Column::Varbinary:
   case NdbDictionary::Column::Varchar:
-    len = 1 + (myRand(&seed) % (len - 1));
+    len = calc_len(myRand(&seed), len - 1);
     assert(len < 256);
     * outlen = len + 1;
     * buf = len;
@@ -186,7 +207,7 @@ HugoCalculator::calcValue(int record,
     goto write_char;
   case NdbDictionary::Column::Longvarchar:
   case NdbDictionary::Column::Longvarbinary:
-    len = 1 + (myRand(&seed) % (len - 2));
+    len = calc_len(myRand(&seed), len - 2);
     assert(len < 65536);
     * outlen = len + 2;
     int2store(buf, len);
diff --git a/storage/ndb/test/src/NDBT_Test.cpp b/storage/ndb/test/src/NDBT_Test.cpp
index 9c908ab27c6..1245d004aff 100644
--- a/storage/ndb/test/src/NDBT_Test.cpp
+++ b/storage/ndb/test/src/NDBT_Test.cpp
@@ -947,6 +947,63 @@ NDBT_TestSuite::executeOne(Ndb_cluster_connection& con,
   }
 }
 
+int 
+NDBT_TestSuite::executeOneCtx(Ndb_cluster_connection& con,
+			   const NdbDictionary::Table *ptab, const char* _testname){
+  
+  testSuiteTimer.doStart(); 
+  
+  do{
+    if(tests.size() == 0)
+      break;
+
+    Ndb ndb(&con, "TEST_DB");
+    ndb.init(1024);
+
+    int result = ndb.waitUntilReady(300); // 5 minutes
+    if (result != 0){
+      g_err << name <<": Ndb was not ready" << endl;
+      break;
+    }
+
+    ndbout << name << " started [" << getDate() << "]" << endl;
+    ndbout << "|- " << ptab->getName() << endl;
+
+    for (unsigned t = 0; t < tests.size(); t++){
+
+      if (_testname != NULL && 
+	      strcasecmp(tests[t]->getName(), _testname) != 0)
+        continue;
+
+      tests[t]->initBeforeTest();
+    
+      ctx = new NDBT_Context(con);
+      ctx->setTab(ptab);
+      ctx->setNumRecords(records);
+      ctx->setNumLoops(loops);
+      if(remote_mgm != NULL)
+        ctx->setRemoteMgm(remote_mgm);
+      ctx->setSuite(this);
+    
+      result = tests[t]->execute(ctx);
+      if (result != NDBT_OK)
+        numTestsFail++;
+      else
+        numTestsOk++;
+      numTestsExecuted++;
+
+    delete ctx;
+  }
+
+    if (numTestsFail > 0)
+      break;
+  }while(0);
+
+  testSuiteTimer.doStop();
+  int res = report(_testname);
+  return NDBT_ProgramExit(res);
+}
+
 int
 NDBT_TestSuite::createHook(Ndb* ndb, NdbDictionary::Table& tab, int when)
 {
diff --git a/storage/ndb/test/src/UtilTransactions.cpp b/storage/ndb/test/src/UtilTransactions.cpp
index 453364fa1b2..5a408140c8e 100644
--- a/storage/ndb/test/src/UtilTransactions.cpp
+++ b/storage/ndb/test/src/UtilTransactions.cpp
@@ -1381,6 +1381,7 @@ loop:
       goto error;
     }
   
+    row_count= 0;
     {
       int eof;
       while((eof = pOp->nextResult(true)) == 0)
diff --git a/storage/ndb/test/tools/listen.cpp b/storage/ndb/test/tools/listen.cpp
index 1d142e0931d..fd404ff0134 100644
--- a/storage/ndb/test/tools/listen.cpp
+++ b/storage/ndb/test/tools/listen.cpp
@@ -168,9 +168,15 @@ main(int argc, const char** argv){
 	  break;
 	case NdbDictionary::Event::TE_DROP:
 	  break;
+	case NdbDictionary::Event::TE_NODE_FAILURE:
+	  break;
+	case NdbDictionary::Event::TE_SUBSCRIBE:
+	case NdbDictionary::Event::TE_UNSUBSCRIBE:
+	  break;
 	default:
 	  /* We should REALLY never get here. */
-	  ndbout_c("Error: unknown event type");
+	  ndbout_c("Error: unknown event type: %u", 
+		   (Uint32)pOp->getEventType());
 	  abort();
 	}
       } while ((pOp= MyNdb.nextEvent()) && gci == pOp->getGCI());
diff --git a/storage/ndb/tools/restore/consumer.hpp b/storage/ndb/tools/restore/consumer.hpp
index b05f7e00402..4121cc4e1b4 100644
--- a/storage/ndb/tools/restore/consumer.hpp
+++ b/storage/ndb/tools/restore/consumer.hpp
@@ -41,6 +41,7 @@ public:
   NODE_GROUP_MAP *m_nodegroup_map;
   uint            m_nodegroup_map_len;
   virtual bool has_temp_error() {return false;}
+  virtual bool table_equal(const TableS &) {return true;}
 };
 
 #endif
diff --git a/storage/ndb/tools/restore/consumer_restore.cpp b/storage/ndb/tools/restore/consumer_restore.cpp
index 88bcbc399aa..f99734a069c 100644
--- a/storage/ndb/tools/restore/consumer_restore.cpp
+++ b/storage/ndb/tools/restore/consumer_restore.cpp
@@ -702,6 +702,62 @@ err:
   return result;
 }
 
+bool
+BackupRestore::table_equal(const TableS &tableS){
+  const char *tablename = tableS.getTableName();
+
+  if(tableS.m_dictTable == NULL){
+    ndbout<<"Table %s has no m_dictTable " << tablename << endl;
+    return false;
+  }
+  /**
+   * Ignore blob tables
+   */
+  if(match_blob(tablename) >= 0)
+    return true;
+
+  const NdbTableImpl & tmptab = NdbTableImpl::getImpl(* tableS.m_dictTable);
+  if ((int) tmptab.m_indexType != (int) NdbDictionary::Index::Undefined){
+    return true;
+  }
+
+  BaseString tmp(tablename);
+  Vector<BaseString> split;
+  if(tmp.split(split, "/") != 3){
+    err << "Invalid table name format " << tablename << endl;
+    return false;
+  }
+
+  m_ndb->setDatabaseName(split[0].c_str());
+  m_ndb->setSchemaName(split[1].c_str());
+
+  NdbDictionary::Dictionary* dict = m_ndb->getDictionary();  
+  const NdbDictionary::Table* tab = dict->getTable(split[2].c_str());
+  if(tab == 0){
+    err << "Unable to find table: " << split[2].c_str() << endl;
+    return false;
+  }
+
+  if(tab->getNoOfColumns() != tableS.m_dictTable->getNoOfColumns())
+  {
+    ndbout_c("m_columns.size %d != %d",tab->getNoOfColumns(),
+                       tableS.m_dictTable->getNoOfColumns());
+    return false;
+  }
+
+ for(int i = 0; i<tab->getNoOfColumns(); i++)
+  {
+    if(!tab->getColumn(i)->equal(*(tableS.m_dictTable->getColumn(i))))
+    {
+      ndbout_c("m_columns %s != %s",tab->getColumn(i)->getName(),
+                tableS.m_dictTable->getColumn(i)->getName());
+      return false;
+    }
+  }
+
+  return true;
+}
+
 bool
 BackupRestore::createSystable(const TableS & tables){
   if (!m_restore && !m_restore_meta && !m_restore_epoch)
diff --git a/storage/ndb/tools/restore/consumer_restore.hpp b/storage/ndb/tools/restore/consumer_restore.hpp
index 5063619d3c3..0bc9d8e8d20 100644
--- a/storage/ndb/tools/restore/consumer_restore.hpp
+++ b/storage/ndb/tools/restore/consumer_restore.hpp
@@ -73,6 +73,7 @@ public:
   virtual bool finalize_table(const TableS &);
   virtual bool has_temp_error();
   virtual bool createSystable(const TableS & table);
+  virtual bool table_equal(const TableS & table);
   virtual bool update_apply_status(const RestoreMetaData &metaData);
   void connectToMysql();
   bool map_in_frm(char *new_data, const char *data,
diff --git a/storage/ndb/tools/restore/restore_main.cpp b/storage/ndb/tools/restore/restore_main.cpp
index 88511880480..8353f049647 100644
--- a/storage/ndb/tools/restore/restore_main.cpp
+++ b/storage/ndb/tools/restore/restore_main.cpp
@@ -61,6 +61,7 @@ NDB_STD_OPTS_VARS;
 static bool ga_restore_epoch = false;
 static bool ga_restore = false;
 static bool ga_print = false;
+static bool ga_skip_table_check = false;
 static int _print = 0;
 static int _print_meta = 0;
 static int _print_data = 0;
@@ -124,6 +125,9 @@ static struct my_option my_long_options[] =
     NDB_REP_DB "." NDB_APPLY_TABLE " with id 0 will be updated/inserted.", 
     (gptr*) &ga_restore_epoch, (gptr*) &ga_restore_epoch,  0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
+  { "skip-table-check", 's', "Skip table structure check during restore of data",
+   (gptr*) &ga_skip_table_check, (gptr*) &ga_skip_table_check, 0,
+   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "parallelism", 'p',
     "No of parallel transactions during restore of data."
     "(parallelism can be 1 to 1024)", 
@@ -640,6 +644,8 @@ main(int argc, char** argv)
   g_options.appfmt(" -n %d", ga_nodeId);
   if (_restore_meta)
     g_options.appfmt(" -m");
+  if (ga_skip_table_check)
+    g_options.appfmt(" -s");
   if (_restore_data)
     g_options.appfmt(" -r");
   if (ga_restore_epoch)
@@ -803,6 +809,20 @@ main(int argc, char** argv)
   {
     if(_restore_data || _print_data)
     {
+      if (!ga_skip_table_check){
+        for(i=0; i < metaData.getNoOfTables(); i++){
+          if (checkSysTable(metaData, i))
+          {
+            for(Uint32 j= 0; j < g_consumers.size(); j++)
+              if (!g_consumers[j]->table_equal(* metaData[i]))
+              {
+                err << "Restore: Failed to restore data, ";
+                err << metaData[i]->getTableName() << " table structure doesn't match backup ... Exiting " << endl;
+                exitHandler(NDBT_FAILED);
+              }
+          }
+        }
+      }
       RestoreDataIterator dataIter(metaData, &free_data_callback);
       
       // Read data file header
diff --git a/support-files/compiler_warnings.supp b/support-files/compiler_warnings.supp
index babc482976d..04f5a30bafa 100644
--- a/support-files/compiler_warnings.supp
+++ b/support-files/compiler_warnings.supp
@@ -1,3 +1,8 @@
+#
+# This file contains compiler warnings that can
+# be ignored for various reasons.
+#
+
 integer.cpp: .*control reaches end of non-void function.*: 1288-1427
 DictTabInfo.cpp : .*invalid access to non-static.*
 DictTabInfo.cpp : .*macro was used incorrectly.*