merge fix

ndb/src/mgmapi/mgmapi.cpp:
  merge

15 files changed, 631 insertions, 111 deletions

diff --git a/ndb/include/mgmapi/mgmapi.h b/ndb/include/mgmapi/mgmapi.h
index 018e554de7c..924d65c2847 100644
--- a/ndb/include/mgmapi/mgmapi.h
+++ b/ndb/include/mgmapi/mgmapi.h
@@ -139,6 +139,7 @@
  *  @{
  */
 
+#include <stdio.h>
 #include <ndb_types.h>
 #include "ndb_logevent.h"
 #include "mgmapi_config_parameters.h"
@@ -441,6 +442,12 @@ extern "C" {
   int ndb_mgm_get_latest_error_line(const NdbMgmHandle handle);
 #endif
 
+  /**
+   * Set error stream
+   */
+  void ndb_mgm_set_error_stream(NdbMgmHandle, FILE *);
+
+
   /** @} *********************************************************************/
   /**
    * @name Functions: Create/Destroy Management Server Handles
diff --git a/ndb/include/mgmapi/mgmapi_config_parameters.h b/ndb/include/mgmapi/mgmapi_config_parameters.h
index 33134899d1e..8f95e159b38 100644
--- a/ndb/include/mgmapi/mgmapi_config_parameters.h
+++ b/ndb/include/mgmapi/mgmapi_config_parameters.h
@@ -50,8 +50,11 @@
 
 #define CFG_DB_FILESYSTEM_PATH        125
 #define CFG_DB_NO_REDOLOG_FILES       126
-#define CFG_DB_DISC_BANDWIDTH         127
-#define CFG_DB_SR_DISC_BANDWITH       128
+
+#define CFG_DB_LCP_DISC_PAGES_TUP     127
+#define CFG_DB_LCP_DISC_PAGES_TUP_SR  128
+#define CFG_DB_LCP_DISC_PAGES_ACC     137
+#define CFG_DB_LCP_DISC_PAGES_ACC_SR  138
 
 #define CFG_DB_TRANSACTION_CHECK_INTERVAL   129
 #define CFG_DB_TRANSACTION_INACTIVE_TIMEOUT 130
diff --git a/ndb/src/common/logger/LogHandler.cpp b/ndb/src/common/logger/LogHandler.cpp
index a9d4512112f..521bd346fd3 100644
--- a/ndb/src/common/logger/LogHandler.cpp
+++ b/ndb/src/common/logger/LogHandler.cpp
@@ -58,7 +58,7 @@ LogHandler::append(const char* pCategory, Logger::LoggerLevel level,
   }
   else // repeated message
   {
-    if (now < m_last_log_time+m_max_repeat_frequency)
+    if (now < (time_t) (m_last_log_time+m_max_repeat_frequency))
     {
       m_count_repeated_messages++;
       m_now= now;
diff --git a/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp b/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp
index 1a64b8f9e1e..aefd2612151 100644
--- a/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp
+++ b/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp
@@ -731,10 +731,12 @@ void Dbacc::execREAD_CONFIG_REQ(Signal* signal)
   ndbrestart1Lab(signal);
 
   clblPagesPerTick = 50;
-  //ndb_mgm_get_int_parameter(p, CFG_DB_, &clblPagesPerTick);
+  ndb_mgm_get_int_parameter(p, CFG_DB_LCP_DISC_PAGES_ACC_SR, 
+			    &clblPagesPerTick);
 
   clblPagesPerTickAfterSr = 50;
-  //ndb_mgm_get_int_parameter(p, CFG_DB_, &clblPagesPerTickAfterSr);
+  ndb_mgm_get_int_parameter(p, CFG_DB_LCP_DISC_PAGES_ACC, 
+			    &clblPagesPerTickAfterSr);
 
   tdata0 = 0;
   initialiseRecordsLab(signal, ref, senderData);
@@ -4849,16 +4851,16 @@ Uint32 Dbacc::executeNextOperation(Signal* signal)
   else if(operationRecPtr.p->operation == ZWRITE)
   {
     jam();
-    operationRecPtr.p->operation = ZINSERT;
+    operationRecPtr.p->operation = ZUPDATE;
     if (operationRecPtr.p->prevParallelQue != RNIL) {
       OperationrecPtr prevOpPtr;
       jam();
       prevOpPtr.i = operationRecPtr.p->prevParallelQue;
       ptrCheckGuard(prevOpPtr, coprecsize, operationrec);
-      if (prevOpPtr.p->operation != ZDELETE) 
+      if (prevOpPtr.p->operation == ZDELETE) 
       {
         jam();
-        operationRecPtr.p->operation = ZUPDATE;
+        operationRecPtr.p->operation = ZINSERT;
       }
     }
   }
diff --git a/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp b/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
index 03f02dd0b92..f02a804aa83 100644
--- a/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
+++ b/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
@@ -672,10 +672,12 @@ void Dbtup::execREAD_CONFIG_REQ(Signal* signal)
   initialiseRecordsLab(signal, 0, ref, senderData);
 
   clblPagesPerTick = 50;
-  //ndb_mgm_get_int_parameter(p, CFG_DB_, &clblPagesPerTick);
+  ndb_mgm_get_int_parameter(p, CFG_DB_LCP_DISC_PAGES_TUP_SR, 
+			    &clblPagesPerTick);
 
   clblPagesPerTickAfterSr = 50;
-  //ndb_mgm_get_int_parameter(p, CFG_DB_, &clblPagesPerTickAfterSr);
+  ndb_mgm_get_int_parameter(p, CFG_DB_LCP_DISC_PAGES_TUP, 
+			    &clblPagesPerTickAfterSr);
 
 }//Dbtup::execSIZEALT_REP()
 
diff --git a/ndb/src/mgmapi/mgmapi.cpp b/ndb/src/mgmapi/mgmapi.cpp
index 9f393d10528..6551ca24ee2 100644
--- a/ndb/src/mgmapi/mgmapi.cpp
+++ b/ndb/src/mgmapi/mgmapi.cpp
@@ -101,6 +101,7 @@ struct ndb_mgm_handle {
 #ifdef MGMAPI_LOG
   FILE* logfile;
 #endif
+  FILE *errstream;
 };
 
 #define SET_ERROR(h, e, s) setError(h, e, __LINE__, s)
@@ -154,6 +155,7 @@ ndb_mgm_create_handle()
   h->read_timeout    = 50000;
   h->write_timeout   = 100;
   h->cfg_i           = -1;
+  h->errstream       = stdout;
 
   strncpy(h->last_error_desc, "No error", NDB_MGM_MAX_ERR_DESC_SIZE);
 
@@ -219,6 +221,13 @@ ndb_mgm_destroy_handle(NdbMgmHandle * handle)
   DBUG_VOID_RETURN;
 }
 
+extern "C" 
+void
+ndb_mgm_set_error_stream(NdbMgmHandle handle, FILE * file)
+{
+  handle->errstream = file;
+}
+
 /*****************************************************************************
  * Error handling
  *****************************************************************************/
@@ -424,8 +433,8 @@ ndb_mgm_connect(NdbMgmHandle handle, int no_retries,
 #endif
     if (verbose > 0) {
       char buf[1024];
-      ndbout_c("Unable to connect with connect string: %s",
-	       cfg.makeConnectString(buf,sizeof(buf)));
+      fprintf(handle->errstream, "Unable to connect with connect string: %s\n",
+	      cfg.makeConnectString(buf,sizeof(buf)));
       verbose= -1;
     }
     if (no_retries == 0) {
@@ -434,32 +443,35 @@ ndb_mgm_connect(NdbMgmHandle handle, int no_retries,
 	       "Unable to connect with connect string: %s",
 	       cfg.makeConnectString(buf,sizeof(buf)));
       if (verbose == -2)
-	ndbout << ", failed." << endl;
+	fprintf(handle->errstream, ", failed.\n");
       DBUG_RETURN(-1);
     }
     if (verbose == -1) {
-      ndbout << "Retrying every " << retry_delay_in_seconds << " seconds";
+      fprintf(handle->errstream, "Retrying every %d seconds", 
+	      retry_delay_in_seconds);
       if (no_retries > 0)
-	ndbout << ". Attempts left:";
+	fprintf(handle->errstream, ". Attempts left:");
       else
-	ndbout << ", until connected.";;	
-      ndbout << flush;
+	fprintf(handle->errstream, ", until connected.");
+      fflush(handle->errstream);
       verbose= -2;
     }
     if (no_retries > 0) {
       if (verbose == -2) {
-	ndbout << " " << no_retries;
-	ndbout << flush;
+	fprintf(handle->errstream, " %d", no_retries);
+	fflush(handle->errstream);
       }
       no_retries--;
     }
     NdbSleep_SecSleep(retry_delay_in_seconds);
   }
   if (verbose == -2)
-    ndbout << endl;
-
+  {
+    fprintf(handle->errstream, "\n");
+    fflush(handle->errstream);
+  }
   handle->cfg_i = i;
-
+  
   handle->socket    = sockfd;
   handle->connected = 1;
 
@@ -511,7 +523,9 @@ ndb_mgm_match_node_type(const char * type)
   for(int i = 0; i<no_of_type_values; i++)
     if(strcmp(type, type_values[i].str) == 0)
       return type_values[i].value;
-
+    else if(strcmp(type, type_values[i].alias) == 0)
+      return type_values[i].value;
+  
   return NDB_MGM_NODE_TYPE_UNKNOWN;
 }
 
@@ -1720,28 +1734,28 @@ ndb_mgm_get_configuration(NdbMgmHandle handle, unsigned int version) {
   do {
     const char * buf;
     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
-      ndbout_c("ERROR Message: %s\n", buf);
+      fprintf(handle->errstream, "ERROR Message: %s\n\n", buf);
       break;
     }
 
     buf = "<Unspecified>";
     if(!prop->get("Content-Type", &buf) || 
        strcmp(buf, "ndbconfig/octet-stream") != 0){
-      ndbout_c("Unhandled response type: %s", buf);
+      fprintf(handle->errstream, "Unhandled response type: %s\n", buf);
       break;
     }
 
     buf = "<Unspecified>";
     if(!prop->get("Content-Transfer-Encoding", &buf) 
        || strcmp(buf, "base64") != 0){
-      ndbout_c("Unhandled encoding: %s", buf);
+      fprintf(handle->errstream, "Unhandled encoding: %s\n", buf);
       break;
     }
 
     buf = "<Content-Length Unspecified>";
     Uint32 len = 0;
     if(!prop->get("Content-Length", &len)){
-      ndbout_c("Invalid response: %s\n", buf);
+      fprintf(handle->errstream, "Invalid response: %s\n\n", buf);
       break;
     }
 
@@ -1766,14 +1780,14 @@ ndb_mgm_get_configuration(NdbMgmHandle handle, unsigned int version) {
     const int res = base64_decode(buf64, len-1, tmp);
     delete[] buf64; 
     if(res != 0){
-      ndbout_c("Failed to decode buffer");
+      fprintf(handle->errstream, "Failed to decode buffer\n");
       break;
     }
 
     ConfigValuesFactory cvf;
     const int res2 = cvf.unpack(tmp);
     if(!res2){
-      ndbout_c("Failed to unpack buffer");
+      fprintf(handle->errstream, "Failed to unpack buffer\n");
       break;
     }
 
@@ -1883,7 +1897,7 @@ ndb_mgm_alloc_nodeid(NdbMgmHandle handle, unsigned int version, int nodetype)
     }
     Uint32 _nodeid;
     if(!prop->get("nodeid", &_nodeid) != 0){
-      ndbout_c("ERROR Message: <nodeid Unspecified>\n");
+      fprintf(handle->errstream, "ERROR Message: <nodeid Unspecified>\n");
       break;
     }
     nodeid= _nodeid;
@@ -1959,7 +1973,7 @@ ndb_mgm_set_int_parameter(NdbMgmHandle handle,
   do {
     const char * buf;
     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
-      ndbout_c("ERROR Message: %s\n", buf);
+      fprintf(handle->errstream, "ERROR Message: %s\n", buf);
       break;
     }
     res= 0;
@@ -2002,7 +2016,7 @@ ndb_mgm_set_int64_parameter(NdbMgmHandle handle,
   do {
     const char * buf;
     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
-      ndbout_c("ERROR Message: %s\n", buf);
+      fprintf(handle->errstream, "ERROR Message: %s\n", buf);
       break;
     }
     res= 0;
@@ -2045,7 +2059,7 @@ ndb_mgm_set_string_parameter(NdbMgmHandle handle,
   do {
     const char * buf;
     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
-      ndbout_c("ERROR Message: %s\n", buf);
+      fprintf(handle->errstream, "ERROR Message: %s\n", buf);
       break;
     }
     res= 0;
@@ -2082,7 +2096,7 @@ ndb_mgm_purge_stale_sessions(NdbMgmHandle handle, char **purged){
   do {
     const char * buf;
     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
-      ndbout_c("ERROR Message: %s\n", buf);
+      fprintf(handle->errstream, "ERROR Message: %s\n", buf);
       break;
     }
     if (purged) {
@@ -2164,7 +2178,7 @@ ndb_mgm_set_connection_int_parameter(NdbMgmHandle handle,
   do {
     const char * buf;
     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
-      ndbout_c("ERROR Message: %s\n", buf);
+      fprintf(handle->errstream, "ERROR Message: %s\n", buf);
       break;
     }
     res= 0;
@@ -2206,14 +2220,14 @@ ndb_mgm_get_connection_int_parameter(NdbMgmHandle handle,
   do {
     const char * buf;
     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
-      ndbout_c("ERROR Message: %s\n", buf);
+      fprintf(handle->errstream, "ERROR Message: %s\n", buf);
       break;
     }
     res= 0;
   } while(0);
 
   if(!prop->get("value",(Uint32*)value)){
-    ndbout_c("Unable to get value");
+    fprintf(handle->errstream, "Unable to get value\n");
     res = -4;
   }
 
@@ -2265,7 +2279,7 @@ ndb_mgm_get_mgmd_nodeid(NdbMgmHandle handle)
   CHECK_REPLY(prop, 0);
 
   if(!prop->get("nodeid",&nodeid)){
-    ndbout_c("Unable to get value");
+    fprintf(handle->errstream, "Unable to get value\n");
     return 0;
   }
 
diff --git a/ndb/src/mgmsrv/ConfigInfo.cpp b/ndb/src/mgmsrv/ConfigInfo.cpp
index 34a2d8c1302..3df878065a7 100644
--- a/ndb/src/mgmsrv/ConfigInfo.cpp
+++ b/ndb/src/mgmsrv/ConfigInfo.cpp
@@ -915,7 +915,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
     STR_VALUE(MAX_INT_RNIL) },
 
   {
-    KEY_INTERNAL,
+    CFG_DB_LCP_DISC_PAGES_TUP_SR,
     "NoOfDiskPagesToDiskDuringRestartTUP",
     DB_TOKEN,
     "?",
@@ -927,7 +927,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
     STR_VALUE(MAX_INT_RNIL) },
 
   {
-    KEY_INTERNAL,
+    CFG_DB_LCP_DISC_PAGES_TUP,
     "NoOfDiskPagesToDiskAfterRestartTUP",
     DB_TOKEN,
     "?",
@@ -939,7 +939,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
     STR_VALUE(MAX_INT_RNIL) },
 
   {
-    KEY_INTERNAL,
+    CFG_DB_LCP_DISC_PAGES_ACC_SR,
     "NoOfDiskPagesToDiskDuringRestartACC",
     DB_TOKEN,
     "?",
@@ -951,7 +951,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
     STR_VALUE(MAX_INT_RNIL) },
 
   {
-    KEY_INTERNAL,
+    CFG_DB_LCP_DISC_PAGES_ACC,
     "NoOfDiskPagesToDiskAfterRestartACC",
     DB_TOKEN,
     "?",
diff --git a/ndb/src/mgmsrv/ConfigInfo.hpp b/ndb/src/mgmsrv/ConfigInfo.hpp
index 871ee62040e..788619db7fe 100644
--- a/ndb/src/mgmsrv/ConfigInfo.hpp
+++ b/ndb/src/mgmsrv/ConfigInfo.hpp
@@ -127,14 +127,14 @@ private:
   Properties               m_info;
   Properties               m_systemDefaults;
 
-  static const ParamInfo   m_ParamInfo[];
-  static const int         m_NoOfParams;
-  
   static const AliasPair   m_sectionNameAliases[];
   static const char*       m_sectionNames[];
   static const int         m_noOfSectionNames;
 
 public:
+  static const ParamInfo   m_ParamInfo[];
+  static const int         m_NoOfParams;
+  
   static const SectionRule m_SectionRules[];
   static const ConfigRule  m_ConfigRules[];
   static const int         m_NoOfRules;
diff --git a/ndb/test/include/HugoOperations.hpp b/ndb/test/include/HugoOperations.hpp
index dbb2ff8d430..82fd5529fa2 100644
--- a/ndb/test/include/HugoOperations.hpp
+++ b/ndb/test/include/HugoOperations.hpp
@@ -45,6 +45,10 @@ public:
 		    int recordNo,
 		    int numRecords = 1,
 		    int updatesValue = 0);
+
+  int pkWritePartialRecord(Ndb*,
+			   int recordNo,
+			   int numRecords = 1);
   
   int pkReadRecord(Ndb*,
 		   int recordNo,
diff --git a/ndb/test/include/UtilTransactions.hpp b/ndb/test/include/UtilTransactions.hpp
index afdbc5c3445..333f5d98328 100644
--- a/ndb/test/include/UtilTransactions.hpp
+++ b/ndb/test/include/UtilTransactions.hpp
@@ -28,6 +28,8 @@ public:
   UtilTransactions(Ndb* ndb, 
 		   const char * tableName, const char * indexName = 0);
   
+  int closeTransaction(Ndb*);
+  
   int clearTable(Ndb*, 
 		 int records = 0,
 		 int parallelism = 0);
diff --git a/ndb/test/ndbapi/testNdbApi.cpp b/ndb/test/ndbapi/testNdbApi.cpp
index 67932780d8f..f456d852898 100644
--- a/ndb/test/ndbapi/testNdbApi.cpp
+++ b/ndb/test/ndbapi/testNdbApi.cpp
@@ -1037,7 +1037,7 @@ int runCheckGetNdbErrorOperation(NDBT_Context* ctx, NDBT_Step* step){
   return result;
 }
 
-#define C2(x) { int _x= (x); if(_x == 0) return NDBT_FAILED; }
+#define C2(x) { int _x= (x); if(_x == 0){ ndbout << "line: " << __LINE__ << endl;  return NDBT_FAILED;} }
 
 int runBug_11133(NDBT_Context* ctx, NDBT_Step* step){
   int result = NDBT_OK;
@@ -1046,7 +1046,6 @@ int runBug_11133(NDBT_Context* ctx, NDBT_Step* step){
   HugoOperations hugoOps(*pTab);
 
   Ndb* pNdb = GETNDB(step);
-
   C2(hugoOps.startTransaction(pNdb) == 0);
   C2(hugoOps.pkInsertRecord(pNdb, 0, 1) == 0);
   C2(hugoOps.execute_NoCommit(pNdb) == 0);
@@ -1098,7 +1097,7 @@ int runBug_11133(NDBT_Context* ctx, NDBT_Step* step){
   C2(hugoOps.pkInsertRecord(pNdb, 0, 1) == 0);
   C2(hugoOps.execute_NoCommit(pNdb) == 0);
   C2(hugoOps2.startTransaction(&ndb2) == 0);
-  C2(hugoOps2.pkWriteRecord(&ndb2, 0, 1) == 0);
+  C2(hugoOps2.pkWritePartialRecord(&ndb2, 0) == 0);
   C2(hugoOps2.execute_async(&ndb2, NdbTransaction::NoCommit) == 0);
   C2(hugoOps.execute_Commit(pNdb) == 0);
   C2(hugoOps2.wait_async(&ndb2) == 0);
@@ -1113,6 +1112,29 @@ int runBug_11133(NDBT_Context* ctx, NDBT_Step* step){
   C2(hugoOps2.execute_async(&ndb2, NdbTransaction::NoCommit) == 0);
   C2(hugoOps.execute_Commit(pNdb) == 0);
   C2(hugoOps2.wait_async(&ndb2) == 0);
+  C2(hugoOps2.execute_Commit(pNdb) == 0);
+  C2(hugoOps.closeTransaction(pNdb) == 0);
+  C2(hugoOps2.closeTransaction(&ndb2) == 0);  
+
+  C2(hugoOps.startTransaction(pNdb) == 0);
+  C2(hugoOps.pkUpdateRecord(pNdb, 0, 1) == 0);
+  C2(hugoOps.execute_NoCommit(pNdb) == 0);
+  C2(hugoOps2.startTransaction(&ndb2) == 0);
+  C2(hugoOps2.pkWritePartialRecord(&ndb2, 0) == 0);
+  C2(hugoOps2.execute_async(&ndb2, NdbTransaction::NoCommit) == 0);
+  C2(hugoOps.execute_Commit(pNdb) == 0);
+  C2(hugoOps2.wait_async(&ndb2) == 0);
+  C2(hugoOps.closeTransaction(pNdb) == 0);
+  C2(hugoOps2.closeTransaction(&ndb2) == 0);  
+
+  C2(hugoOps.startTransaction(pNdb) == 0);
+  C2(hugoOps.pkDeleteRecord(pNdb, 0, 1) == 0);
+  C2(hugoOps.execute_NoCommit(pNdb) == 0);
+  C2(hugoOps2.startTransaction(&ndb2) == 0);
+  C2(hugoOps2.pkWritePartialRecord(&ndb2, 0) == 0);
+  C2(hugoOps2.execute_async(&ndb2, NdbTransaction::NoCommit) == 0);
+  C2(hugoOps.execute_Commit(pNdb) == 0);
+  C2(hugoOps2.wait_async(&ndb2) != 0);
   C2(hugoOps.closeTransaction(pNdb) == 0);
   C2(hugoOps2.closeTransaction(&ndb2) == 0);  
 
diff --git a/ndb/test/src/HugoOperations.cpp b/ndb/test/src/HugoOperations.cpp
index 91902c56d76..f2e54971766 100644
--- a/ndb/test/src/HugoOperations.cpp
+++ b/ndb/test/src/HugoOperations.cpp
@@ -53,11 +53,7 @@ HugoOperations::setTransactionId(Uint64 id){
 
 int HugoOperations::closeTransaction(Ndb* pNdb){
 
-  if (pTrans != NULL){
-    pNdb->closeTransaction(pTrans);
-    pTrans = NULL;
-  }
-  pTrans = NULL;
+  UtilTransactions::closeTransaction(pNdb);
 
   m_result_sets.clear();
   m_executed_result_sets.clear();
@@ -267,6 +263,37 @@ int HugoOperations::pkWriteRecord(Ndb* pNdb,
   return NDBT_OK;
 }
 
+int HugoOperations::pkWritePartialRecord(Ndb* pNdb,
+					 int recordNo,
+					 int numRecords){
+  
+  int a, check;
+  for(int r=0; r < numRecords; r++){
+    NdbOperation* pOp = pTrans->getNdbOperation(tab.getName());	
+    if (pOp == NULL) {
+      ERR(pTrans->getNdbError());
+      return NDBT_FAILED;
+    }
+    
+    check = pOp->writeTuple();
+    if( check == -1 ) {
+      ERR(pTrans->getNdbError());
+      return NDBT_FAILED;
+    }
+    
+    // Define primary keys
+    for(a = 0; a<tab.getNoOfColumns(); a++){
+      if (tab.getColumn(a)->getPrimaryKey() == true){
+	if(equalForAttr(pOp, a, r+recordNo) != 0){
+	  ERR(pTrans->getNdbError());
+	  return NDBT_FAILED;
+	}
+      }
+    }
+  }
+  return NDBT_OK;
+}
+
 int HugoOperations::pkDeleteRecord(Ndb* pNdb,
 				   int recordNo,
 				   int numRecords){
@@ -419,7 +446,14 @@ HugoOperations::callback(int res, NdbTransaction* pCon)
 {
   assert(pCon == pTrans);
   m_async_reply= 1;
-  m_async_return= res;
+  if(res)
+  {
+    m_async_return = pCon->getNdbError().code;
+  }
+  else
+  {
+    m_async_return = 0;
+  }
 }
 
 int 
@@ -444,6 +478,8 @@ HugoOperations::wait_async(Ndb* pNdb, int timeout)
 
   if(m_async_reply)
   {
+    if(m_async_return)
+      ndbout << "ERROR: " << pNdb->getNdbError(m_async_return) << endl;
     return m_async_return;
   }
   ndbout_c("wait returned nothing...");
diff --git a/ndb/test/src/UtilTransactions.cpp b/ndb/test/src/UtilTransactions.cpp
index 65c1a7ded31..31c323045ed 100644
--- a/ndb/test/src/UtilTransactions.cpp
+++ b/ndb/test/src/UtilTransactions.cpp
@@ -109,7 +109,7 @@ UtilTransactions::clearTable3(Ndb* pNdb,
       err = pTrans->getNdbError();
       if(err.status == NdbError::TemporaryError){
 	ERR(err);
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	NdbSleep_MilliSleep(50);
 	par = 1;
 	goto restart;
@@ -126,7 +126,7 @@ UtilTransactions::clearTable3(Ndb* pNdb,
       err = pTrans->getNdbError();    
       if(err.status == NdbError::TemporaryError){
 	ERR(err);
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	NdbSleep_MilliSleep(50);
 	continue;
       }
@@ -150,7 +150,7 @@ UtilTransactions::clearTable3(Ndb* pNdb,
       if(check == -1){
 	if(err.status == NdbError::TemporaryError){
 	  ERR(err);
-	  pNdb->closeTransaction(pTrans);
+	  closeTransaction(pNdb);
 	  NdbSleep_MilliSleep(50);
 	  par = 1;
 	  goto restart;
@@ -162,20 +162,20 @@ UtilTransactions::clearTable3(Ndb* pNdb,
       err = pTrans->getNdbError();    
       if(err.status == NdbError::TemporaryError){
 	ERR(err);
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	NdbSleep_MilliSleep(50);
 	par = 1;
 	goto restart;
       }
       goto failed;
     }
-    pNdb->closeTransaction(pTrans);
+    closeTransaction(pNdb);
     return NDBT_OK;
   }
   return NDBT_FAILED;
   
  failed:
-  if(pTrans != 0) pNdb->closeTransaction(pTrans);
+  closeTransaction(pNdb);
   ERR(err);
   return (err.code != 0 ? err.code : NDBT_FAILED);
 }
@@ -219,20 +219,20 @@ UtilTransactions::copyTableData(Ndb* pNdb,
     pOp = pTrans->getNdbScanOperation(tab.getName());	
     if (pOp == NULL) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
 
     if( pOp->readTuples(NdbScanOperation::LM_Read, parallelism) ) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
 
     check = pOp->interpret_exit_ok();
     if( check == -1 ) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }  
 
@@ -241,7 +241,7 @@ UtilTransactions::copyTableData(Ndb* pNdb,
       if ((row.attributeStore(a) =  
 	   pOp->getValue(tab.getColumn(a)->getName())) == 0) {
 	ERR(pTrans->getNdbError());
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	return NDBT_FAILED;
       }
     }
@@ -249,7 +249,7 @@ UtilTransactions::copyTableData(Ndb* pNdb,
     check = pTrans->execute(NoCommit);
     if( check == -1 ) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
   
@@ -258,7 +258,7 @@ UtilTransactions::copyTableData(Ndb* pNdb,
       do {
 	insertedRows++;
 	if (addRowToInsert(pNdb, pTrans, row, destName) != 0){
-	  pNdb->closeTransaction(pTrans);
+	  closeTransaction(pNdb);
 	  return NDBT_FAILED;
 	}
       } while((eof = pOp->nextResult(false)) == 0);
@@ -268,7 +268,7 @@ UtilTransactions::copyTableData(Ndb* pNdb,
       if( check == -1 ) {
 	const NdbError err = pTrans->getNdbError();    
 	ERR(err);
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	return NDBT_FAILED;
       }
     }  
@@ -277,7 +277,7 @@ UtilTransactions::copyTableData(Ndb* pNdb,
       
       if (err.status == NdbError::TemporaryError){
 	ERR(err);
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	NdbSleep_MilliSleep(50);
 	// If error = 488 there should be no limit on number of retry attempts
 	if (err.code != 488) 
@@ -285,11 +285,11 @@ UtilTransactions::copyTableData(Ndb* pNdb,
 	continue;
       }
       ERR(err);
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
     
-    pNdb->closeTransaction(pTrans);
+    closeTransaction(pNdb);
     
     g_info << insertedRows << " rows copied" << endl;
     
@@ -375,7 +375,7 @@ UtilTransactions::scanReadRecords(Ndb* pNdb,
     pOp = getScanOperation(pTrans);
     if (pOp == NULL) {
       const NdbError err = pNdb->getNdbError();
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
 
       if (err.status == NdbError::TemporaryError){
 	ERR(err);
@@ -389,14 +389,14 @@ UtilTransactions::scanReadRecords(Ndb* pNdb,
 
     if( pOp->readTuples(lm, 0, parallelism) ) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
 
     check = pOp->interpret_exit_ok();
     if( check == -1 ) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
     
@@ -408,7 +408,7 @@ UtilTransactions::scanReadRecords(Ndb* pNdb,
 	if ((row.attributeStore(attrib_list[a]) =  
 	     pOp->getValue(tab.getColumn(attrib_list[a])->getName())) == 0) {
 	  ERR(pTrans->getNdbError());
-	  pNdb->closeTransaction(pTrans);
+	  closeTransaction(pNdb);
 	  return NDBT_FAILED;
 	}
       }
@@ -421,13 +421,13 @@ UtilTransactions::scanReadRecords(Ndb* pNdb,
 
       if (err.status == NdbError::TemporaryError){
 	ERR(err);
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	NdbSleep_MilliSleep(50);
 	retryAttempt++;
 	continue;
       }
       ERR(err);
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
     
@@ -447,17 +447,17 @@ UtilTransactions::scanReadRecords(Ndb* pNdb,
       
       if (err.status == NdbError::TemporaryError){
 	ERR(err);
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	NdbSleep_MilliSleep(50);
 	retryAttempt++;
 	continue;
       }
       ERR(err);
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
     
-    pNdb->closeTransaction(pTrans);
+    closeTransaction(pNdb);
     g_info << rows << " rows have been read" << endl;
     if (records != 0 && rows != records){
       g_info << "Check expected number of records failed" << endl 
@@ -496,13 +496,13 @@ UtilTransactions::selectCount(Ndb* pNdb,
     pOp = getScanOperation(pTrans);
     if (pOp == NULL) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
 
     if( pOp->readTuples(lm) ) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
 
@@ -515,7 +515,7 @@ UtilTransactions::selectCount(Ndb* pNdb,
       check = pOp->interpret_exit_ok();
       if( check == -1 ) {
 	ERR(pTrans->getNdbError());
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	return NDBT_FAILED;
       }
     }
@@ -524,7 +524,7 @@ UtilTransactions::selectCount(Ndb* pNdb,
     check = pTrans->execute(NoCommit);
     if( check == -1 ) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
 
@@ -539,17 +539,17 @@ UtilTransactions::selectCount(Ndb* pNdb,
       const NdbError err = pTrans->getNdbError();
       
       if (err.status == NdbError::TemporaryError){
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	NdbSleep_MilliSleep(50);
 	retryAttempt++;
 	continue;
       }
       ERR(err);
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
     
-    pNdb->closeTransaction(pTrans);
+    closeTransaction(pNdb);
     
     if (count_rows != NULL){
       *count_rows = rows;
@@ -653,7 +653,7 @@ restart:
     pOp = pTrans->getNdbScanOperation(tab.getName());	
     if (pOp == NULL) {
       const NdbError err = pNdb->getNdbError();
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       ERR(err);
       
       if (err.status == NdbError::TemporaryError){
@@ -673,14 +673,14 @@ restart:
     
     if( rs != 0 ) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
 
     check = pOp->interpret_exit_ok();
     if( check == -1 ) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
 
@@ -689,7 +689,7 @@ restart:
       if ((row.attributeStore(a) =  
 	   pOp->getValue(tab.getColumn(a)->getName())) == 0) {
 	ERR(pTrans->getNdbError());
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	return NDBT_FAILED;
       }
     }
@@ -700,13 +700,13 @@ restart:
       
       if (err.status == NdbError::TemporaryError){
 	ERR(err);
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	NdbSleep_MilliSleep(50);
 	retryAttempt++;
 	continue;
       }
       ERR(err);
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
     
@@ -733,13 +733,13 @@ restart:
 	  
 	  if (err.status == NdbError::TemporaryError){
 	    ERR(err);
-	    pNdb->closeTransaction(pTrans);
+	    closeTransaction(pNdb);
 	    NdbSleep_MilliSleep(50);
 	    retryAttempt++;
 	    goto restart;
 	  }
 	}
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	return NDBT_FAILED;
       }
     }
@@ -748,17 +748,17 @@ restart:
       
       if (err.status == NdbError::TemporaryError){
 	ERR(err);
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	NdbSleep_MilliSleep(50);
 	retryAttempt++;
 	continue;
       }
       ERR(err);
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
     
-    pNdb->closeTransaction(pTrans);
+    closeTransaction(pNdb);
     
     return NDBT_OK;
   }
@@ -1057,20 +1057,20 @@ UtilTransactions::verifyOrderedIndex(Ndb* pNdb,
     pOp = pTrans->getNdbScanOperation(tab.getName());	
     if (pOp == NULL) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
 
     if( pOp->readTuples(NdbScanOperation::LM_Read, 0, parallelism) ) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
 
     check = pOp->interpret_exit_ok();
     if( check == -1 ) {
       ERR(pTrans->getNdbError());
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
 
@@ -1085,13 +1085,13 @@ UtilTransactions::verifyOrderedIndex(Ndb* pNdb,
       
       if (err.status == NdbError::TemporaryError){
 	ERR(err);
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	NdbSleep_MilliSleep(50);
 	retryAttempt++;
 	continue;
       }
       ERR(err);
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
         
@@ -1146,7 +1146,7 @@ UtilTransactions::verifyOrderedIndex(Ndb* pNdb,
 	g_err << "Error when comapring records" << endl;
 	g_err << " scanRow: \n" << scanRow.c_str().c_str() << endl;
 	g_err << " pkRow: \n" << pkRow.c_str().c_str() << endl;
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	return NDBT_FAILED;
       }
 
@@ -1156,7 +1156,7 @@ UtilTransactions::verifyOrderedIndex(Ndb* pNdb,
 	if((res= iop->nextResult()) != 0){
 	  g_err << "Failed to find row using index: " << res << endl;
 	  ERR(pTrans->getNdbError());
-	  pNdb->closeTransaction(pTrans);
+	  closeTransaction(pNdb);
 	  return NDBT_FAILED;
 	}
 	
@@ -1164,14 +1164,14 @@ UtilTransactions::verifyOrderedIndex(Ndb* pNdb,
 	  g_err << "Error when comapring records" << endl;
 	  g_err << " scanRow: \n" << scanRow.c_str().c_str() << endl;
 	  g_err << " indexRow: \n" << indexRow.c_str().c_str() << endl;
-	  pNdb->closeTransaction(pTrans);
+	  closeTransaction(pNdb);
 	  return NDBT_FAILED;
 	}
 	
 	if(iop->nextResult() == 0){
 	  g_err << "Found extra row!!" << endl;
 	  g_err << " indexRow: \n" << indexRow.c_str().c_str() << endl;
-	  pNdb->closeTransaction(pTrans);
+	  closeTransaction(pNdb);
 	  return NDBT_FAILED;
 	}
       }
@@ -1184,18 +1184,18 @@ UtilTransactions::verifyOrderedIndex(Ndb* pNdb,
       if (err.status == NdbError::TemporaryError){
 	ERR(err);
 	iop = 0;
-	pNdb->closeTransaction(pTrans);
+	closeTransaction(pNdb);
 	NdbSleep_MilliSleep(50);
 	retryAttempt++;
 	rows--;
 	continue;
       }
       ERR(err);
-      pNdb->closeTransaction(pTrans);
+      closeTransaction(pNdb);
       return NDBT_FAILED;
     }
       
-    pNdb->closeTransaction(pTrans);
+    closeTransaction(pNdb);
     
     return NDBT_OK;
   }
@@ -1303,6 +1303,16 @@ UtilTransactions::getOperation(NdbConnection* pTrans,
 
 #include <HugoOperations.hpp>
 
+int
+UtilTransactions::closeTransaction(Ndb* pNdb)
+{
+  if (pTrans != NULL){
+    pNdb->closeTransaction(pTrans);
+    pTrans = NULL;
+  }
+  return 0;
+}
+
 int 
 UtilTransactions::compare(Ndb* pNdb, const char* tab_name2, int flags){
 
@@ -1313,7 +1323,6 @@ UtilTransactions::compare(Ndb* pNdb, const char* tab_name2, int flags){
 
   HugoCalculator calc(tab);
   NDBT_ResultRow row(tab);
-  NdbTransaction* pTrans= 0;
   const NdbDictionary::Table* tmp= pNdb->getDictionary()->getTable(tab_name2);
   if(tmp == 0)
   {
diff --git a/ndb/tools/Makefile.am b/ndb/tools/Makefile.am
index 1008b166dfc..17b71f7e33c 100644
--- a/ndb/tools/Makefile.am
+++ b/ndb/tools/Makefile.am
@@ -9,7 +9,7 @@ ndbtools_PROGRAMS = \
   ndb_show_tables \
   ndb_select_all \
   ndb_select_count \
-  ndb_restore
+  ndb_restore ndb_config
 
 tools_common_sources = ../test/src/NDBT_ReturnCodes.cpp \
                        ../test/src/NDBT_Table.cpp \
@@ -33,6 +33,17 @@ ndb_restore_SOURCES = restore/restore_main.cpp \
                       restore/Restore.cpp \
                       ../test/src/NDBT_ResultRow.cpp $(tools_common_sources)
 
+ndb_config_SOURCES = ndb_config.cpp \
+	../src/mgmsrv/Config.cpp \
+	../src/mgmsrv/ConfigInfo.cpp \
+	../src/mgmsrv/InitConfigFileParser.cpp
+
+ndb_config_CXXFLAGS = -I$(top_srcdir)/ndb/src/mgmapi \
+                      -I$(top_srcdir)/ndb/src/mgmsrv \
+                      -I$(top_srcdir)/ndb/include/mgmcommon \
+                      -DMYSQLCLUSTERDIR="\"\""
+
+
 include $(top_srcdir)/ndb/config/common.mk.am
 include $(top_srcdir)/ndb/config/type_ndbapitools.mk.am
 
@@ -46,6 +57,7 @@ ndb_show_tables_LDFLAGS = @ndb_bin_am_ldflags@
 ndb_select_all_LDFLAGS = @ndb_bin_am_ldflags@
 ndb_select_count_LDFLAGS = @ndb_bin_am_ldflags@
 ndb_restore_LDFLAGS = @ndb_bin_am_ldflags@
+ndb_config_LDFLAGS = @ndb_bin_am_ldflags@
 
 # Don't update the files from bitkeeper
 %::SCCS/s.%
diff --git a/ndb/tools/ndb_config.cpp b/ndb/tools/ndb_config.cpp
new file mode 100644
index 00000000000..d188aec1337
--- /dev/null
+++ b/ndb/tools/ndb_config.cpp
@@ -0,0 +1,407 @@
+/* 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 */
+
+/**
+ * ndb_config --nodes --query=nodeid --type=ndbd --host=local1
+ */
+
+#include <ndb_global.h>
+#include <my_sys.h>
+#include <my_getopt.h>
+#include <mysql_version.h>
+
+#include <NdbOut.hpp>
+#include <mgmapi.h>
+#include <mgmapi_configuration.hpp>
+#include <ConfigInfo.hpp>
+
+static int g_verbose = 0;
+static int try_reconnect = 3;
+
+static int g_nodes = 1;
+static const char * g_connectstring = 0;
+static const char * g_query = 0;
+
+static int g_nodeid = 0;
+static const char * g_type = 0;
+static const char * g_host = 0;
+static const char * g_field_delimiter=",";
+static const char * g_row_delimiter=" ";
+
+int g_print_full_config, opt_ndb_shm;
+
+typedef ndb_mgm_configuration_iterator Iter;
+
+static void ndb_std_print_version()
+{
+  printf("MySQL distrib %s, for %s (%s)\n",
+	 MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
+}
+
+static struct my_option my_long_options[] =
+{
+  { "usage", '?', "Display this help and exit.", 
+    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0 }, 
+  { "help", '?', "Display this help and exit.", 
+    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0 }, 
+  { "version", 'V', "Output version information and exit.", 0, 0, 0, 
+    GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0 }, 
+  { "ndb-connectstring", 256,
+    "Set connect string for connecting to ndb_mgmd. " 
+    "Syntax: \"[nodeid=<id>;][host=]<hostname>[:<port>]\". " 
+    "Overides specifying entries in NDB_CONNECTSTRING and Ndb.cfg", 
+    (gptr*) &g_connectstring, (gptr*) &g_connectstring, 
+    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
+  { "nodes", 256, "Print nodes",
+    (gptr*) &g_nodes, (gptr*) &g_nodes,
+    0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
+  { "query", 'q', "Query option(s)",
+    (gptr*) &g_query, (gptr*) &g_query,
+    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  { "host", 257, "Host",
+    (gptr*) &g_host, (gptr*) &g_host,
+    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  { "type", 258, "Type of node/connection",
+    (gptr*) &g_type, (gptr*) &g_type,
+    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  { "id", 258, "Nodeid",
+    (gptr*) &g_nodeid, (gptr*) &g_nodeid,
+    0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  { "nodeid", 258, "Nodeid",
+    (gptr*) &g_nodeid, (gptr*) &g_nodeid,
+    0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  { "fields", 'f', "Field separator",
+    (gptr*) &g_field_delimiter, (gptr*) &g_field_delimiter,
+    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  { "rows", 'r', "Row separator",
+    (gptr*) &g_row_delimiter, (gptr*) &g_row_delimiter,
+    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
+};
+
+static void usage()
+{
+  char desc[] = 
+    "This program will retreive config options for a ndb cluster\n";
+  ndb_std_print_version();
+  my_print_help(my_long_options);
+  my_print_variables(my_long_options);
+}
+static my_bool
+ndb_std_get_one_option(int optid,
+		       const struct my_option *opt __attribute__((unused)),
+		       char *argument)
+{
+  switch (optid) {
+  case 'V':
+    ndb_std_print_version();
+    exit(0);
+  case '?':
+    usage();
+    exit(0);
+  }
+  return 0;
+}
+
+/**
+ * Match/Apply framework
+ */
+struct Match
+{
+  int m_key;
+  BaseString m_value;
+  virtual int eval(NdbMgmHandle, const Iter&);
+};
+
+struct Apply
+{
+  Apply() {}
+  Apply(int val) { m_key = val;}
+  int m_key;
+  virtual int apply(NdbMgmHandle, const Iter&);
+};
+
+struct NodeTypeApply : public Apply
+{
+  virtual int apply(NdbMgmHandle, const Iter&);
+};
+
+static int parse_query(Vector<Apply*>&, int &argc, char**& argv);
+static int parse_where(Vector<Match*>&, int &argc, char**& argv);
+static int eval(NdbMgmHandle, const Iter&, const Vector<Match*>&);
+static int apply(NdbMgmHandle, const Iter&, const Vector<Apply*>&);
+int
+main(int argc, char** argv){
+  NDB_INIT(argv[0]);
+  const char *load_default_groups[]= { "mysql_cluster",0 };
+  load_defaults("my",load_default_groups,&argc,&argv);
+  int ho_error;
+  if ((ho_error=handle_options(&argc, &argv, my_long_options,
+			       ndb_std_get_one_option)))
+    return -1;
+
+  NdbMgmHandle mgm = ndb_mgm_create_handle();
+  if(mgm == NULL) {
+    fprintf(stderr, "Cannot create handle to management server.\n");
+    exit(-1);
+  }
+
+  ndb_mgm_set_error_stream(mgm, stderr);
+  
+  if (ndb_mgm_set_connectstring(mgm, g_connectstring))
+  {
+    fprintf(stderr, "* %5d: %s\n", 
+	    ndb_mgm_get_latest_error(mgm),
+	    ndb_mgm_get_latest_error_msg(mgm));
+    fprintf(stderr, 
+	    "*        %s", ndb_mgm_get_latest_error_desc(mgm));
+    exit(-1);
+  }
+
+  if(ndb_mgm_connect(mgm, try_reconnect-1, 5, 1))
+  {
+    fprintf(stderr, "Connect failed");
+    fprintf(stderr, " code: %d, msg: %s\n",
+	    ndb_mgm_get_latest_error(mgm),
+	    ndb_mgm_get_latest_error_msg(mgm));
+    exit(-1);
+  }
+  else if(g_verbose)
+  {
+    fprintf(stderr, "Connected to %s:%d\n", 
+	    ndb_mgm_get_connected_host(mgm),
+	    ndb_mgm_get_connected_port(mgm));
+  }
+	  
+  ndb_mgm_configuration * conf = ndb_mgm_get_configuration(mgm, 0);
+  if(conf == 0)
+  {
+    fprintf(stderr, "Could not get configuration");
+    fprintf(stderr, "code: %d, msg: %s\n",
+	    ndb_mgm_get_latest_error(mgm),
+	    ndb_mgm_get_latest_error_msg(mgm));
+    exit(-1);
+  }
+  else if(g_verbose)
+  {
+    fprintf(stderr, "Fetched configuration\n");
+  }
+
+  Vector<Apply*> select_list;
+  Vector<Match*> where_clause;
+
+  if(strcmp(g_row_delimiter, "\\n") == 0)
+    g_row_delimiter = "\n";
+  if(strcmp(g_field_delimiter, "\\n") == 0)
+    g_field_delimiter = "\n";
+
+  if(parse_query(select_list, argc, argv))
+  {
+    exit(0);
+  }
+
+  if(parse_where(where_clause, argc, argv))
+  {
+    exit(0);
+  }
+
+  Iter iter(* conf, CFG_SECTION_NODE);
+  bool prev= false;
+  iter.first();
+  for(iter.first(); iter.valid(); iter.next())
+  {
+    if(eval(mgm, iter, where_clause))
+    {
+      if(prev)
+	printf("%s", g_row_delimiter);
+      prev= true;
+      apply(mgm, iter, select_list);
+    }
+  }
+  printf("\n");
+  return 0;
+}
+
+static
+int
+parse_query(Vector<Apply*>& select, int &argc, char**& argv)
+{
+  if(g_query)
+  {
+    BaseString q(g_query);
+    Vector<BaseString> list;
+    q.split(list, ",");
+    for(unsigned i = 0; i<list.size(); i++)
+    {
+      const char * str= list[i].c_str();
+      if(strcasecmp(str, "id") == 0 || strcasecmp(str, "nodeid") == 0)
+	select.push_back(new Apply(CFG_NODE_ID));
+      else if(strncasecmp(str, "host", 4) == 0)
+	select.push_back(new Apply(CFG_NODE_HOST));
+      else if(strcasecmp(str, "type") == 0)
+	select.push_back(new NodeTypeApply());
+      else if(g_nodes)
+      {
+	bool found = false;
+	for(int p = 0; p<ConfigInfo::m_NoOfParams; p++)
+	{
+	  if(0)ndbout_c("%s %s",
+			ConfigInfo::m_ParamInfo[p]._section,
+			ConfigInfo::m_ParamInfo[p]._fname);
+	  if(strcmp(ConfigInfo::m_ParamInfo[p]._section, "DB") == 0 ||
+	     strcmp(ConfigInfo::m_ParamInfo[p]._section, "API") == 0 ||
+	     strcmp(ConfigInfo::m_ParamInfo[p]._section, "MGM") == 0)
+	  {
+	    if(strcasecmp(ConfigInfo::m_ParamInfo[p]._fname, str) == 0)
+	    {
+	      select.push_back(new Apply(ConfigInfo::m_ParamInfo[p]._paramId));
+	      found = true;
+	      break;
+	    }
+	  }
+	}
+	if(!found)
+	{
+	  fprintf(stderr, "Unknown query option: %s\n", str);
+	  return 1;
+	}
+      }
+      else
+      {
+	fprintf(stderr, "Unknown query option: %s\n", str);
+	return 1;
+      }
+    }
+  }
+  return 0;
+}
+
+static 
+int 
+parse_where(Vector<Match*>& where, int &argc, char**& argv)
+{
+  Match m;
+  if(g_host)
+  {
+    m.m_key = CFG_NODE_HOST;
+    m.m_value.assfmt("%s", g_host);
+    where.push_back(new Match(m));
+  }
+  
+  if(g_type)
+  {
+    m.m_key = CFG_TYPE_OF_SECTION;
+    m.m_value.assfmt("%d", ndb_mgm_match_node_type(g_type));
+    where.push_back(new Match(m));
+  }
+
+  if(g_nodeid)
+  {
+    m.m_key = CFG_NODE_ID;
+    m.m_value.assfmt("%d", g_nodeid);
+    where.push_back(new Match(m));
+  }
+  return 0;
+}
+
+template class Vector<Apply*>;
+template class Vector<Match*>;
+
+static 
+int
+eval(NdbMgmHandle mgm, const Iter& iter, const Vector<Match*>& where)
+{
+  for(unsigned i = 0; i<where.size(); i++)
+  {
+    if(where[i]->eval(mgm, iter) == 0)
+      return 0;
+  }
+  
+  return 1;
+}
+
+static 
+int 
+apply(NdbMgmHandle mgm, const Iter& iter, const Vector<Apply*>& list)
+{
+  for(unsigned i = 0; i<list.size(); i++)
+  {
+    list[i]->apply(mgm, iter);
+    if(i + 1 != list.size())
+      printf("%s", g_field_delimiter);
+  }
+  return 0;
+}
+
+int
+Match::eval(NdbMgmHandle h, const Iter& iter)
+{
+  Uint32 val32;
+  Uint64 val64;
+  const char* valc;
+  if (iter.get(m_key, &val32) == 0)
+  {
+    if(atoi(m_value.c_str()) != val32)
+      return 0;
+  } 
+  else if(iter.get(m_key, &val64) == 0)
+  {
+    if(strtoll(m_value.c_str(), (char **)NULL, 10) != val64)
+      return 0;
+  }
+  else if(iter.get(m_key, &valc) == 0)
+  {
+    if(strcmp(m_value.c_str(), valc) != 0)
+      return 0;
+  }
+  else
+  {
+    return 0;
+  }
+  return 1;
+}
+
+int
+Apply::apply(NdbMgmHandle h, const Iter& iter)
+{
+  Uint32 val32;
+  Uint64 val64;
+  const char* valc;
+  if (iter.get(m_key, &val32) == 0)
+  {
+    printf("%u", val32);
+  } 
+  else if(iter.get(m_key, &val64) == 0)
+  {
+    printf("%llu", val64);
+  }
+  else if(iter.get(m_key, &valc) == 0)
+  {
+    printf("%s", valc);
+  }
+  return 0;
+}
+
+int
+NodeTypeApply::apply(NdbMgmHandle h, const Iter& iter)
+{
+  Uint32 val32;
+  if (iter.get(CFG_TYPE_OF_SECTION, &val32) == 0)
+  {
+    printf("%s", ndb_mgm_get_node_type_alias_string((ndb_mgm_node_type)val32, 0));
+  } 
+  return 0;
+}