From e0e235c3220e2db71f30d8073f2ca69733477599 Mon Sep 17 00:00:00 2001
From: "SergeyV@selena." <>
Date: Tue, 30 Aug 2005 17:22:19 +0400
Subject: [PATCH 01/15] Fixes bug #12517. Clear user variables and replication
 events before closing temp tables in thread cleanup.

---
 mysql-test/r/connect.result | 16 ++++++++++++++++
 mysql-test/t/connect.test   | 18 ++++++++++++++++++
 sql/sql_class.cc            |  4 ++--
 3 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/mysql-test/r/connect.result b/mysql-test/r/connect.result
index edf30e7f6e4..293ad37c31a 100644
--- a/mysql-test/r/connect.result
+++ b/mysql-test/r/connect.result
@@ -65,3 +65,19 @@ show tables;
 Tables_in_test
 delete from mysql.user where user=_binary"test";
 flush privileges;
+use test;
+drop table if exists t1;
+Warnings:
+Note	1051	Unknown table 't1'
+create table t1 (id integer not null auto_increment primary key);
+drop table if exists t2;
+Warnings:
+Note	1051	Unknown table 't2'
+create temporary table t2(id integer not null auto_increment primary key);
+set @id := 1;
+delete from t1 where id like @id;
+use test;
+drop table if exists t2;
+Warnings:
+Note	1051	Unknown table 't2'
+drop table if exists t1;
diff --git a/mysql-test/t/connect.test b/mysql-test/t/connect.test
index 1a6dca5b69e..9acc18a0cee 100644
--- a/mysql-test/t/connect.test
+++ b/mysql-test/t/connect.test
@@ -77,4 +77,22 @@ show tables;
 delete from mysql.user where user=_binary"test";
 flush privileges;
 
+# Test for bug #12517.
+connect (con2,localhost,root,,test);
+connection con2;
+use test;
+drop table if exists t1;
+create table t1 (id integer not null auto_increment primary key);
+drop table if exists t2;
+create temporary table t2(id integer not null auto_increment primary key);
+set @id := 1;
+delete from t1 where id like @id;
+disconnect con2;
+sleep 5;
+connect (con1,localhost,root,,test);
+connection con1;
+use test;
+drop table if exists t2;
+drop table if exists t1;
+
 # End of 4.1 tests
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index e845769d7ad..11b45b848c8 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -353,12 +353,12 @@ void THD::cleanup(void)
   mysql_ha_flush(this, (TABLE_LIST*) 0,
                  MYSQL_HA_CLOSE_FINAL | MYSQL_HA_FLUSH_ALL);
   hash_free(&handler_tables_hash);
+  delete_dynamic(&user_var_events);
+  hash_free(&user_vars);
   close_temporary_tables(this);
   my_free((char*) variables.time_format, MYF(MY_ALLOW_ZERO_PTR));
   my_free((char*) variables.date_format, MYF(MY_ALLOW_ZERO_PTR));
   my_free((char*) variables.datetime_format, MYF(MY_ALLOW_ZERO_PTR));
-  delete_dynamic(&user_var_events);
-  hash_free(&user_vars);
   if (global_read_lock)
     unlock_global_read_lock(this);
   if (ull)

From 5e5184752d26956a9b42bc6b97269b1d4a019ba2 Mon Sep 17 00:00:00 2001
From: "kent@mysql.com" <>
Date: Fri, 2 Sep 2005 10:44:20 +0200
Subject: [PATCH 02/15] configure.in:   Back port of code to find the right
 'ps' settings

---
 configure.in | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/configure.in b/configure.in
index 83685009ee6..2dd502b31b7 100644
--- a/configure.in
+++ b/configure.in
@@ -447,30 +447,33 @@ PS=$ac_cv_path_PS
 # Linux style
 if $PS p $$ 2> /dev/null | grep $0 > /dev/null
 then
-  FIND_PROC="$PS p \$\$PID | grep mysqld > /dev/null"
+  FIND_PROC="$PS p \$\$PID | grep -v grep | grep mysqld > /dev/null"
 # Solaris
 elif $PS -fp $$ 2> /dev/null | grep $0 > /dev/null
 then
-  FIND_PROC="$PS -p \$\$PID | grep mysqld > /dev/null"
+  FIND_PROC="$PS -p \$\$PID | grep -v grep | grep mysqld > /dev/null"
 # BSD style
 elif $PS -uaxww 2> /dev/null | grep $0 > /dev/null
 then
-  FIND_PROC="$PS -uaxww | grep mysqld | grep \" \$\$PID \" > /dev/null"
+  FIND_PROC="$PS -uaxww | grep -v grep | grep mysqld | grep \" \$\$PID \" > /dev/null"
 # SysV style
 elif $PS -ef 2> /dev/null | grep $0 > /dev/null
 then
-  FIND_PROC="$PS -ef | grep mysqld | grep \" \$\$PID \" > /dev/null"
+  FIND_PROC="$PS -ef | grep -v grep | grep mysqld | grep \" \$\$PID \" > /dev/null"
 # Do anybody use this?
 elif $PS $$ 2> /dev/null | grep $0 > /dev/null
 then
-  FIND_PROC="$PS \$\$PID | grep mysqld > /dev/null"
+  FIND_PROC="$PS \$\$PID | grep -v grep | grep mysqld > /dev/null"
 else
   case $SYSTEM_TYPE in
+    *freebsd*)
+      FIND_PROC="$PS p \$\$PID | grep -v grep | grep mysqld > /dev/null"
+      ;;
     *darwin*)
-      FIND_PROC="$PS -uaxww | grep mysqld | grep \" \$\$PID \" > /dev/null"
+      FIND_PROC="$PS -uaxww | grep -v grep | grep mysqld | grep \" \$\$PID \" > /dev/null"
       ;;
     *cygwin*)
-      FIND_PROC="$PS -e | grep mysqld | grep \" \$\$PID \" > /dev/null"
+      FIND_PROC="$PS -e | grep -v grep | grep mysqld | grep \" \$\$PID \" > /dev/null"
       ;;
     *netware* | *modesto*)
       FIND_PROC=

From bfd4b626a1e5bc0d3e6a7bc9887079ad359b82d3 Mon Sep 17 00:00:00 2001
From: "stewart@mysql.com" <>
Date: Fri, 2 Sep 2005 19:09:20 +1000
Subject: [PATCH 03/15] BUG#11607 Incorrect error code returned on deletion

Save error on first failure.

At end of execute, if the current error is 4350 (transaction already aborted), restore
the original error (if there was one).
---
 ndb/src/ndbapi/NdbConnection.cpp | 26 ++++++++++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

diff --git a/ndb/src/ndbapi/NdbConnection.cpp b/ndb/src/ndbapi/NdbConnection.cpp
index e1f70160fb7..c9e26f8ccaf 100644
--- a/ndb/src/ndbapi/NdbConnection.cpp
+++ b/ndb/src/ndbapi/NdbConnection.cpp
@@ -280,6 +280,7 @@ NdbConnection::execute(ExecType aTypeOfExec,
 		       AbortOption abortOption,
 		       int forceSend)
 {
+  NdbError savedError= theError;
   DBUG_ENTER("NdbConnection::execute");
   DBUG_PRINT("enter", ("aTypeOfExec: %d, abortOption: %d", 
 		       aTypeOfExec, abortOption));
@@ -309,7 +310,11 @@ NdbConnection::execute(ExecType aTypeOfExec,
         NdbBlob* tBlob = tPrepOp->theBlobList;
         while (tBlob != NULL) {
           if (tBlob->preExecute(tExecType, batch) == -1)
+	  {
             ret = -1;
+	    if(savedError.code==0)
+	      savedError= theError;
+	  }
           tBlob = tBlob->theNext;
         }
         if (batch) {
@@ -338,7 +343,11 @@ NdbConnection::execute(ExecType aTypeOfExec,
           NdbBlob* tBlob = tOp->theBlobList;
           while (tBlob != NULL) {
             if (tBlob->preCommit() == -1)
-              ret = -1;
+	    {
+	      ret = -1;
+	      if(savedError.code==0)
+		savedError= theError;
+	    }
             tBlob = tBlob->theNext;
           }
         }
@@ -360,7 +369,12 @@ NdbConnection::execute(ExecType aTypeOfExec,
     }
 
     if (executeNoBlobs(tExecType, abortOption, forceSend) == -1)
-        ret = -1;
+    {
+      ret = -1;
+      if(savedError.code==0)
+	savedError= theError;
+    }
+
 #ifdef ndb_api_crash_on_complex_blob_abort
     assert(theFirstOpInList == NULL && theLastOpInList == NULL);
 #else
@@ -375,7 +389,11 @@ NdbConnection::execute(ExecType aTypeOfExec,
           while (tBlob != NULL) {
             // may add new operations if batch
             if (tBlob->postExecute(tExecType) == -1)
+	    {
               ret = -1;
+	      if(savedError.code==0)
+		savedError= theError;
+	    }
             tBlob = tBlob->theNext;
           }
         }
@@ -406,6 +424,10 @@ NdbConnection::execute(ExecType aTypeOfExec,
     ndbout << "completed ops: " << n << endl;
   }
 #endif
+
+  if(savedError.code!=0 && theError.code==4350) // Trans already aborted
+      theError= savedError;
+
   DBUG_RETURN(ret);
 }
 

From 5b65d8fb034f1758a167c92f3cacfa49df47cfdc Mon Sep 17 00:00:00 2001
From: "kent@mysql.com" <>
Date: Fri, 2 Sep 2005 11:11:29 +0200
Subject: [PATCH 04/15] my_global.h:   Back port of QNX work around for rint()

---
 include/my_global.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/include/my_global.h b/include/my_global.h
index e2a97667a1f..483cd135d53 100644
--- a/include/my_global.h
+++ b/include/my_global.h
@@ -297,6 +297,11 @@ C_MODE_END
 #undef  HAVE_FINITE
 #undef  LONGLONG_MIN            /* These get wrongly defined in QNX 6.2 */
 #undef  LONGLONG_MAX            /* standard system library 'limits.h' */
+#ifdef __cplusplus
+#define HAVE_RINT               /* rint() and isnan() functions are not */
+#define rint(a) std::rint(a)    /* visible in C++ scope due to an error */
+#define isnan(a) std::isnan(a)  /* in the usr/include/math.h on QNX     */
+#endif
 #endif
 
 /* We can not live without the following defines */

From 14485e71c2803b50ff57441630c8d92551d6fc68 Mon Sep 17 00:00:00 2001
From: "hartmut@mysql.com" <>
Date: Fri, 2 Sep 2005 22:52:52 +0200
Subject: [PATCH 05/15] fix for BUG#12958 : mysqlimport with -L option crashing
 on HP-UX

---
 client/mysqlimport.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/client/mysqlimport.c b/client/mysqlimport.c
index 24392fedc1f..4bf4974748b 100644
--- a/client/mysqlimport.c
+++ b/client/mysqlimport.c
@@ -37,8 +37,9 @@ static char *add_load_option(char *ptr,const char *object,
 			     const char *statement);
 
 static my_bool	verbose=0,lock_tables=0,ignore_errors=0,opt_delete=0,
-		replace=0,silent=0,ignore=0,opt_compress=0,opt_local_file=0,
+		replace=0,silent=0,ignore=0,opt_compress=0,
                 opt_low_priority= 0, tty_password= 0;
+static uint     opt_local_file=0;
 static MYSQL	mysql_connection;
 static char	*opt_password=0, *current_user=0,
 		*current_host=0, *current_db=0, *fields_terminated=0,

From af9740d0fd82fbcde0237ac08911aaee99fbaa68 Mon Sep 17 00:00:00 2001
From: "igor@rurik.mysql.com" <>
Date: Tue, 6 Sep 2005 22:20:11 -0700
Subject: [PATCH 06/15] func_gconcat.result, func_gconcat.test:   Added test
 cases for bug #12863. item_sum.cc, item_sum.h:   Fixed bug #12863.   Added a
 flag to Item_func_group_concat set to FALSE after   concatenation of the
 first element of a group.

---
 mysql-test/r/func_gconcat.result | 20 ++++++++++++++++++++
 mysql-test/t/func_gconcat.test   | 16 ++++++++++++++++
 sql/item_sum.cc                  |  8 +++++---
 sql/item_sum.h                   |  1 +
 4 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/mysql-test/r/func_gconcat.result b/mysql-test/r/func_gconcat.result
index 12bc5ca2582..9c0c05ae296 100644
--- a/mysql-test/r/func_gconcat.result
+++ b/mysql-test/r/func_gconcat.result
@@ -560,3 +560,23 @@ group_concat('x')
 NULL
 1
 drop table t1;
+CREATE TABLE t1 (id int, a varchar(9));
+INSERT INTO t1 VALUES
+(2, ''), (1, ''), (2, 'x'), (1, 'y'), (3, 'z'), (3, '');
+SELECT GROUP_CONCAT(a) FROM t1;
+GROUP_CONCAT(a)
+,,x,y,z,
+SELECT GROUP_CONCAT(a ORDER BY a) FROM t1;
+GROUP_CONCAT(a ORDER BY a)
+,,,x,y,z
+SELECT GROUP_CONCAT(a) FROM t1 GROUP BY id;
+GROUP_CONCAT(a)
+,y
+,x
+z,
+SELECT GROUP_CONCAT(a ORDER BY a) FROM t1 GROUP BY id;
+GROUP_CONCAT(a ORDER BY a)
+,y
+,x
+,z
+DROP TABLE t1;
diff --git a/mysql-test/t/func_gconcat.test b/mysql-test/t/func_gconcat.test
index 9e003d19ab9..aa8ce0f4bdc 100644
--- a/mysql-test/t/func_gconcat.test
+++ b/mysql-test/t/func_gconcat.test
@@ -356,4 +356,20 @@ select * from (select group_concat(a) from t1) t2;
 select group_concat('x') UNION ALL select 1;
 drop table t1;
 
+#
+# Bug #12863 : missing separators after first empty cancatanated elements
+#
+
+CREATE TABLE t1 (id int, a varchar(9));
+INSERT INTO t1 VALUES
+  (2, ''), (1, ''), (2, 'x'), (1, 'y'), (3, 'z'), (3, '');
+
+SELECT GROUP_CONCAT(a) FROM t1;
+SELECT GROUP_CONCAT(a ORDER BY a) FROM t1;
+
+SELECT GROUP_CONCAT(a) FROM t1 GROUP BY id;
+SELECT GROUP_CONCAT(a ORDER BY a) FROM t1 GROUP BY id;
+
+DROP TABLE t1;
+
 # End of 4.1 tests
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index 000dcdb4997..7f13fdf82b2 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -1664,7 +1664,9 @@ int dump_leaf_key(byte* key, uint32 count __attribute__((unused)),
   char buff[MAX_FIELD_WIDTH];
   String tmp((char *)&buff,sizeof(buff),default_charset_info), tmp2;
 
-  if (item->result.length())
+  if (item->no_appended)
+    item->no_appended= FALSE;
+  else
     item->result.append(*item->separator);
 
   tmp.length(0);
@@ -1856,6 +1858,7 @@ void Item_func_group_concat::clear()
   result.copy();
   null_value= TRUE;
   warning_for_row= FALSE;
+  no_appended= TRUE;
   if (tree_mode)
     reset_tree(tree);
 }
@@ -1898,8 +1901,7 @@ bool Item_func_group_concat::add()
 
 void Item_func_group_concat::reset_field()
 {
-  if (tree_mode)
-    reset_tree(tree);
+  DBUG_ASSERT(0);
 }
 
 
diff --git a/sql/item_sum.h b/sql/item_sum.h
index a3b422565d1..d53d8d861ae 100644
--- a/sql/item_sum.h
+++ b/sql/item_sum.h
@@ -709,6 +709,7 @@ class Item_func_group_concat : public Item_sum
   uint arg_count_field;
   uint field_list_offset;
   uint count_cut_values;
+  bool no_appended;
   /*
     Following is 0 normal object and pointer to original one for copy 
     (to correctly free resources)

From 78eaeb6d814aced99ed867bd90e837e82b0e0919 Mon Sep 17 00:00:00 2001
From: "tomas@poseidon.ndb.mysql.com" <>
Date: Wed, 7 Sep 2005 12:49:11 +0200
Subject: [PATCH 07/15] Modified ndb log message on startup failure

---
 ndb/src/kernel/main.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ndb/src/kernel/main.cpp b/ndb/src/kernel/main.cpp
index aa220b0ae05..d9953b920d2 100644
--- a/ndb/src/kernel/main.cpp
+++ b/ndb/src/kernel/main.cpp
@@ -394,5 +394,5 @@ handler_sigusr1(int signum)
     failed_startups++;
     failed_startup_flag = true;
   }
-  g_eventLogger.info("Received signal %d. Ndbd failed startup (%u).", signum, failed_startups);
+  g_eventLogger.info("Angel received ndbd startup failure count %u.", failed_startups);
 }

From 668f0e10fabf9779a61bc07df6a329f0f2bd64a8 Mon Sep 17 00:00:00 2001
From: "SergeyV@selena." <>
Date: Thu, 8 Sep 2005 12:09:30 +0400
Subject: [PATCH 08/15] Modified test case for bug #12517

---
 mysql-test/r/connect.result | 14 ++------------
 mysql-test/t/connect.test   | 20 ++++++++++----------
 2 files changed, 12 insertions(+), 22 deletions(-)

diff --git a/mysql-test/r/connect.result b/mysql-test/r/connect.result
index 293ad37c31a..68c86b80e60 100644
--- a/mysql-test/r/connect.result
+++ b/mysql-test/r/connect.result
@@ -1,3 +1,4 @@
+drop table if exists t1,t2;
 show tables;
 Tables_in_mysql
 columns_priv
@@ -65,19 +66,8 @@ show tables;
 Tables_in_test
 delete from mysql.user where user=_binary"test";
 flush privileges;
-use test;
-drop table if exists t1;
-Warnings:
-Note	1051	Unknown table 't1'
 create table t1 (id integer not null auto_increment primary key);
-drop table if exists t2;
-Warnings:
-Note	1051	Unknown table 't2'
 create temporary table t2(id integer not null auto_increment primary key);
 set @id := 1;
 delete from t1 where id like @id;
-use test;
-drop table if exists t2;
-Warnings:
-Note	1051	Unknown table 't2'
-drop table if exists t1;
+drop table t1;
diff --git a/mysql-test/t/connect.test b/mysql-test/t/connect.test
index 9acc18a0cee..ff15d74e5ac 100644
--- a/mysql-test/t/connect.test
+++ b/mysql-test/t/connect.test
@@ -6,6 +6,10 @@
 # This test makes no sense with the embedded server
 --source include/not_embedded.inc
 
+--disable_warnings
+drop table if exists t1,t2;
+--enable_warnings
+
 #connect (con1,localhost,root,,"");
 #show tables;
 connect (con1,localhost,root,,mysql);
@@ -77,22 +81,18 @@ show tables;
 delete from mysql.user where user=_binary"test";
 flush privileges;
 
-# Test for bug #12517.
+#
+# Bug#12517: Clear user variables and replication events before 
+#            closing temp tables in thread cleanup.
 connect (con2,localhost,root,,test);
 connection con2;
-use test;
-drop table if exists t1;
 create table t1 (id integer not null auto_increment primary key);
-drop table if exists t2;
 create temporary table t2(id integer not null auto_increment primary key);
 set @id := 1;
 delete from t1 where id like @id;
 disconnect con2;
-sleep 5;
-connect (con1,localhost,root,,test);
-connection con1;
-use test;
-drop table if exists t2;
-drop table if exists t1;
+--sleep 5
+connection default;
+drop table t1;
 
 # End of 4.1 tests

From 06345424586790b975a522b89e19c2d91a1df112 Mon Sep 17 00:00:00 2001
From: "tomas@poseidon.ndb.mysql.com" <>
Date: Thu, 8 Sep 2005 11:34:55 +0200
Subject: [PATCH 09/15] Bug #13054  	start backup command return may be
 interrpted

---
 ndb/include/kernel/signaldata/BackupImpl.hpp  |   9 +-
 .../kernel/signaldata/BackupSignalData.hpp    |   5 +-
 .../kernel/signaldata/NFCompleteRep.hpp       |  18 +-
 ndb/include/kernel/signaldata/NodeFailRep.hpp |  28 +-
 ndb/src/kernel/blocks/backup/Backup.cpp       |  42 ++-
 ndb/src/kernel/blocks/backup/Backup.hpp       |   1 +
 ndb/src/mgmsrv/MgmtSrvr.cpp                   | 265 ++++++++---------
 ndb/src/mgmsrv/MgmtSrvr.hpp                   |   3 -
 ndb/src/ndbapi/Makefile.am                    |   3 +-
 ndb/src/ndbapi/SignalSender.cpp               | 270 ++++++++++++++++++
 ndb/src/ndbapi/SignalSender.hpp               |  83 ++++++
 11 files changed, 527 insertions(+), 200 deletions(-)
 create mode 100644 ndb/src/ndbapi/SignalSender.cpp
 create mode 100644 ndb/src/ndbapi/SignalSender.hpp

diff --git a/ndb/include/kernel/signaldata/BackupImpl.hpp b/ndb/include/kernel/signaldata/BackupImpl.hpp
index 2032e2347b5..298440ad377 100644
--- a/ndb/include/kernel/signaldata/BackupImpl.hpp
+++ b/ndb/include/kernel/signaldata/BackupImpl.hpp
@@ -33,7 +33,7 @@ class DefineBackupReq {
 
   friend bool printDEFINE_BACKUP_REQ(FILE *, const Uint32 *, Uint32, Uint16);
 public:
-  STATIC_CONST( SignalLength = 8 + NdbNodeBitmask::Size);
+  STATIC_CONST( SignalLength = 9 + NdbNodeBitmask::Size);
 
 private:
   /**
@@ -60,6 +60,13 @@ private:
    * Length of backup data
    */
   Uint32 backupDataLen;
+
+  /**
+   * Backup flags
+   */
+  /* & 0x3 - waitCompleted
+   */
+  Uint32 flags;
 };
 
 class DefineBackupRef {
diff --git a/ndb/include/kernel/signaldata/BackupSignalData.hpp b/ndb/include/kernel/signaldata/BackupSignalData.hpp
index b38dd8d14b2..e1b8c6203a1 100644
--- a/ndb/include/kernel/signaldata/BackupSignalData.hpp
+++ b/ndb/include/kernel/signaldata/BackupSignalData.hpp
@@ -36,11 +36,14 @@ class BackupReq {
 
   friend bool printBACKUP_REQ(FILE *, const Uint32 *, Uint32, Uint16);
 public:
-  STATIC_CONST( SignalLength = 2 );
+  STATIC_CONST( SignalLength = 3 );
 
 private:
   Uint32 senderData;
   Uint32 backupDataLen;
+  /* & 0x3 - waitCompleted
+   */
+  Uint32 flags;
 };
 
 class BackupData {
diff --git a/ndb/include/kernel/signaldata/NFCompleteRep.hpp b/ndb/include/kernel/signaldata/NFCompleteRep.hpp
index c8bde705a86..764da85b163 100644
--- a/ndb/include/kernel/signaldata/NFCompleteRep.hpp
+++ b/ndb/include/kernel/signaldata/NFCompleteRep.hpp
@@ -30,28 +30,12 @@
  * from the failed NDB node
  *
  */
-class NFCompleteRep {
-  /**
-   * Sender(s)
-   */
-  friend class Dbdict;
-  friend class Dblqh;
-  friend class Dbtc;
-  friend class Qmgr;
-  
-  /**
-   * Sender/Reciver
-   */
-  friend class Dbdih;
-  friend class ClusterMgr;
+struct NFCompleteRep {
 
   friend bool printNF_COMPLETE_REP(FILE *, const Uint32 *, Uint32, Uint16);
   
-public:
   STATIC_CONST( SignalLength = 5 );
 
-private:
-  
   /**
    * Which block has completed...
    *
diff --git a/ndb/include/kernel/signaldata/NodeFailRep.hpp b/ndb/include/kernel/signaldata/NodeFailRep.hpp
index 060acd6a3e2..fe57ba1a712 100644
--- a/ndb/include/kernel/signaldata/NodeFailRep.hpp
+++ b/ndb/include/kernel/signaldata/NodeFailRep.hpp
@@ -24,34 +24,8 @@
  * This signals is sent by Qmgr to NdbCntr
  *   and then from NdbCntr sent to: dih, dict, lqh, tc & API
  */
-class NodeFailRep {
-  /**
-   * Sender(s)
-   */
-  friend class Qmgr;
-  
-  /**
-   * Sender(s) / Reciver(s)
-   */
-  friend class Ndbcntr;
-  friend class Dbdict;
-  
-  /**
-   * Reciver(s)
-   */
-  friend class Dbdih;
-  friend class Dblqh;
-  friend class Dbtc;
-  friend class ClusterMgr;
-  friend class Trix;
-  friend class Backup;
-  friend class Suma;
-  friend class Grep;
-  friend class SafeCounterManager;
-
-public:
+struct NodeFailRep {
   STATIC_CONST( SignalLength = 3 + NodeBitmask::Size );
-private:
   
   Uint32 failNo;
 
diff --git a/ndb/src/kernel/blocks/backup/Backup.cpp b/ndb/src/kernel/blocks/backup/Backup.cpp
index 3334d69ae89..04b5a00494c 100644
--- a/ndb/src/kernel/blocks/backup/Backup.cpp
+++ b/ndb/src/kernel/blocks/backup/Backup.cpp
@@ -69,6 +69,9 @@ static const Uint32 BACKUP_SEQUENCE = 0x1F000000;
 
 static Uint32 g_TypeOfStart = NodeState::ST_ILLEGAL_TYPE;
 
+#define SEND_BACKUP_STARTED_FLAG(A) (((A) & 0x3) > 0)
+#define SEND_BACKUP_COMPLETED_FLAG(A) (((A) & 0x3) > 1)
+
 void
 Backup::execSTTOR(Signal* signal) 
 {
@@ -852,7 +855,8 @@ Backup::execBACKUP_REQ(Signal* signal)
   const Uint32 senderData = req->senderData;
   const BlockReference senderRef = signal->senderBlockRef();
   const Uint32 dataLen32 = req->backupDataLen; // In 32 bit words
-  
+  const Uint32 flags = signal->getLength() > 2 ? req->flags : 2;
+
   if(getOwnNodeId() != getMasterNodeId()) {
     jam();
     sendBackupRef(senderRef, signal, senderData, BackupRef::IAmNotMaster);
@@ -894,6 +898,7 @@ Backup::execBACKUP_REQ(Signal* signal)
   ptr.p->errorCode = 0;
   ptr.p->clientRef = senderRef;
   ptr.p->clientData = senderData;
+  ptr.p->flags = flags;
   ptr.p->masterRef = reference();
   ptr.p->nodes = c_aliveNodes;
   ptr.p->backupId = 0;
@@ -931,7 +936,10 @@ void
 Backup::sendBackupRef(Signal* signal, BackupRecordPtr ptr, Uint32 errorCode)
 {
   jam();
-  sendBackupRef(ptr.p->clientRef, signal, ptr.p->clientData, errorCode);
+  if (SEND_BACKUP_STARTED_FLAG(ptr.p->flags))
+  {
+    sendBackupRef(ptr.p->clientRef, signal, ptr.p->clientData, errorCode);
+  }
   cleanup(signal, ptr);
 }
 
@@ -1098,6 +1106,7 @@ Backup::sendDefineBackupReq(Signal *signal, BackupRecordPtr ptr)
   req->backupKey[1] = ptr.p->backupKey[1];
   req->nodes = ptr.p->nodes;
   req->backupDataLen = ptr.p->backupDataLen;
+  req->flags = ptr.p->flags;
   
   ptr.p->masterData.gsn = GSN_DEFINE_BACKUP_REQ;
   ptr.p->masterData.sendCounter = ptr.p->nodes;
@@ -1193,13 +1202,18 @@ Backup::defineBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId)
   /**
    * Reply to client
    */
+  CRASH_INSERTION((10034));
+
   BackupConf * conf = (BackupConf*)signal->getDataPtrSend();
   conf->backupId = ptr.p->backupId;
   conf->senderData = ptr.p->clientData;
   conf->nodes = ptr.p->nodes;
-  sendSignal(ptr.p->clientRef, GSN_BACKUP_CONF, signal, 
-	     BackupConf::SignalLength, JBB);
-  
+  if (SEND_BACKUP_STARTED_FLAG(ptr.p->flags))
+  {
+    sendSignal(ptr.p->clientRef, GSN_BACKUP_CONF, signal, 
+	       BackupConf::SignalLength, JBB);
+  }
+
   signal->theData[0] = EventReport::BackupStarted;
   signal->theData[1] = ptr.p->clientRef;
   signal->theData[2] = ptr.p->backupId;
@@ -2090,9 +2104,12 @@ Backup::stopBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId)
     rep->noOfLogBytes = ptr.p->noOfLogBytes;
     rep->noOfLogRecords = ptr.p->noOfLogRecords;
     rep->nodes = ptr.p->nodes;
-    sendSignal(ptr.p->clientRef, GSN_BACKUP_COMPLETE_REP, signal,
-	       BackupCompleteRep::SignalLength, JBB);
-    
+    if (SEND_BACKUP_COMPLETED_FLAG(ptr.p->flags))
+    {
+      sendSignal(ptr.p->clientRef, GSN_BACKUP_COMPLETE_REP, signal,
+		 BackupCompleteRep::SignalLength, JBB);
+    }
+
     signal->theData[0] = EventReport::BackupCompleted;
     signal->theData[1] = ptr.p->clientRef;
     signal->theData[2] = ptr.p->backupId;
@@ -2133,9 +2150,11 @@ Backup::masterAbort(Signal* signal, BackupRecordPtr ptr)
   rep->backupId = ptr.p->backupId;
   rep->senderData = ptr.p->clientData;
   rep->reason = ptr.p->errorCode;
-  sendSignal(ptr.p->clientRef, GSN_BACKUP_ABORT_REP, signal, 
-	     BackupAbortRep::SignalLength, JBB);
-  
+  if (SEND_BACKUP_COMPLETED_FLAG(ptr.p->flags))
+  {
+    sendSignal(ptr.p->clientRef, GSN_BACKUP_ABORT_REP, signal, 
+	       BackupAbortRep::SignalLength, JBB);
+  }
   signal->theData[0] = EventReport::BackupAborted;
   signal->theData[1] = ptr.p->clientRef;
   signal->theData[2] = ptr.p->backupId;
@@ -2267,6 +2286,7 @@ Backup::execDEFINE_BACKUP_REQ(Signal* signal)
   ptr.p->errorCode = 0;
   ptr.p->clientRef = req->clientRef;
   ptr.p->clientData = req->clientData;
+  ptr.p->flags = req->flags;
   ptr.p->masterRef = senderRef;
   ptr.p->nodes = req->nodes;
   ptr.p->backupId = backupId;
diff --git a/ndb/src/kernel/blocks/backup/Backup.hpp b/ndb/src/kernel/blocks/backup/Backup.hpp
index 7bcea5655b4..7780d05ab9e 100644
--- a/ndb/src/kernel/blocks/backup/Backup.hpp
+++ b/ndb/src/kernel/blocks/backup/Backup.hpp
@@ -413,6 +413,7 @@ public:
     
     Uint32 clientRef;
     Uint32 clientData;
+    Uint32 flags;
     Uint32 backupId;
     Uint32 backupKey[2];
     Uint32 masterRef;
diff --git a/ndb/src/mgmsrv/MgmtSrvr.cpp b/ndb/src/mgmsrv/MgmtSrvr.cpp
index acab2ef9eac..e9d3ce19076 100644
--- a/ndb/src/mgmsrv/MgmtSrvr.cpp
+++ b/ndb/src/mgmsrv/MgmtSrvr.cpp
@@ -39,6 +39,8 @@
 #include <signaldata/BackupSignalData.hpp>
 #include <signaldata/GrepImpl.hpp>
 #include <signaldata/ManagementServer.hpp>
+#include <signaldata/NFCompleteRep.hpp>
+#include <signaldata/NodeFailRep.hpp>
 #include <NdbSleep.h>
 #include <EventLogger.hpp>
 #include <DebuggerNames.hpp>
@@ -56,6 +58,8 @@
 #include <mgmapi_config_parameters.h>
 #include <m_string.h>
 
+#include <SignalSender.hpp>
+
 //#define MGM_SRV_DEBUG
 #ifdef MGM_SRV_DEBUG
 #define DEBUG(x) do ndbout << x << endl; while(0)
@@ -709,6 +713,15 @@ int MgmtSrvr::okToSendTo(NodeId processId, bool unCond)
   }
 }
 
+void report_unknown_signal(SimpleSignal *signal)
+{
+  g_eventLogger.error("Unknown signal received. SignalNumber: "
+		      "%i from (%d, %x)",
+		      signal->readSignalNumber(),
+		      refToNode(signal->header.theSendersBlockRef),
+		      refToBlock(signal->header.theSendersBlockRef));
+}
+
 /*****************************************************************************
  * Starting and stopping database nodes
  ****************************************************************************/
@@ -1911,81 +1924,6 @@ MgmtSrvr::handleReceivedSignal(NdbApiSignal* signal)
   }
     break;
     
-  case GSN_BACKUP_CONF:{
-    const BackupConf * const conf = 
-      CAST_CONSTPTR(BackupConf, signal->getDataPtr());
-    BackupEvent event;
-    event.Event = BackupEvent::BackupStarted;
-    event.Started.BackupId = conf->backupId;
-    event.Nodes = conf->nodes;
-#ifdef VM_TRACE
-    ndbout_c("Backup master is %d", refToNode(signal->theSendersBlockRef));
-#endif
-    backupCallback(event);
-  }
-    break;
-
-  case GSN_BACKUP_REF:{
-    const BackupRef * const ref = 
-      CAST_CONSTPTR(BackupRef, signal->getDataPtr());
-    Uint32 errCode = ref->errorCode;
-    if(ref->errorCode == BackupRef::IAmNotMaster){
-      const Uint32 aNodeId = refToNode(ref->masterRef);
-#ifdef VM_TRACE
-      ndbout_c("I'm not master resending to %d", aNodeId);
-#endif
-      theWaitNode= aNodeId;
-      NdbApiSignal aSignal(_ownReference);
-      BackupReq* req = CAST_PTR(BackupReq, aSignal.getDataPtrSend());
-      aSignal.set(TestOrd::TraceAPI, BACKUP, GSN_BACKUP_REQ, 
-		  BackupReq::SignalLength);
-      req->senderData = 19;
-      req->backupDataLen = 0;
-      
-      int i = theFacade->sendSignalUnCond(&aSignal, aNodeId);
-      if(i == 0){
-	return;
-      }
-      errCode = 5030;
-    }
-    BackupEvent event;
-    event.Event = BackupEvent::BackupFailedToStart;
-    event.FailedToStart.ErrorCode = errCode;
-    backupCallback(event);
-    break;
-  }
-
-  case GSN_BACKUP_ABORT_REP:{
-    const BackupAbortRep * const rep = 
-      CAST_CONSTPTR(BackupAbortRep, signal->getDataPtr());
-    BackupEvent event;
-    event.Event = BackupEvent::BackupAborted;
-    event.Aborted.Reason = rep->reason;
-    event.Aborted.BackupId = rep->backupId;
-    event.Aborted.ErrorCode = rep->reason;
-    backupCallback(event);
-  }
-  break;
-
-  case GSN_BACKUP_COMPLETE_REP:{
-    const BackupCompleteRep * const rep = 
-      CAST_CONSTPTR(BackupCompleteRep, signal->getDataPtr());
-    BackupEvent event;
-    event.Event = BackupEvent::BackupCompleted;
-    event.Completed.BackupId = rep->backupId;
-
-    event.Completed.NoOfBytes = rep->noOfBytes;
-    event.Completed.NoOfLogBytes = rep->noOfLogBytes;
-    event.Completed.NoOfRecords = rep->noOfRecords;
-    event.Completed.NoOfLogRecords = rep->noOfLogRecords;
-    event.Completed.stopGCP = rep->stopGCP;
-    event.Completed.startGCP = rep->startGCP;
-    event.Nodes = rep->nodes;
-
-    backupCallback(event);
-  }
-    break;
-
   case GSN_MGM_LOCK_CONFIG_REP:
   case GSN_MGM_LOCK_CONFIG_REQ:
   case GSN_MGM_UNLOCK_CONFIG_REP:
@@ -2446,6 +2384,9 @@ MgmtSrvr::eventReport(NodeId nodeId, const Uint32 * theData)
 int
 MgmtSrvr::startBackup(Uint32& backupId, int waitCompleted)
 {
+  SignalSender ss(theFacade);
+  ss.lock(); // lock will be released on exit
+
   bool next;
   NodeId nodeId = 0;
   while((next = getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)) == true &&
@@ -2453,49 +2394,125 @@ MgmtSrvr::startBackup(Uint32& backupId, int waitCompleted)
   
   if(!next) return NO_CONTACT_WITH_DB_NODES;
 
-  NdbApiSignal* signal = getSignal();
-  if (signal == NULL) {
-    return COULD_NOT_ALLOCATE_MEMORY;
-  }
+  SimpleSignal ssig;
 
-  BackupReq* req = CAST_PTR(BackupReq, signal->getDataPtrSend());
-  signal->set(TestOrd::TraceAPI, BACKUP, GSN_BACKUP_REQ, 
-	      BackupReq::SignalLength);
+  BackupReq* req = CAST_PTR(BackupReq, ssig.getDataPtrSend());
+  ssig.set(ss, TestOrd::TraceAPI, BACKUP, GSN_BACKUP_REQ, 
+	   BackupReq::SignalLength);
   
   req->senderData = 19;
   req->backupDataLen = 0;
+  assert(waitCompleted < 3);
+  req->flags = waitCompleted & 0x3;
 
-  int result;
-  if (waitCompleted == 2) {
-    result = sendRecSignal(nodeId, WAIT_BACKUP_COMPLETED,
-			   signal, true, 48*60*60*1000 /* 48 hours */);
-  }
-  else if (waitCompleted == 1) {
-    result = sendRecSignal(nodeId, WAIT_BACKUP_STARTED,
-			   signal, true, 5*60*1000 /*5 mins*/);
-  }
-  else {
-    result = sendRecSignal(nodeId, NO_WAIT, signal, true);
-  }
-  if (result == -1) {
-    return SEND_OR_RECEIVE_FAILED;
-  }
+  BackupEvent event;
+  int do_send = 1;
+  while (1) {
+    if (do_send)
+    {
+      SendStatus result = ss.sendSignal(nodeId, &ssig);
+      if (result != SEND_OK) {
+	return SEND_OR_RECEIVE_FAILED;
+      }
+      if (waitCompleted == 0)
+	return 0;
+      do_send = 0;
+    }
+    SimpleSignal *signal = ss.waitFor();
 
-  if (waitCompleted){
-    switch(m_lastBackupEvent.Event){
-    case BackupEvent::BackupCompleted:
-      backupId = m_lastBackupEvent.Completed.BackupId;
+    int gsn = signal->readSignalNumber();
+    switch (gsn) {
+    case GSN_BACKUP_CONF:{
+      const BackupConf * const conf = 
+	CAST_CONSTPTR(BackupConf, signal->getDataPtr());
+      event.Event = BackupEvent::BackupStarted;
+      event.Started.BackupId = conf->backupId;
+      event.Nodes = conf->nodes;
+#ifdef VM_TRACE
+      ndbout_c("Backup(%d) master is %d", conf->backupId,
+	       refToNode(signal->header.theSendersBlockRef));
+#endif
+      backupId = conf->backupId;
+      if (waitCompleted == 1)
+	return 0;
+      // wait for next signal
       break;
-    case BackupEvent::BackupStarted:
-      backupId = m_lastBackupEvent.Started.BackupId;
+    }
+    case GSN_BACKUP_COMPLETE_REP:{
+      const BackupCompleteRep * const rep = 
+	CAST_CONSTPTR(BackupCompleteRep, signal->getDataPtr());
+#ifdef VM_TRACE
+      ndbout_c("Backup(%d) completed %d", rep->backupId);
+#endif
+      event.Event = BackupEvent::BackupCompleted;
+      event.Completed.BackupId = rep->backupId;
+    
+      event.Completed.NoOfBytes = rep->noOfBytes;
+      event.Completed.NoOfLogBytes = rep->noOfLogBytes;
+      event.Completed.NoOfRecords = rep->noOfRecords;
+      event.Completed.NoOfLogRecords = rep->noOfLogRecords;
+      event.Completed.stopGCP = rep->stopGCP;
+      event.Completed.startGCP = rep->startGCP;
+      event.Nodes = rep->nodes;
+
+      backupId = rep->backupId;
+      return 0;
+    }
+    case GSN_BACKUP_REF:{
+      const BackupRef * const ref = 
+	CAST_CONSTPTR(BackupRef, signal->getDataPtr());
+      if(ref->errorCode == BackupRef::IAmNotMaster){
+	nodeId = refToNode(ref->masterRef);
+#ifdef VM_TRACE
+	ndbout_c("I'm not master resending to %d", nodeId);
+#endif
+	do_send = 1; // try again
+	continue;
+      }
+      event.Event = BackupEvent::BackupFailedToStart;
+      event.FailedToStart.ErrorCode = ref->errorCode;
+      return ref->errorCode;
+    }
+    case GSN_BACKUP_ABORT_REP:{
+      const BackupAbortRep * const rep = 
+	CAST_CONSTPTR(BackupAbortRep, signal->getDataPtr());
+      event.Event = BackupEvent::BackupAborted;
+      event.Aborted.Reason = rep->reason;
+      event.Aborted.BackupId = rep->backupId;
+      event.Aborted.ErrorCode = rep->reason;
+#ifdef VM_TRACE
+      ndbout_c("Backup %d aborted", rep->backupId);
+#endif
+      return rep->reason;
+    }
+    case GSN_NF_COMPLETEREP:{
+      const NFCompleteRep * const rep =
+	CAST_CONSTPTR(NFCompleteRep, signal->getDataPtr());
+#ifdef VM_TRACE
+      ndbout_c("Node %d fail completed", rep->failedNodeId);
+#endif
+      if (rep->failedNodeId == nodeId ||
+	  waitCompleted == 1)
+	return 1326;
+      // wait for next signal
+      // master node will report aborted backup
       break;
-    case BackupEvent::BackupFailedToStart:
-      return m_lastBackupEvent.FailedToStart.ErrorCode;
-    case BackupEvent::BackupAborted:
-      return m_lastBackupEvent.Aborted.ErrorCode;
+    }
+    case GSN_NODE_FAILREP:{
+      const NodeFailRep * const rep =
+	CAST_CONSTPTR(NodeFailRep, signal->getDataPtr());
+#ifdef VM_TRACE
+      ndbout_c("Node %d failed", rep->failNo);
+#endif
+      if (rep->failNo == nodeId ||
+	  waitCompleted == 1)
+      // wait for next signal
+      // master node will report aborted backup
+      break;
+    }
     default:
-      return -1;
-      break;
+      report_unknown_signal(signal);
+      return SEND_OR_RECEIVE_FAILED;
     }
   }
   
@@ -2535,36 +2552,6 @@ MgmtSrvr::abortBackup(Uint32 backupId)
   return 0;
 }
 
-void
-MgmtSrvr::backupCallback(BackupEvent & event)
-{
-  DBUG_ENTER("MgmtSrvr::backupCallback");
-  m_lastBackupEvent = event;
-  switch(event.Event){
-  case BackupEvent::BackupFailedToStart:
-    DBUG_PRINT("info",("BackupEvent::BackupFailedToStart"));
-    theWaitState = NO_WAIT;
-    break;
-  case BackupEvent::BackupAborted:
-    DBUG_PRINT("info",("BackupEvent::BackupAborted"));
-    theWaitState = NO_WAIT;
-    break;
-  case BackupEvent::BackupCompleted:
-    DBUG_PRINT("info",("BackupEvent::BackupCompleted"));
-    theWaitState = NO_WAIT;
-    break;
-  case BackupEvent::BackupStarted:
-    if(theWaitState == WAIT_BACKUP_STARTED)
-    {
-      DBUG_PRINT("info",("BackupEvent::BackupStarted NO_WAIT"));
-      theWaitState = NO_WAIT;
-    } else {
-      DBUG_PRINT("info",("BackupEvent::BackupStarted"));
-    }
-  }
-  DBUG_VOID_RETURN;
-}
-
 
 /*****************************************************************************
  * Global Replication
diff --git a/ndb/src/mgmsrv/MgmtSrvr.hpp b/ndb/src/mgmsrv/MgmtSrvr.hpp
index c132852338b..f8c244a1bf1 100644
--- a/ndb/src/mgmsrv/MgmtSrvr.hpp
+++ b/ndb/src/mgmsrv/MgmtSrvr.hpp
@@ -757,9 +757,6 @@ private:
   static void *signalRecvThread_C(void *);
   void signalRecvThreadRun();
   
-  void backupCallback(BackupEvent &);
-  BackupEvent m_lastBackupEvent;
-
   Config *_props;
 
   int send(class NdbApiSignal* signal, Uint32 node, Uint32 node_type);
diff --git a/ndb/src/ndbapi/Makefile.am b/ndb/src/ndbapi/Makefile.am
index 9f8a851b995..1ba80ef7d85 100644
--- a/ndb/src/ndbapi/Makefile.am
+++ b/ndb/src/ndbapi/Makefile.am
@@ -35,7 +35,8 @@ libndbapi_la_SOURCES = \
         NdbDictionaryImpl.cpp \
         DictCache.cpp \
         ndb_cluster_connection.cpp \
-	NdbBlob.cpp
+	NdbBlob.cpp \
+        SignalSender.cpp
 
 INCLUDES_LOC = -I$(top_srcdir)/ndb/src/mgmapi
 
diff --git a/ndb/src/ndbapi/SignalSender.cpp b/ndb/src/ndbapi/SignalSender.cpp
new file mode 100644
index 00000000000..0a23529dc73
--- /dev/null
+++ b/ndb/src/ndbapi/SignalSender.cpp
@@ -0,0 +1,270 @@
+/* Copyright (C) 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; 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 "SignalSender.hpp"
+#include <NdbSleep.h>
+#include <SignalLoggerManager.hpp>
+#include <signaldata/NFCompleteRep.hpp>
+#include <signaldata/NodeFailRep.hpp>
+
+SimpleSignal::SimpleSignal(bool dealloc){
+  memset(this, 0, sizeof(* this));
+  deallocSections = dealloc;
+}
+
+SimpleSignal::~SimpleSignal(){
+  if(!deallocSections)
+    return;
+  if(ptr[0].p != 0) delete []ptr[0].p;
+  if(ptr[1].p != 0) delete []ptr[1].p;
+  if(ptr[2].p != 0) delete []ptr[2].p;
+}
+
+void 
+SimpleSignal::set(class SignalSender& ss,
+		  Uint8  trace, Uint16 recBlock, Uint16 gsn, Uint32 len){
+  
+  header.theTrace                = trace;
+  header.theReceiversBlockNumber = recBlock;
+  header.theVerId_signalNumber   = gsn;
+  header.theLength               = len;
+  header.theSendersBlockRef      = refToBlock(ss.getOwnRef());
+}
+
+void
+SimpleSignal::print(FILE * out){
+  fprintf(out, "---- Signal ----------------\n");
+  SignalLoggerManager::printSignalHeader(out, header, 0, 0, false);
+  SignalLoggerManager::printSignalData(out, header, theData);
+  for(Uint32 i = 0; i<header.m_noOfSections; i++){
+    Uint32 len = ptr[i].sz;
+    fprintf(out, " --- Section %d size=%d ---\n", i, len);
+    Uint32 * signalData = ptr[i].p;
+    while(len >= 7){
+      fprintf(out, 
+              " H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x H\'%.8x\n",
+              signalData[0], signalData[1], signalData[2], signalData[3], 
+              signalData[4], signalData[5], signalData[6]);
+      len -= 7;
+      signalData += 7;
+    }
+    if(len > 0){
+      fprintf(out, " H\'%.8x", signalData[0]);
+      for(Uint32 i = 1; i<len; i++)
+        fprintf(out, " H\'%.8x", signalData[i]);
+      fprintf(out, "\n");
+    }
+  }
+}
+
+SignalSender::SignalSender(TransporterFacade *facade)
+  : m_lock(0)
+{
+  m_cond = NdbCondition_Create();
+  theFacade = facade;
+  m_blockNo = theFacade->open(this, execSignal, execNodeStatus);
+  assert(m_blockNo > 0);
+}
+
+SignalSender::~SignalSender(){
+  int i;
+  if (m_lock)
+    unlock();
+  theFacade->close(m_blockNo,0);
+  // free these _after_ closing theFacade to ensure that
+  // we delete all signals
+  for (i= m_jobBuffer.size()-1; i>= 0; i--)
+    delete m_jobBuffer[i];
+  for (i= m_usedBuffer.size()-1; i>= 0; i--)
+    delete m_usedBuffer[i];
+  NdbCondition_Destroy(m_cond);
+}
+
+int SignalSender::lock()
+{
+  if (NdbMutex_Lock(theFacade->theMutexPtr))
+    return -1;
+  m_lock= 1;
+  return 0;
+}
+
+int SignalSender::unlock()
+{
+  if (NdbMutex_Unlock(theFacade->theMutexPtr))
+    return -1;
+  m_lock= 0;
+  return 0;
+}
+
+Uint32
+SignalSender::getOwnRef() const {
+  return numberToRef(m_blockNo, theFacade->ownId());
+}
+
+Uint32
+SignalSender::getAliveNode() const{
+  return theFacade->get_an_alive_node();
+}
+
+const ClusterMgr::Node & 
+SignalSender::getNodeInfo(Uint16 nodeId) const {
+  return theFacade->theClusterMgr->getNodeInfo(nodeId);
+}
+
+Uint32
+SignalSender::getNoOfConnectedNodes() const {
+  return theFacade->theClusterMgr->getNoOfConnectedNodes();
+}
+
+SendStatus
+SignalSender::sendSignal(Uint16 nodeId, const SimpleSignal * s){
+  return theFacade->theTransporterRegistry->prepareSend(&s->header,
+							1, // JBB
+							&s->theData[0],
+							nodeId, 
+							&s->ptr[0]);
+}
+
+template<class T>
+SimpleSignal *
+SignalSender::waitFor(Uint32 timeOutMillis, T & t)
+{
+  SimpleSignal * s = t.check(m_jobBuffer);
+  if(s != 0){
+    return s;
+  }
+  
+  NDB_TICKS now = NdbTick_CurrentMillisecond();
+  NDB_TICKS stop = now + timeOutMillis;
+  Uint32 wait = (timeOutMillis == 0 ? 10 : timeOutMillis);
+  do {
+    NdbCondition_WaitTimeout(m_cond,
+			     theFacade->theMutexPtr, 
+			     wait);
+    
+    
+    SimpleSignal * s = t.check(m_jobBuffer);
+    if(s != 0){
+      m_usedBuffer.push_back(s);
+      return s;
+    }
+    
+    now = NdbTick_CurrentMillisecond();
+    wait = (timeOutMillis == 0 ? 10 : stop - now);
+  } while(stop > now || timeOutMillis == 0);
+  
+  return 0;
+} 
+
+class WaitForAny {
+public:
+  SimpleSignal * check(Vector<SimpleSignal*> & m_jobBuffer){
+    if(m_jobBuffer.size() > 0){
+      SimpleSignal * s = m_jobBuffer[0];
+      m_jobBuffer.erase(0);
+      return s;
+    }
+    return 0;
+  }
+};
+  
+SimpleSignal *
+SignalSender::waitFor(Uint32 timeOutMillis){
+  
+  WaitForAny w;
+  return waitFor(timeOutMillis, w);
+}
+
+class WaitForNode {
+public:
+  Uint32 m_nodeId;
+  SimpleSignal * check(Vector<SimpleSignal*> & m_jobBuffer){
+    Uint32 len = m_jobBuffer.size();
+    for(Uint32 i = 0; i<len; i++){
+      if(refToNode(m_jobBuffer[i]->header.theSendersBlockRef) == m_nodeId){
+	SimpleSignal * s = m_jobBuffer[i];
+	m_jobBuffer.erase(i);
+	return s;
+      }
+    }
+    return 0;
+  }
+};
+
+SimpleSignal *
+SignalSender::waitFor(Uint16 nodeId, Uint32 timeOutMillis){
+  
+  WaitForNode w;
+  w.m_nodeId = nodeId;
+  return waitFor(timeOutMillis, w);
+}
+
+#include <NdbApiSignal.hpp>
+
+void
+SignalSender::execSignal(void* signalSender, 
+			 NdbApiSignal* signal, 
+			 class LinearSectionPtr ptr[3]){
+  SimpleSignal * s = new SimpleSignal(true);
+  s->header = * signal;
+  memcpy(&s->theData[0], signal->getDataPtr(), 4 * s->header.theLength);
+  for(Uint32 i = 0; i<s->header.m_noOfSections; i++){
+    s->ptr[i].p = new Uint32[ptr[i].sz];
+    s->ptr[i].sz = ptr[i].sz;
+    memcpy(s->ptr[i].p, ptr[i].p, 4 * ptr[i].sz);
+  }
+  SignalSender * ss = (SignalSender*)signalSender;
+  ss->m_jobBuffer.push_back(s);
+  NdbCondition_Signal(ss->m_cond);
+}
+  
+void 
+SignalSender::execNodeStatus(void* signalSender, 
+			     Uint32 nodeId, 
+			     bool alive, 
+			     bool nfCompleted){
+  if (alive) {
+    // node connected
+    return;
+  }
+
+  SimpleSignal * s = new SimpleSignal(true);
+  SignalSender * ss = (SignalSender*)signalSender;
+
+  // node disconnected
+  if(nfCompleted)
+  {
+    // node shutdown complete
+    s->header.theVerId_signalNumber = GSN_NF_COMPLETEREP;
+    NFCompleteRep *rep = (NFCompleteRep *)s->getDataPtrSend();
+    rep->failedNodeId = nodeId;
+  }
+  else
+  {
+    // node failure
+    s->header.theVerId_signalNumber = GSN_NODE_FAILREP;
+    NodeFailRep *rep = (NodeFailRep *)s->getDataPtrSend();
+    rep->failNo = nodeId;
+  }
+
+  ss->m_jobBuffer.push_back(s);
+  NdbCondition_Signal(ss->m_cond);
+}
+
+template SimpleSignal* SignalSender::waitFor<WaitForNode>(unsigned, WaitForNode&);
+template SimpleSignal* SignalSender::waitFor<WaitForAny>(unsigned, WaitForAny&);
+template Vector<SimpleSignal*>;
+  
diff --git a/ndb/src/ndbapi/SignalSender.hpp b/ndb/src/ndbapi/SignalSender.hpp
new file mode 100644
index 00000000000..4b991460034
--- /dev/null
+++ b/ndb/src/ndbapi/SignalSender.hpp
@@ -0,0 +1,83 @@
+/* Copyright (C) 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; 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 */
+
+#ifndef SIGNAL_SENDER_HPP
+#define SIGNAL_SENDER_HPP
+
+#include <ndb_global.h>
+#include "TransporterFacade.hpp"
+#include <Vector.hpp>
+
+struct SimpleSignal {
+public:
+  SimpleSignal(bool dealloc = false);
+  ~SimpleSignal();
+  
+  void set(class SignalSender&,
+	   Uint8  trace, Uint16 recBlock, Uint16 gsn, Uint32 len);
+  
+  struct SignalHeader header;
+  Uint32 theData[25];
+  LinearSectionPtr ptr[3];
+
+  int readSignalNumber() {return header.theVerId_signalNumber; }
+  Uint32 *getDataPtrSend() { return theData; }
+  const Uint32 *getDataPtr() const { return theData; }
+
+  void print(FILE * out = stdout);
+private:
+  bool deallocSections;
+};
+
+class SignalSender {
+public:
+  SignalSender(TransporterFacade *facade);
+  virtual ~SignalSender();
+  
+  int lock();
+  int unlock();
+
+  Uint32 getOwnRef() const;
+  Uint32 getAliveNode() const;
+  const ClusterMgr::Node &getNodeInfo(Uint16 nodeId) const;
+  Uint32 getNoOfConnectedNodes() const;
+
+  SendStatus sendSignal(Uint16 nodeId, const SimpleSignal *);
+  
+  SimpleSignal * waitFor(Uint32 timeOutMillis = 0);
+  SimpleSignal * waitFor(Uint16 nodeId, Uint32 timeOutMillis = 0);
+  SimpleSignal * waitFor(Uint16 nodeId, Uint16 gsn, Uint32 timeOutMillis = 0);  
+private:
+  int m_blockNo;
+  TransporterFacade * theFacade;
+  
+  static void execSignal(void* signalSender, 
+			 NdbApiSignal* signal, 
+			 class LinearSectionPtr ptr[3]);
+  
+  static void execNodeStatus(void* signalSender, Uint32 nodeId, 
+			     bool alive, bool nfCompleted);
+  
+  int m_lock;
+  struct NdbCondition * m_cond;
+  Vector<SimpleSignal *> m_jobBuffer;
+  Vector<SimpleSignal *> m_usedBuffer;
+
+  template<class T>
+  SimpleSignal * waitFor(Uint32 timeOutMillis, T & t);
+};
+
+#endif

From 3979938c516cd22b9db9568cdbbf92d865b4148f Mon Sep 17 00:00:00 2001
From: "tomas@poseidon.ndb.mysql.com" <>
Date: Thu, 8 Sep 2005 15:24:21 +0200
Subject: [PATCH 10/15] corrected prev fix for bug #13054 so that _only_ backup
 master replies to API

---
 ndb/src/kernel/blocks/backup/Backup.cpp | 72 +++++++++++++------------
 1 file changed, 39 insertions(+), 33 deletions(-)

diff --git a/ndb/src/kernel/blocks/backup/Backup.cpp b/ndb/src/kernel/blocks/backup/Backup.cpp
index 04b5a00494c..ec5c7a5d588 100644
--- a/ndb/src/kernel/blocks/backup/Backup.cpp
+++ b/ndb/src/kernel/blocks/backup/Backup.cpp
@@ -859,20 +859,20 @@ Backup::execBACKUP_REQ(Signal* signal)
 
   if(getOwnNodeId() != getMasterNodeId()) {
     jam();
-    sendBackupRef(senderRef, signal, senderData, BackupRef::IAmNotMaster);
+    sendBackupRef(senderRef, flags, signal, senderData, BackupRef::IAmNotMaster);
     return;
   }//if
 
   if (m_diskless)
   {
-    sendBackupRef(senderRef, signal, senderData, 
+    sendBackupRef(senderRef, flags, signal, senderData, 
 		  BackupRef::CannotBackupDiskless);
     return;
   }
   
   if(dataLen32 != 0) {
     jam();
-    sendBackupRef(senderRef, signal, senderData, 
+    sendBackupRef(senderRef, flags, signal, senderData, 
 		  BackupRef::BackupDefinitionNotImplemented);
     return;
   }//if
@@ -887,7 +887,7 @@ Backup::execBACKUP_REQ(Signal* signal)
   c_backups.seize(ptr);
   if(ptr.i == RNIL) {
     jam();
-    sendBackupRef(senderRef, signal, senderData, BackupRef::OutOfBackupRecord);
+    sendBackupRef(senderRef, flags, signal, senderData, BackupRef::OutOfBackupRecord);
     return;
   }//if
 
@@ -936,23 +936,23 @@ void
 Backup::sendBackupRef(Signal* signal, BackupRecordPtr ptr, Uint32 errorCode)
 {
   jam();
-  if (SEND_BACKUP_STARTED_FLAG(ptr.p->flags))
-  {
-    sendBackupRef(ptr.p->clientRef, signal, ptr.p->clientData, errorCode);
-  }
+  sendBackupRef(ptr.p->clientRef, ptr.p->flags, signal, ptr.p->clientData, errorCode);
   cleanup(signal, ptr);
 }
 
 void
-Backup::sendBackupRef(BlockReference senderRef, Signal *signal,
+Backup::sendBackupRef(BlockReference senderRef, Uint32 flags, Signal *signal,
 		      Uint32 senderData, Uint32 errorCode)
 {
   jam();
-  BackupRef* ref = (BackupRef*)signal->getDataPtrSend();
-  ref->senderData = senderData;
-  ref->errorCode = errorCode;
-  ref->masterRef = numberToRef(BACKUP, getMasterNodeId());
-  sendSignal(senderRef, GSN_BACKUP_REF, signal, BackupRef::SignalLength, JBB);
+  if (SEND_BACKUP_STARTED_FLAG(flags))
+  {
+    BackupRef* ref = (BackupRef*)signal->getDataPtrSend();
+    ref->senderData = senderData;
+    ref->errorCode = errorCode;
+    ref->masterRef = numberToRef(BACKUP, getMasterNodeId());
+    sendSignal(senderRef, GSN_BACKUP_REF, signal, BackupRef::SignalLength, JBB);
+  }
 
   if(errorCode != BackupRef::IAmNotMaster){
     signal->theData[0] = EventReport::BackupFailedToStart;
@@ -1204,12 +1204,12 @@ Backup::defineBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId)
    */
   CRASH_INSERTION((10034));
 
-  BackupConf * conf = (BackupConf*)signal->getDataPtrSend();
-  conf->backupId = ptr.p->backupId;
-  conf->senderData = ptr.p->clientData;
-  conf->nodes = ptr.p->nodes;
   if (SEND_BACKUP_STARTED_FLAG(ptr.p->flags))
   {
+    BackupConf * conf = (BackupConf*)signal->getDataPtrSend();
+    conf->backupId = ptr.p->backupId;
+    conf->senderData = ptr.p->clientData;
+    conf->nodes = ptr.p->nodes;
     sendSignal(ptr.p->clientRef, GSN_BACKUP_CONF, signal, 
 	       BackupConf::SignalLength, JBB);
   }
@@ -2094,18 +2094,18 @@ Backup::stopBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId)
   
   if(!ptr.p->checkError())
   {
-    BackupCompleteRep * rep = (BackupCompleteRep*)signal->getDataPtrSend();
-    rep->backupId = ptr.p->backupId;
-    rep->senderData = ptr.p->clientData;
-    rep->startGCP = ptr.p->startGCP;
-    rep->stopGCP = ptr.p->stopGCP;
-    rep->noOfBytes = ptr.p->noOfBytes;
-    rep->noOfRecords = ptr.p->noOfRecords;
-    rep->noOfLogBytes = ptr.p->noOfLogBytes;
-    rep->noOfLogRecords = ptr.p->noOfLogRecords;
-    rep->nodes = ptr.p->nodes;
     if (SEND_BACKUP_COMPLETED_FLAG(ptr.p->flags))
     {
+      BackupCompleteRep * rep = (BackupCompleteRep*)signal->getDataPtrSend();
+      rep->backupId = ptr.p->backupId;
+      rep->senderData = ptr.p->clientData;
+      rep->startGCP = ptr.p->startGCP;
+      rep->stopGCP = ptr.p->stopGCP;
+      rep->noOfBytes = ptr.p->noOfBytes;
+      rep->noOfRecords = ptr.p->noOfRecords;
+      rep->noOfLogBytes = ptr.p->noOfLogBytes;
+      rep->noOfLogRecords = ptr.p->noOfLogRecords;
+      rep->nodes = ptr.p->nodes;
       sendSignal(ptr.p->clientRef, GSN_BACKUP_COMPLETE_REP, signal,
 		 BackupCompleteRep::SignalLength, JBB);
     }
@@ -2146,12 +2146,12 @@ Backup::masterAbort(Signal* signal, BackupRecordPtr ptr)
     return;
   }
 
-  BackupAbortRep* rep = (BackupAbortRep*)signal->getDataPtrSend();
-  rep->backupId = ptr.p->backupId;
-  rep->senderData = ptr.p->clientData;
-  rep->reason = ptr.p->errorCode;
   if (SEND_BACKUP_COMPLETED_FLAG(ptr.p->flags))
   {
+    BackupAbortRep* rep = (BackupAbortRep*)signal->getDataPtrSend();
+    rep->backupId = ptr.p->backupId;
+    rep->senderData = ptr.p->clientData;
+    rep->reason = ptr.p->errorCode;
     sendSignal(ptr.p->clientRef, GSN_BACKUP_ABORT_REP, signal, 
 	       BackupAbortRep::SignalLength, JBB);
   }
@@ -2286,7 +2286,13 @@ Backup::execDEFINE_BACKUP_REQ(Signal* signal)
   ptr.p->errorCode = 0;
   ptr.p->clientRef = req->clientRef;
   ptr.p->clientData = req->clientData;
-  ptr.p->flags = req->flags;
+  if(senderRef == reference())
+    ptr.p->flags = req->flags;
+  else
+    ptr.p->flags = req->flags & ~((Uint32)0x3); /* remove waitCompleted flags
+						 * as non master should never
+						 * reply
+						 */
   ptr.p->masterRef = senderRef;
   ptr.p->nodes = req->nodes;
   ptr.p->backupId = backupId;

From a6c9ebba470befa2ed5143ad10a8d0fc39ba1574 Mon Sep 17 00:00:00 2001
From: "tomas@poseidon.ndb.mysql.com" <>
Date: Thu, 8 Sep 2005 15:43:46 +0200
Subject: [PATCH 11/15]    corrected printouts in backup test

---
 ndb/src/kernel/blocks/backup/Backup.hpp | 2 +-
 ndb/test/src/NdbBackup.cpp              | 9 ++++++---
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/ndb/src/kernel/blocks/backup/Backup.hpp b/ndb/src/kernel/blocks/backup/Backup.hpp
index 7780d05ab9e..f3d180b9467 100644
--- a/ndb/src/kernel/blocks/backup/Backup.hpp
+++ b/ndb/src/kernel/blocks/backup/Backup.hpp
@@ -596,7 +596,7 @@ public:
   
   bool insertFileHeader(BackupFormat::FileType, BackupRecord*, BackupFile*);
   void sendBackupRef(Signal* signal, BackupRecordPtr ptr, Uint32 errorCode);
-  void sendBackupRef(BlockReference ref, Signal *signal,
+  void sendBackupRef(BlockReference ref, Uint32 flags, Signal *signal,
 		     Uint32 senderData, Uint32 errorCode);
   void dumpUsedResources();
   void cleanup(Signal*, BackupRecordPtr ptr);
diff --git a/ndb/test/src/NdbBackup.cpp b/ndb/test/src/NdbBackup.cpp
index 28724323bd7..1e56db83c11 100644
--- a/ndb/test/src/NdbBackup.cpp
+++ b/ndb/test/src/NdbBackup.cpp
@@ -50,14 +50,17 @@ NdbBackup::start(unsigned int & _backup_id){
 			   2, // wait until completed
 			   &_backup_id,
 			   &reply) == -1) {
-    g_err  << "Could not start backup " << endl;
-    g_err << "Error: " << reply.message << endl;
+    g_err << "Error: " << ndb_mgm_get_latest_error(handle) << endl;
+    g_err << "Error msg: " << ndb_mgm_get_latest_error_msg(handle) << endl;
+    g_err << "Error desc: " << ndb_mgm_get_latest_error_desc(handle) << endl;
     return -1;
   }
 
   if(reply.return_code != 0){
     g_err  << "PLEASE CHECK CODE NdbBackup.cpp line=" << __LINE__ << endl;
-    g_err << "Error: " << reply.message << endl;
+    g_err << "Error: " << ndb_mgm_get_latest_error(handle) << endl;
+    g_err << "Error msg: " << ndb_mgm_get_latest_error_msg(handle) << endl;
+    g_err << "Error desc: " << ndb_mgm_get_latest_error_desc(handle) << endl;
     return reply.return_code;
   }
   return 0;

From 98a52fa9a434319a1c8ac1b859ca39fa62faa17e Mon Sep 17 00:00:00 2001
From: "tomas@poseidon.ndb.mysql.com" <>
Date: Thu, 8 Sep 2005 16:47:27 +0200
Subject: [PATCH 12/15] corrected typo

---
 ndb/src/mgmsrv/MgmtSrvr.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ndb/src/mgmsrv/MgmtSrvr.cpp b/ndb/src/mgmsrv/MgmtSrvr.cpp
index e9d3ce19076..011643237f8 100644
--- a/ndb/src/mgmsrv/MgmtSrvr.cpp
+++ b/ndb/src/mgmsrv/MgmtSrvr.cpp
@@ -2506,6 +2506,7 @@ MgmtSrvr::startBackup(Uint32& backupId, int waitCompleted)
 #endif
       if (rep->failNo == nodeId ||
 	  waitCompleted == 1)
+	return 1326;
       // wait for next signal
       // master node will report aborted backup
       break;

From 0f4bb8e6ff5de3b0637e3336e58913fa8d372c6d Mon Sep 17 00:00:00 2001
From: "tulin@dl145c.mysql.com" <>
Date: Thu, 8 Sep 2005 19:27:37 +0200
Subject: [PATCH 13/15] SignalSender.cpp:   fixed compile error

---
 ndb/src/ndbapi/SignalSender.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ndb/src/ndbapi/SignalSender.cpp b/ndb/src/ndbapi/SignalSender.cpp
index 0a23529dc73..a1c80f22041 100644
--- a/ndb/src/ndbapi/SignalSender.cpp
+++ b/ndb/src/ndbapi/SignalSender.cpp
@@ -266,5 +266,5 @@ SignalSender::execNodeStatus(void* signalSender,
 
 template SimpleSignal* SignalSender::waitFor<WaitForNode>(unsigned, WaitForNode&);
 template SimpleSignal* SignalSender::waitFor<WaitForAny>(unsigned, WaitForAny&);
-template Vector<SimpleSignal*>;
+template class Vector<SimpleSignal*>;
   

From 19192328f29abd99155523d24f06a04888578494 Mon Sep 17 00:00:00 2001
From: "igor@rurik.mysql.com" <>
Date: Thu, 8 Sep 2005 12:37:16 -0700
Subject: [PATCH 14/15] sql_select.cc:   Fixed bug #12885.   Forced inheritence
 of the maybe_null flag for the expressions   containing GROUP BY attributes
 in selects with ROLLUP. olap.test, olap.result:   Added test case for bug
 #12885.

---
 mysql-test/r/olap.result | 13 +++++++++++++
 mysql-test/t/olap.test   | 13 +++++++++++++
 sql/sql_select.cc        | 17 ++++++++++++++---
 3 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/mysql-test/r/olap.result b/mysql-test/r/olap.result
index 7178895cf80..65f7c649624 100644
--- a/mysql-test/r/olap.result
+++ b/mysql-test/r/olap.result
@@ -516,3 +516,16 @@ a	b	c	count
 1	NULL	NULL	2
 NULL	NULL	NULL	2
 DROP TABLE t1;
+CREATE TABLE t1 (a int(11) NOT NULL);
+INSERT INTO t1 VALUES (1),(2);
+SELECT * FROM (SELECT a, a + 1, COUNT(*) FROM t1 GROUP BY a WITH ROLLUP) t;
+a	a + 1	COUNT(*)
+1	2	1
+2	3	1
+NULL	NULL	2
+SELECT * FROM (SELECT a, LENGTH(a), COUNT(*) FROM t1 GROUP BY a WITH ROLLUP) t;
+a	LENGTH(a)	COUNT(*)
+1	1	1
+2	1	1
+NULL	NULL	2
+DROP TABLE t1;
diff --git a/mysql-test/t/olap.test b/mysql-test/t/olap.test
index c9a16b897c6..76c62d14621 100644
--- a/mysql-test/t/olap.test
+++ b/mysql-test/t/olap.test
@@ -250,4 +250,17 @@ SELECT a, b, a AS c, COUNT(*) AS count FROM t1 GROUP BY a, b, c WITH ROLLUP;
 
 DROP TABLE t1;
 
+#
+# Bug #11885:  derived table specified by a subquery with
+#              ROLLUP over expressions on not nullable group by attributes 
+#
+
+CREATE TABLE t1 (a int(11) NOT NULL);
+INSERT INTO t1 VALUES (1),(2);
+
+SELECT * FROM (SELECT a, a + 1, COUNT(*) FROM t1 GROUP BY a WITH ROLLUP) t;
+SELECT * FROM (SELECT a, LENGTH(a), COUNT(*) FROM t1 GROUP BY a WITH ROLLUP) t;
+
+DROP TABLE t1;
+
 # End of 4.1 tests
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index e7af2a1aa75..3de546fd619 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -9277,6 +9277,8 @@ void free_underlaid_joins(THD *thd, SELECT_LEX *select)
     The function replaces occurrences of group by fields in expr
     by ref objects for these fields unless they are under aggregate
     functions.
+    The function also corrects value of the the maybe_null attribute
+    for the items of all subexpressions containing group by fields.
 
   IMPLEMENTATION
     The function recursively traverses the tree of the expr expression,
@@ -9287,6 +9289,9 @@ void free_underlaid_joins(THD *thd, SELECT_LEX *select)
     This substitution is needed GROUP BY queries with ROLLUP if
     SELECT list contains expressions over group by attributes.
 
+  TODO: Some functions are not null-preserving. For those functions
+    updating of the maybe_null attribute is an overkill. 
+
   EXAMPLES
     SELECT a+1 FROM t1 GROUP BY a WITH ROLLUP
     SELECT SUM(a)+a FROM t1 GROUP BY a WITH ROLLUP 
@@ -9307,6 +9312,7 @@ static bool change_group_ref(THD *thd, Item_func *expr, ORDER *group_list,
          arg != arg_end; arg++)
     {
       Item *item= *arg;
+      bool arg_changed= FALSE;
       if (item->type() == Item::FIELD_ITEM || item->type() == Item::REF_ITEM)
       {
         ORDER *group_tmp;
@@ -9318,15 +9324,20 @@ static bool change_group_ref(THD *thd, Item_func *expr, ORDER *group_list,
             if(!(new_item= new Item_ref(group_tmp->item, 0, item->name)))
               return 1;                                 // fatal_error is set
             thd->change_item_tree(arg, new_item);
-            *changed= TRUE;
+            arg_changed= TRUE;
           }
         }
       }
       else if (item->type() == Item::FUNC_ITEM)
       {
-        if (change_group_ref(thd, (Item_func *) item, group_list, changed))
+        if (change_group_ref(thd, (Item_func *) item, group_list, &arg_changed))
           return 1;
       }
+      if (arg_changed)
+      {
+        expr->maybe_null= 1;
+        *changed= TRUE;
+      }
     }
   }
   return 0;
@@ -9389,7 +9400,7 @@ bool JOIN::rollup_init()
     }
     if (item->type() == Item::FUNC_ITEM)
     {
-      bool changed= 0;
+      bool changed= FALSE;
       if (change_group_ref(thd, (Item_func *) item, group_list, &changed))
         return 1;
       /*

From a7f2179c29b6a168c853b6fe0dece13c963bc288 Mon Sep 17 00:00:00 2001
From: "serg@serg.mylan" <>
Date: Thu, 8 Sep 2005 22:57:27 +0200
Subject: [PATCH 15/15] BUG#12695: Item_func_isnull::update_used_tables did not
 update const_item_cache

---
 mysql-test/r/group_by.result |  9 +++++++++
 mysql-test/t/group_by.test   | 10 ++++++++++
 sql/item_cmpfunc.h           |  2 +-
 3 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/mysql-test/r/group_by.result b/mysql-test/r/group_by.result
index 8287a042d60..4ad28091164 100644
--- a/mysql-test/r/group_by.result
+++ b/mysql-test/r/group_by.result
@@ -764,3 +764,12 @@ select date(left(f1+0,8)) from t1 group by 1;
 date(left(f1+0,8))
 2005-06-06
 drop table t1;
+create table t1(f1 varchar(5) key);
+insert into t1 values (1),(2);
+select sql_buffer_result max(f1) is null from t1;
+max(f1) is null
+0
+select sql_buffer_result max(f1)+1 from t1;
+max(f1)+1
+3
+drop table t1;
diff --git a/mysql-test/t/group_by.test b/mysql-test/t/group_by.test
index 815da66c717..f14fab2d30e 100644
--- a/mysql-test/t/group_by.test
+++ b/mysql-test/t/group_by.test
@@ -600,4 +600,14 @@ insert into t1 values('2005-06-06');
 select date(left(f1+0,8)) from t1 group by 1;
 drop table t1;
 
+#
+# BUG#12695: Item_func_isnull::update_used_tables
+# did not update const_item_cache
+#
+create table t1(f1 varchar(5) key);
+insert into t1 values (1),(2);
+select sql_buffer_result max(f1) is null from t1;
+select sql_buffer_result max(f1)+1 from t1;
+drop table t1;
+
 # End of 4.1 tests
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h
index 47884f6064e..bb4759918ff 100644
--- a/sql/item_cmpfunc.h
+++ b/sql/item_cmpfunc.h
@@ -805,7 +805,7 @@ public:
     else
     {
       args[0]->update_used_tables();
-      if (!(used_tables_cache=args[0]->used_tables()))
+      if ((const_item_cache= !(used_tables_cache= args[0]->used_tables())))
       {
 	/* Remember if the value is always NULL or never NULL */
 	cached_value= (longlong) args[0]->is_null();