Merge mskold@bk-internal.mysql.com:/home/bk/mysql-5.0-ndb

into mysql.com:/usr/local/home/marty/MySQL/test/mysql-5.0-ndb

ndb/examples/Makefile

-# XXX ndbapi_example4, select_all commented out until fixed
-BIN_DIRS := ndbapi_example1 ndbapi_example2 ndbapi_example3  $(ndbapi_example4) \
-	    ndbapi_example5 $(select_all) ndbapi_scan_example
+BIN_DIRS := ndbapi_example1 ndbapi_example3 ndbapi_example4 \
+	    ndbapi_example5 ndbapi_scan_example
 
 bins: $(patsubst %, _bins_%, $(BIN_DIRS))
 

ndb/examples/ndbapi_example1/Makefile

 TARGET = ndbapi_example1
-SRCS = ndbapi_example1.cpp
-OBJS = ndbapi_example1.o
+SRCS = $(TARGET).cpp
+OBJS = $(TARGET).o
 CXX = g++
 CFLAGS = -c -Wall -fno-rtti -fno-exceptions
+CXXFLAGS = 
 DEBUG = 
 LFLAGS = -Wall
-INCLUDE_DIR = ../../include
-LIB_DIR = -L../../src/.libs \
-          -L../../../libmysql_r/.libs \
-          -L../../../mysys
+TOP_SRCDIR = ../../..
+INCLUDE_DIR = $(TOP_SRCDIR)
+LIB_DIR = -L$(TOP_SRCDIR)/ndb/src/.libs \
+          -L$(TOP_SRCDIR)/libmysql_r/.libs \
+          -L$(TOP_SRCDIR)/mysys
 SYS_LIB = 
 
 $(TARGET): $(OBJS)
-	$(CXX) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient_r -lmysys -lz $(SYS_LIB) -o $(TARGET)
+	$(CXX) $(CXXFLAGS) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient_r -lmysys -lz $(SYS_LIB) -o $(TARGET)
 
 $(TARGET).o: $(SRCS)
-	$(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)
+	$(CXX) $(CFLAGS) -I$(INCLUDE_DIR)/include -I$(INCLUDE_DIR)/ndb/include -I$(INCLUDE_DIR)/ndb/include/ndbapi $(SRCS)
 
 clean:
 	rm -f *.o $(TARGET)

ndb/examples/ndbapi_example1/ndbapi_example1.cpp

@@ -14,209 +14,242 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
-// 
-//  ndbapi_example1.cpp: Using synchronous transactions in NDB API
-//
-//  Correct output from this program is:
-//
-//  ATTR1 ATTR2
-//    0    10
-//    1     1
-//    2    12
-//  Detected that deleted tuple doesn't exist!
-//    4    14
-//    5     5
-//    6    16
-//    7     7
-//    8    18
-//    9     9
-
+/* 
+ *  ndbapi_example1.cpp: Using synchronous transactions in NDB API
+ *
+ *  Correct output from this program is:
+ *
+ *  ATTR1 ATTR2
+ *    0    10
+ *    1     1
+ *    2    12
+ *  Detected that deleted tuple doesn't exist!
+ *    4    14
+ *    5     5
+ *    6    16
+ *    7     7
+ *    8    18
+ *    9     9
+ *
+ */
+
+#include <mysql.h>
 #include <NdbApi.hpp>
-
 // Used for cout
 #include <stdio.h>
 #include <iostream>
 
-#define APIERROR(error) \
-  { std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \
-              << error.code << ", msg: " << error.message << "." << std::endl; \
-    exit(-1); }
+static void run_application(MYSQL &, Ndb_cluster_connection &);
+
+#define PRINT_ERROR(code,msg) \
+  std::cout << "Error in " << __FILE__ << ", line: " << __LINE__ \
+            << ", code: " << code \
+            << ", msg: " << msg << "." << std::endl
+#define MYSQLERROR(mysql) { \
+  PRINT_ERROR(mysql_errno(&mysql),mysql_error(&mysql)); \
+  exit(-1); }
+#define APIERROR(error) { \
+  PRINT_ERROR(error.code,error.message); \
+  exit(-1); }
 
 int main()
 {
+  // ndb_init must be called first
   ndb_init();
 
-  Ndb_cluster_connection *cluster_connection=
-    new Ndb_cluster_connection(); // Object representing the cluster
-
-  int r= cluster_connection->connect(5 /* retries               */,
-				     3 /* delay between retries */,
-				     1 /* verbose               */);
-  if (r > 0)
-  {
-    std::cout
-      << "Cluster connect failed, possibly resolved with more retries.\n";
-    exit(-1);
-  }
-  else if (r < 0)
+  // connect to mysql server and cluster and run application
   {
-    std::cout
-      << "Cluster connect failed.\n";
-    exit(-1);
-  }
-					   
+    // Object representing the cluster
+    Ndb_cluster_connection cluster_connection;
+
+    // Connect to cluster management server (ndb_mgmd)
+    if (cluster_connection.connect(4 /* retries               */,
+				   5 /* delay between retries */,
+				   1 /* verbose               */))
+    {
+      std::cout << "Cluster management server was not ready within 30 secs.\n";
+      exit(-1);
+    }
 
-  if (cluster_connection->wait_until_ready(30,30))
-  {
-    std::cout << "Cluster was not ready within 30 secs." << std::endl;
-    exit(-1);
+    // Optionally connect and wait for the storage nodes (ndbd's)
+    if (cluster_connection.wait_until_ready(30,30))
+    {
+      std::cout << "Cluster was not ready within 30 secs.\n";
+      exit(-1);
+    }
+
+    // connect to mysql server
+    MYSQL mysql;
+    if ( !mysql_init(&mysql) ) {
+      std::cout << "mysql_init failed\n";
+      exit(-1);
+    }
+    if ( !mysql_real_connect(&mysql, "localhost", "root", "", "",
+			     3306, "/tmp/mysql.sock", 0) )
+      MYSQLERROR(mysql);
+    
+    // run the application code
+    run_application(mysql, cluster_connection);
   }
 
-  Ndb* myNdb = new Ndb( cluster_connection,
-			"TEST_DB_1" );  // Object representing the database
-  NdbDictionary::Table myTable;
-  NdbDictionary::Column myColumn;
+  // ndb_end should not be called until all "Ndb" objects are deleted
+  ndb_end(0);
 
-  NdbConnection	 *myConnection;         // For other transactions
-  NdbOperation	 *myOperation;          // For other operations
-  NdbRecAttr     *myRecAttr;            // Result of reading attribute value
-  
+  std::cout << "\nTo drop created table use:\n"
+	    << "echo \"drop table MYTABLENAME\" | mysql TEST_DB_1 -u root\n";
+
+  return 0;
+}
+
+static void create_table(MYSQL &);
+static void do_insert(Ndb &);
+static void do_update(Ndb &);
+static void do_delete(Ndb &);
+static void do_read(Ndb &);
+
+static void run_application(MYSQL &mysql,
+			    Ndb_cluster_connection &cluster_connection)
+{
   /********************************************
-   * Initialize NDB and wait until it's ready *
+   * Connect to database via mysql-c          *
    ********************************************/
-  if (myNdb->init()) { 
-    APIERROR(myNdb->getNdbError());
-    exit(-1);
-  }
+  mysql_query(&mysql, "CREATE DATABASE TEST_DB_1");
+  if (mysql_query(&mysql, "USE TEST_DB_1") != 0) MYSQLERROR(mysql);
+  create_table(mysql);
 
-  NdbDictionary::Dictionary* myDict = myNdb->getDictionary();
-  
-  /*********************************************************
-   * Create a table named MYTABLENAME if it does not exist *
-   *********************************************************/
-  if (myDict->getTable("MYTABLENAME") != NULL) {
-    std::cout << "NDB already has example table: MYTABLENAME." << std::endl; 
-    exit(-1);
-  } 
-
-  myTable.setName("MYTABLENAME");
-  
-  myColumn.setName("ATTR1");
-  myColumn.setType(NdbDictionary::Column::Unsigned);
-  myColumn.setLength(1);
-  myColumn.setPrimaryKey(true);
-  myColumn.setNullable(false);
-  myTable.addColumn(myColumn);
-
-  myColumn.setName("ATTR2");
-  myColumn.setType(NdbDictionary::Column::Unsigned);
-  myColumn.setLength(1);
-  myColumn.setPrimaryKey(false);
-  myColumn.setNullable(false);
-  myTable.addColumn(myColumn);
-
-  if (myDict->createTable(myTable) == -1) 
-      APIERROR(myDict->getNdbError());
-
-  /**************************************************************************
-   * Using 5 transactions, insert 10 tuples in table: (0,0),(1,1),...,(9,9) *
-   **************************************************************************/
+  /********************************************
+   * Connect to database via NdbApi           *
+   ********************************************/
+  // Object representing the database
+  Ndb myNdb( &cluster_connection, "TEST_DB_1" );
+  if (myNdb.init()) APIERROR(myNdb.getNdbError());
+
+  /*
+   * Do different operations on database
+   */
+  do_insert(myNdb);
+  do_update(myNdb);
+  do_delete(myNdb);
+  do_read(myNdb);
+}
+
+/*********************************************************
+ * Create a table named MYTABLENAME if it does not exist *
+ *********************************************************/
+static void create_table(MYSQL &mysql)
+{
+  if (mysql_query(&mysql, 
+		  "CREATE TABLE"
+		  "  MYTABLENAME"
+		  "    (ATTR1 INT UNSIGNED PRIMARY KEY,"
+		  "     ATTR2 INT UNSIGNED)"
+		  "  ENGINE=NDB"))
+    MYSQLERROR(mysql);
+}
+
+/**************************************************************************
+ * Using 5 transactions, insert 10 tuples in table: (0,0),(1,1),...,(9,9) *
+ **************************************************************************/
+static void do_insert(Ndb &myNdb)
+{
   for (int i = 0; i < 5; i++) {
-    myConnection = myNdb->startTransaction();
-    if (myConnection == NULL) APIERROR(myNdb->getNdbError());
+    NdbTransaction *myTransaction= myNdb.startTransaction();
+    if (myTransaction == NULL) APIERROR(myNdb.getNdbError());
     
-    myOperation = myConnection->getNdbOperation("MYTABLENAME");	
-    if (myOperation == NULL) APIERROR(myConnection->getNdbError());
+    NdbOperation *myOperation= myTransaction->getNdbOperation("MYTABLENAME");
+    if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
     
     myOperation->insertTuple();
     myOperation->equal("ATTR1", i);
     myOperation->setValue("ATTR2", i);
 
-    myOperation = myConnection->getNdbOperation("MYTABLENAME");	
-    if (myOperation == NULL) APIERROR(myConnection->getNdbError());
+    myOperation= myTransaction->getNdbOperation("MYTABLENAME");
+    if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
 
     myOperation->insertTuple();
     myOperation->equal("ATTR1", i+5);
     myOperation->setValue("ATTR2", i+5);
     
-    if (myConnection->execute( Commit ) == -1)
-      APIERROR(myConnection->getNdbError());
+    if (myTransaction->execute( Commit ) == -1)
+      APIERROR(myTransaction->getNdbError());
     
-    myNdb->closeTransaction(myConnection);
+    myNdb.closeTransaction(myTransaction);
   }
-  
-  /*****************************************************************
-   * Update the second attribute in half of the tuples (adding 10) *
-   *****************************************************************/
+}
+ 
+/*****************************************************************
+ * Update the second attribute in half of the tuples (adding 10) *
+ *****************************************************************/
+static void do_update(Ndb &myNdb)
+{
   for (int i = 0; i < 10; i+=2) {
-    myConnection = myNdb->startTransaction();
-    if (myConnection == NULL) APIERROR(myNdb->getNdbError());
+    NdbTransaction *myTransaction= myNdb.startTransaction();
+    if (myTransaction == NULL) APIERROR(myNdb.getNdbError());
     
-    myOperation = myConnection->getNdbOperation("MYTABLENAME");	
-    if (myOperation == NULL) APIERROR(myConnection->getNdbError());
+    NdbOperation *myOperation= myTransaction->getNdbOperation("MYTABLENAME");
+    if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
     
     myOperation->updateTuple();
     myOperation->equal( "ATTR1", i );
     myOperation->setValue( "ATTR2", i+10);
     
-    if( myConnection->execute( Commit ) == -1 ) 
-      APIERROR(myConnection->getNdbError());
+    if( myTransaction->execute( Commit ) == -1 ) 
+      APIERROR(myTransaction->getNdbError());
     
-    myNdb->closeTransaction(myConnection);
+    myNdb.closeTransaction(myTransaction);
   }
+}
   
-  /*************************************************
-   * Delete one tuple (the one with primary key 3) *
-   *************************************************/
-  myConnection = myNdb->startTransaction();
-  if (myConnection == NULL) APIERROR(myNdb->getNdbError());
+/*************************************************
+ * Delete one tuple (the one with primary key 3) *
+ *************************************************/
+static void do_delete(Ndb &myNdb)
+{
+  NdbTransaction *myTransaction= myNdb.startTransaction();
+  if (myTransaction == NULL) APIERROR(myNdb.getNdbError());
   
-  myOperation = myConnection->getNdbOperation("MYTABLENAME");	
-  if (myOperation == NULL) 
-    APIERROR(myConnection->getNdbError());
+  NdbOperation *myOperation= myTransaction->getNdbOperation("MYTABLENAME");
+  if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
   
   myOperation->deleteTuple();
   myOperation->equal( "ATTR1", 3 );
   
-  if (myConnection->execute(Commit) == -1) 
-    APIERROR(myConnection->getNdbError());
-  
-  myNdb->closeTransaction(myConnection);
+  if (myTransaction->execute(Commit) == -1) 
+    APIERROR(myTransaction->getNdbError());
   
-  /*****************************
-   * Read and print all tuples *
-   *****************************/
+  myNdb.closeTransaction(myTransaction);
+}
+
+/*****************************
+ * Read and print all tuples *
+ *****************************/
+static void do_read(Ndb &myNdb)
+{
   std::cout << "ATTR1 ATTR2" << std::endl;
   
   for (int i = 0; i < 10; i++) {
-    myConnection = myNdb->startTransaction();
-    if (myConnection == NULL) APIERROR(myNdb->getNdbError());
+    NdbTransaction *myTransaction= myNdb.startTransaction();
+    if (myTransaction == NULL) APIERROR(myNdb.getNdbError());
     
-    myOperation = myConnection->getNdbOperation("MYTABLENAME");	
-    if (myOperation == NULL) APIERROR(myConnection->getNdbError());
+    NdbOperation *myOperation= myTransaction->getNdbOperation("MYTABLENAME");
+    if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
     
     myOperation->readTuple();
     myOperation->equal("ATTR1", i);
+
+    NdbRecAttr *myRecAttr= myOperation->getValue("ATTR2", NULL);
+    if (myRecAttr == NULL) APIERROR(myTransaction->getNdbError());
     
-    myRecAttr = myOperation->getValue("ATTR2", NULL);
-    if (myRecAttr == NULL) APIERROR(myConnection->getNdbError());
-    
-    if(myConnection->execute( Commit ) == -1)
+    if(myTransaction->execute( Commit ) == -1)
       if (i == 3) {
 	std::cout << "Detected that deleted tuple doesn't exist!" << std::endl;
       } else {
-	APIERROR(myConnection->getNdbError());
+	APIERROR(myTransaction->getNdbError());
       }
     
     if (i != 3) {
       printf(" %2d    %2d\n", i, myRecAttr->u_32_value());
     }
-    myNdb->closeTransaction(myConnection);
+    myNdb.closeTransaction(myTransaction);
   }
-
-  delete myNdb;
-  delete cluster_connection;
-
-  ndb_end(0);
-  return 0;
 }

ndb/examples/ndbapi_example2/Makefile

@@ -7,12 +7,12 @@ DEBUG =
 LFLAGS = -Wall
 INCLUDE_DIR = ../../include
 LIB_DIR = -L../../src/.libs \
-          -L../../../libmysql/.libs \
+          -L../../../libmysql_r/.libs \
           -L../../../mysys
 SYS_LIB = 
 
 $(TARGET): $(OBJS)
-	$(CXX) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient -lmysys $(SYS_LIB) -o $(TARGET)
+	$(CXX) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient_r -lmysys -lz $(SYS_LIB) -o $(TARGET)
 
 $(TARGET).o: $(SRCS)
 	$(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)

ndb/examples/ndbapi_example2/ndbapi_example2.cpp

@@ -35,7 +35,7 @@
               << error.code << ", msg: " << error.message << "." << std::endl; \
     exit(-1); }
 
-static void callback(int result, NdbConnection* NdbObject, void* aObject);
+static void callback(int result, NdbTransaction* NdbObject, void* aObject);
 
 int main()
 {
@@ -50,42 +50,56 @@ int main()
     exit(-1);
   }
 
+  int r= cluster_connection->connect(5 /* retries               */,
+				     3 /* delay between retries */,
+				     1 /* verbose               */);
+  if (r > 0)
+  {
+    std::cout
+      << "Cluster connect failed, possibly resolved with more retries.\n";
+    exit(-1);
+  }
+  else if (r < 0)
+  {
+    std::cout
+      << "Cluster connect failed.\n";
+    exit(-1);
+  }
+					   
+  if (cluster_connection->wait_until_ready(30,30))
+  {
+    std::cout << "Cluster was not ready within 30 secs." << std::endl;
+    exit(-1);
+  }
+
   Ndb* myNdb = new Ndb( cluster_connection,
 			"TEST_DB_2" );  // Object representing the database
 
-  NdbConnection*  myNdbConnection[2];   // For transactions
+  NdbTransaction*  myNdbTransaction[2];   // For transactions
   NdbOperation*   myNdbOperation;       // For operations
   
-  /*******************************************
-   * Initialize NDB and wait until its ready *
-   *******************************************/
   if (myNdb->init(2) == -1) {          // Want two parallel insert transactions
     APIERROR(myNdb->getNdbError());
     exit(-1);
   }
 
-  if (myNdb->waitUntilReady(30) != 0) {
-    std::cout << "NDB was not ready within 30 secs." << std::endl;
-    exit(-1);
-  }
-
   /******************************************************
    * Insert (we do two insert transactions in parallel) *
    ******************************************************/
   for (int i = 0; i < 2; i++) {
-    myNdbConnection[i] = myNdb->startTransaction();
-    if (myNdbConnection[i] == NULL) APIERROR(myNdb->getNdbError());
+    myNdbTransaction[i] = myNdb->startTransaction();
+    if (myNdbTransaction[i] == NULL) APIERROR(myNdb->getNdbError());
     
-    myNdbOperation = myNdbConnection[i]->getNdbOperation("MYTABLENAME");
+    myNdbOperation = myNdbTransaction[i]->getNdbOperation("MYTABLENAME");
     // Error check. If error, then maybe table MYTABLENAME is not in database
-    if (myNdbOperation == NULL) APIERROR(myNdbConnection[i]->getNdbError());
+    if (myNdbOperation == NULL) APIERROR(myNdbTransaction[i]->getNdbError());
     
     myNdbOperation->insertTuple();
     myNdbOperation->equal("ATTR1", 20 + i);
     myNdbOperation->setValue("ATTR2", 20 + i);
     
     // Prepare transaction (the transaction is NOT yet sent to NDB)
-    myNdbConnection[i]->executeAsynchPrepare(Commit, &callback, NULL);
+    myNdbTransaction[i]->executeAsynchPrepare(Commit, &callback, NULL);
   }
 
   // Send all transactions to NDB 
@@ -96,7 +110,7 @@ int main()
   
   // Close all transactions
   for (int i = 0; i < 2; i++) 
-    myNdb->closeTransaction(myNdbConnection[i]);
+    myNdb->closeTransaction(myNdbTransaction[i]);
 
   delete myNdb;
   delete cluster_connection;
@@ -110,12 +124,12 @@ int main()
  *              
  *   (This function must have three arguments: 
  *   - The result of the transaction, 
- *   - The NdbConnection object, and 
+ *   - The NdbTransaction object, and 
  *   - A pointer to an arbitrary object.)
  */
 
 static void
-callback(int result, NdbConnection* myTrans, void* aObject)
+callback(int result, NdbTransaction* myTrans, void* aObject)
 {
   if (result == -1) {
     std::cout << "Poll error: " << std::endl; 

ndb/examples/ndbapi_example3/Makefile

@@ -7,12 +7,12 @@ DEBUG =
 LFLAGS = -Wall
 INCLUDE_DIR = ../../include
 LIB_DIR = -L../../src/.libs \
-          -L../../../libmysql/.libs \
+          -L../../../libmysql_r/.libs \
           -L../../../mysys
 SYS_LIB = 
 
 $(TARGET): $(OBJS)
-	$(CXX) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient -lmysys $(SYS_LIB) -o $(TARGET)
+	$(CXX) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient_r -lmysys -lz $(SYS_LIB) -o $(TARGET)
 
 $(TARGET).o: $(SRCS)
 	$(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)

ndb/examples/ndbapi_example3/ndbapi_example3.cpp

@@ -22,7 +22,7 @@
 //
 //  There are many ways to program using the NDB API.  In this example
 //  we execute two inserts in the same transaction using 
-//  NdbConnection::Ndbexecute(NoCommit).
+//  NdbConnection::execute(NoCommit).
 // 
 //  Transaction failing is handled by re-executing the transaction
 //  in case of non-permanent transaction errors.
@@ -52,28 +52,28 @@
   }
 
 //
-//  CONERROR prints all error info regarding an NdbConnection
+//  TRANSERROR prints all error info regarding an NdbTransaction
 //
-#define CONERROR(ndbConnection) \
-  { NdbError error = ndbConnection->getNdbError(); \
-    std::cout << "CON ERROR: " << error.code << " " << error.message \
+#define TRANSERROR(ndbTransaction) \
+  { NdbError error = ndbTransaction->getNdbError(); \
+    std::cout << "TRANS ERROR: " << error.code << " " << error.message \
               << std::endl \
               << "           " << "Status: " << error.status \
               << ", Classification: " << error.classification << std::endl \
               << "           " << "File: " << __FILE__ \
               << " (Line: " << __LINE__ << ")" << std::endl \
               ; \
-    printTransactionError(ndbConnection); \
+    printTransactionError(ndbTransaction); \
   }
 
-void printTransactionError(NdbConnection *ndbConnection) {
+void printTransactionError(NdbTransaction *ndbTransaction) {
   const NdbOperation *ndbOp = NULL;
   int i=0;
 
   /****************************************************************
    * Print NdbError object of every operations in the transaction *
    ****************************************************************/
-  while ((ndbOp = ndbConnection->getNextCompletedOperation(ndbOp)) != NULL) {
+  while ((ndbOp = ndbTransaction->getNextCompletedOperation(ndbOp)) != NULL) {
     NdbError error = ndbOp->getNdbError();
     std::cout << "           OPERATION " << i+1 << ": " 
 	      << error.code << " " << error.message << std::endl
@@ -86,15 +86,15 @@ void printTransactionError(NdbConnection *ndbConnection) {
 
 //
 //  Example insert
-//  @param myNdb         Ndb object representing NDB Cluster
-//  @param myConnection  NdbConnection used for transaction
-//  @param error         NdbError object returned in case of errors
+//  @param myNdb          Ndb object representing NDB Cluster
+//  @param myTransaction  NdbTransaction used for transaction
+//  @param error          NdbError object returned in case of errors
 //  @return -1 in case of failures, 0 otherwise
 //
-int insert(int transactionId, NdbConnection* myConnection) {
+int insert(int transactionId, NdbTransaction* myTransaction) {
   NdbOperation	 *myOperation;          // For other operations
 
-  myOperation = myConnection->getNdbOperation("MYTABLENAME");
+  myOperation = myTransaction->getNdbOperation("MYTABLENAME");
   if (myOperation == NULL) return -1;
   
   if (myOperation->insertTuple() ||  
@@ -104,7 +104,7 @@ int insert(int transactionId, NdbConnection* myConnection) {
     exit(-1);
   }
 
-  return myConnection->execute(NoCommit);
+  return myTransaction->execute(NoCommit);
 }
 
 
@@ -116,7 +116,7 @@ int insert(int transactionId, NdbConnection* myConnection) {
 int executeInsertTransaction(int transactionId, Ndb* myNdb) {
   int result = 0;                       // No result yet
   int noOfRetriesLeft = 10;
-  NdbConnection	 *myConnection;         // For other transactions
+  NdbTransaction	 *myTransaction;         // For other transactions
   NdbError ndberror;
   
   while (noOfRetriesLeft > 0 && !result) {
@@ -124,16 +124,16 @@ int executeInsertTransaction(int transactionId, Ndb* myNdb) {
     /*********************************
      * Start and execute transaction *
      *********************************/
-    myConnection = myNdb->startTransaction();
-    if (myConnection == NULL) {
+    myTransaction = myNdb->startTransaction();
+    if (myTransaction == NULL) {
       APIERROR(myNdb->getNdbError());
       ndberror = myNdb->getNdbError();
       result = -1;  // Failure
-    } else if (insert(transactionId, myConnection) || 
-	       insert(10000+transactionId, myConnection) ||
-	       myConnection->execute(Commit)) {
-      CONERROR(myConnection);
-      ndberror = myConnection->getNdbError();
+    } else if (insert(transactionId, myTransaction) || 
+	       insert(10000+transactionId, myTransaction) ||
+	       myTransaction->execute(Commit)) {
+      TRANSERROR(myTransaction);
+      ndberror = myTransaction->getNdbError();
       result = -1;  // Failure
     } else {
       result = 1;   // Success
@@ -164,8 +164,8 @@ int executeInsertTransaction(int transactionId, Ndb* myNdb) {
     /*********************
      * Close transaction *
      *********************/
-    if (myConnection != NULL) {
-      myNdb->closeTransaction(myConnection);
+    if (myTransaction != NULL) {
+      myNdb->closeTransaction(myTransaction);
     }
   }
 
@@ -181,28 +181,36 @@ int main()
   Ndb_cluster_connection *cluster_connection=
     new Ndb_cluster_connection(); // Object representing the cluster
 
+  int r= cluster_connection->connect(5 /* retries               */,
+				     3 /* delay between retries */,
+				     1 /* verbose               */);
+  if (r > 0)
+  {
+    std::cout
+      << "Cluster connect failed, possibly resolved with more retries.\n";
+    exit(-1);
+  }
+  else if (r < 0)
+  {
+    std::cout
+      << "Cluster connect failed.\n";
+    exit(-1);
+  }
+					   
   if (cluster_connection->wait_until_ready(30,30))
   {
     std::cout << "Cluster was not ready within 30 secs." << std::endl;
     exit(-1);
   }
 
-  Ndb* myNdb = new Ndb( cluster_connection,
-			"TEST_DB_1" );  // Object representing the database
+  Ndb* myNdb= new Ndb( cluster_connection,
+		       "TEST_DB_1" );  // Object representing the database
   
-  /*******************************************
-   * Initialize NDB and wait until its ready *
-   *******************************************/
-  if (myNdb->init() == -1) { 
+  if (myNdb->init() == -1) {
     APIERROR(myNdb->getNdbError());
     exit(-1);
   }
 
-  if (myNdb->waitUntilReady(30) != 0) {
-    std::cout << "NDB was not ready within 30 secs." << std::endl;
-    exit(-1);
-  }
-  
   /************************************
    * Execute some insert transactions *
    ************************************/

ndb/examples/ndbapi_example4/Makefile

@@ -7,12 +7,12 @@ DEBUG =
 LFLAGS = -Wall
 INCLUDE_DIR = ../../include
 LIB_DIR = -L../../src/.libs \
-          -L../../../libmysql/.libs \
+          -L../../../libmysql_r/.libs \
           -L../../../mysys
 SYS_LIB = 
 
 $(TARGET): $(OBJS)
-	$(CXX) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient -lmysys $(SYS_LIB) -o $(TARGET)
+	$(CXX) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient_r -lmysys -lz $(SYS_LIB) -o $(TARGET)
 
 $(TARGET).o: $(SRCS)
 	$(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)

ndb/examples/ndbapi_example4/ndbapi_example4.cpp

@@ -49,6 +49,22 @@ int main()
   Ndb_cluster_connection *cluster_connection=
     new Ndb_cluster_connection(); // Object representing the cluster
 
+  int r= cluster_connection->connect(5 /* retries               */,
+				     3 /* delay between retries */,
+				     1 /* verbose               */);
+  if (r > 0)
+  {
+    std::cout
+      << "Cluster connect failed, possibly resolved with more retries.\n";
+    exit(-1);
+  }
+  else if (r < 0)
+  {
+    std::cout
+      << "Cluster connect failed.\n";
+    exit(-1);
+  }
+					   
   if (cluster_connection->wait_until_ready(30,30))
   {
     std::cout << "Cluster was not ready within 30 secs." << std::endl;
@@ -61,24 +77,16 @@ int main()
   NdbDictionary::Column myColumn;
   NdbDictionary::Index myIndex;
 
-  NdbConnection	 	*myConnection;     // For transactions
+  NdbTransaction	*myTransaction;     // For transactions
   NdbOperation	 	*myOperation;      // For primary key operations
   NdbIndexOperation	*myIndexOperation; // For index operations
   NdbRecAttr     	*myRecAttr;        // Result of reading attribute value
   
-  /********************************************
-   * Initialize NDB and wait until it's ready *
-   ********************************************/
   if (myNdb->init() == -1) { 
     APIERROR(myNdb->getNdbError());
     exit(-1);
   }
 
-  if (myNdb->waitUntilReady(30) != 0) {
-    std::cout << "NDB was not ready within 30 secs." << std::endl;
-    exit(-1);
-  }
-  
   /*********************************************************
    * Create a table named MYTABLENAME if it does not exist *
    *********************************************************/
@@ -130,27 +138,27 @@ int main()
    * Using 5 transactions, insert 10 tuples in table: (0,0),(1,1),...,(9,9) *
    **************************************************************************/
   for (int i = 0; i < 5; i++) {
-    myConnection = myNdb->startTransaction();
-    if (myConnection == NULL) APIERROR(myNdb->getNdbError());
+    myTransaction = myNdb->startTransaction();
+    if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
     
-    myOperation = myConnection->getNdbOperation("MYTABLENAME");	
-    if (myOperation == NULL) APIERROR(myConnection->getNdbError());
+    myOperation = myTransaction->getNdbOperation("MYTABLENAME");	
+    if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
     
     myOperation->insertTuple();
     myOperation->equal("ATTR1", i);
     myOperation->setValue("ATTR2", i);
 
-    myOperation = myConnection->getNdbOperation("MYTABLENAME");	
-    if (myOperation == NULL) APIERROR(myConnection->getNdbError());
+    myOperation = myTransaction->getNdbOperation("MYTABLENAME");	
+    if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
 
     myOperation->insertTuple();
     myOperation->equal("ATTR1", i+5);
     myOperation->setValue("ATTR2", i+5);
     
-    if (myConnection->execute( Commit ) == -1)
-      APIERROR(myConnection->getNdbError());
+    if (myTransaction->execute( Commit ) == -1)
+      APIERROR(myTransaction->getNdbError());
     
-    myNdb->closeTransaction(myConnection);
+    myNdb->closeTransaction(myTransaction);
   }
   
   /*****************************************
@@ -159,63 +167,63 @@ int main()
   std::cout << "ATTR1 ATTR2" << std::endl;
   
   for (int i = 0; i < 10; i++) {
-    myConnection = myNdb->startTransaction();
-    if (myConnection == NULL) APIERROR(myNdb->getNdbError());
+    myTransaction = myNdb->startTransaction();
+    if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
     
-    myIndexOperation = myConnection->getNdbIndexOperation("MYINDEXNAME",
-							  "MYTABLENAME");	
-    if (myIndexOperation == NULL) APIERROR(myConnection->getNdbError());
+    myIndexOperation = myTransaction->getNdbIndexOperation("MYINDEXNAME",
+							   "MYTABLENAME");
+    if (myIndexOperation == NULL) APIERROR(myTransaction->getNdbError());
     
     myIndexOperation->readTuple();
     myIndexOperation->equal("ATTR2", i);
     
     myRecAttr = myIndexOperation->getValue("ATTR1", NULL);
-    if (myRecAttr == NULL) APIERROR(myConnection->getNdbError());
+    if (myRecAttr == NULL) APIERROR(myTransaction->getNdbError());
 
-    if(myConnection->execute( Commit ) != -1)
+    if(myTransaction->execute( Commit ) != -1)
       printf(" %2d    %2d\n", myRecAttr->u_32_value(), i);
     }
-    myNdb->closeTransaction(myConnection);
+    myNdb->closeTransaction(myTransaction);
 
   /*****************************************************************
    * Update the second attribute in half of the tuples (adding 10) *
    *****************************************************************/
   for (int i = 0; i < 10; i+=2) {
-    myConnection = myNdb->startTransaction();
-    if (myConnection == NULL) APIERROR(myNdb->getNdbError());
+    myTransaction = myNdb->startTransaction();
+    if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
     
-    myIndexOperation = myConnection->getNdbIndexOperation("MYINDEXNAME",
-							  "MYTABLENAME");	
-    if (myIndexOperation == NULL) APIERROR(myConnection->getNdbError());
+    myIndexOperation = myTransaction->getNdbIndexOperation("MYINDEXNAME",
+							   "MYTABLENAME");
+    if (myIndexOperation == NULL) APIERROR(myTransaction->getNdbError());
     
     myIndexOperation->updateTuple();
     myIndexOperation->equal( "ATTR2", i );
     myIndexOperation->setValue( "ATTR2", i+10);
     
-    if( myConnection->execute( Commit ) == -1 ) 
-      APIERROR(myConnection->getNdbError());
+    if( myTransaction->execute( Commit ) == -1 ) 
+      APIERROR(myTransaction->getNdbError());
     
-    myNdb->closeTransaction(myConnection);
+    myNdb->closeTransaction(myTransaction);
   }
   
   /*************************************************
    * Delete one tuple (the one with primary key 3) *
    *************************************************/
-  myConnection = myNdb->startTransaction();
-  if (myConnection == NULL) APIERROR(myNdb->getNdbError());
+  myTransaction = myNdb->startTransaction();
+  if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
   
-  myIndexOperation = myConnection->getNdbIndexOperation("MYINDEXNAME",
-							"MYTABLENAME");	
+  myIndexOperation = myTransaction->getNdbIndexOperation("MYINDEXNAME",
+							 "MYTABLENAME");
   if (myIndexOperation == NULL) 
-    APIERROR(myConnection->getNdbError());
+    APIERROR(myTransaction->getNdbError());
   
   myIndexOperation->deleteTuple();
   myIndexOperation->equal( "ATTR2", 3 );
   
-  if (myConnection->execute(Commit) == -1) 
-    APIERROR(myConnection->getNdbError());
+  if (myTransaction->execute(Commit) == -1) 
+    APIERROR(myTransaction->getNdbError());
   
-  myNdb->closeTransaction(myConnection);
+  myNdb->closeTransaction(myTransaction);
   
   /*****************************
    * Read and print all tuples *
@@ -223,29 +231,29 @@ int main()
   std::cout << "ATTR1 ATTR2" << std::endl;
   
   for (int i = 0; i < 10; i++) {
-    myConnection = myNdb->startTransaction();
-    if (myConnection == NULL) APIERROR(myNdb->getNdbError());
+    myTransaction = myNdb->startTransaction();
+    if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
     
-    myOperation = myConnection->getNdbOperation("MYTABLENAME");	
-    if (myOperation == NULL) APIERROR(myConnection->getNdbError());
+    myOperation = myTransaction->getNdbOperation("MYTABLENAME");	
+    if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
     
     myOperation->readTuple();
     myOperation->equal("ATTR1", i);
     
     myRecAttr = myOperation->getValue("ATTR2", NULL);
-    if (myRecAttr == NULL) APIERROR(myConnection->getNdbError());
+    if (myRecAttr == NULL) APIERROR(myTransaction->getNdbError());
     
-    if(myConnection->execute( Commit ) == -1)
+    if(myTransaction->execute( Commit ) == -1)
       if (i == 3) {
 	std::cout << "Detected that deleted tuple doesn't exist!" << std::endl;
       } else {
-	APIERROR(myConnection->getNdbError());
+	APIERROR(myTransaction->getNdbError());
       }
     
     if (i != 3) {
       printf(" %2d    %2d\n", i, myRecAttr->u_32_value());
     }
-    myNdb->closeTransaction(myConnection);
+    myNdb->closeTransaction(myTransaction);
   }
 
   /**************

ndb/examples/ndbapi_example5/Makefile

@@ -9,12 +9,12 @@ LFLAGS = -Wall
 TOP_SRCDIR = ../../..
 INCLUDE_DIR = $(TOP_SRCDIR)/ndb/include
 LIB_DIR = -L$(TOP_SRCDIR)/ndb/src/.libs \
-          -L$(TOP_SRCDIR)/libmysql/.libs \
+          -L$(TOP_SRCDIR)/libmysql_r/.libs \
           -L$(TOP_SRCDIR)/mysys
 SYS_LIB = 
 
 $(TARGET): $(OBJS)
-	$(CXX) $(CXXFLAGS) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient -lmysys $(SYS_LIB) -o $(TARGET)
+	$(CXX) $(CXXFLAGS) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient_r -lmysys -lz $(SYS_LIB) -o $(TARGET)
 
 $(TARGET).o: $(SRCS)
 	$(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)

ndb/examples/ndbapi_example5/ndbapi_example5.cpp

@@ -19,7 +19,6 @@
  */
 
 #include <NdbApi.hpp>
-#include <NdbEventOperation.hpp>
 
 // Used for cout
 #include <stdio.h>
@@ -59,8 +58,8 @@
 int myCreateEvent(Ndb* myNdb,
 		  const char *eventName,
 		  const char *eventTableName,
-		  const char **eventComlumnName,
-		  const int noEventComlumnName);
+		  const char **eventColumnName,
+		  const int noEventColumnName);
 
 int main()
 {
@@ -69,6 +68,22 @@ int main()
   Ndb_cluster_connection *cluster_connection=
     new Ndb_cluster_connection(); // Object representing the cluster
 
+  int r= cluster_connection->connect(5 /* retries               */,
+				     3 /* delay between retries */,
+				     1 /* verbose               */);
+  if (r > 0)
+  {
+    std::cout
+      << "Cluster connect failed, possibly resolved with more retries.\n";
+    exit(-1);
+  }
+  else if (r < 0)
+  {
+    std::cout
+      << "Cluster connect failed.\n";
+    exit(-1);
+  }
+					   
   if (cluster_connection->wait_until_ready(30,30))
   {
     std::cout << "Cluster was not ready within 30 secs." << std::endl;
@@ -78,39 +93,30 @@ int main()
   Ndb* myNdb= new Ndb(cluster_connection,
 		      "TEST_DB");  // Object representing the database
 
-  if (myNdb->init() == -1) { 
-    APIERROR(myNdb->getNdbError());
-    exit(-1);
-  }
-
-  NdbDictionary::Dictionary *myDict;
+  if (myNdb->init() == -1) APIERROR(myNdb->getNdbError());
 
   const char *eventName= "CHNG_IN_TAB0";
   const char *eventTableName= "TAB0";
   const int noEventColumnName= 3;
-  const char *eventColumnName[noEventColumnName] =
+  const char *eventColumnName[noEventColumnName]=
     {"COL0",
      "COL1",
      "COL11"};
   
-  myDict = myNdb->getDictionary();
-
   // Create events
   myCreateEvent(myNdb,
 		eventName,
 		eventTableName,
 		eventColumnName,
 		noEventColumnName);
-  int j = 0;
+  int j= 0;
   while (j < 5) {
 
     // Start "transaction" for handling events
     NdbEventOperation* op;
     printf("create EventOperation\n");
-    if ((op = myNdb->createEventOperation(eventName,100)) == NULL) {
-      printf("Event operation creation failed\n");
-      exit(-1);
-    }
+    if ((op = myNdb->createEventOperation(eventName,100)) == NULL)
+      APIERROR(myNdb->getNdbError());
 
     printf("get values\n");
     NdbRecAttr* recAttr[noEventColumnName];
@@ -124,22 +130,21 @@ int main()
     // set up the callbacks
     printf("execute\n");
     if (op->execute()) { // This starts changes to "start flowing"
-      printf("operationd execution failed\n");
+      printf("operation execution failed\n");
       exit(-1);
     }
 
-    int i = 0;
-
+    int i= 0;
     while(i < 40) {
-      //printf("now waiting for event...\n");
-      int r = myNdb->pollEvents(1000); // wait for event or 1000 ms
-      if (r>0) {
-	//printf("got data! %d\n", r);
+      // printf("now waiting for event...\n");
+      int r= myNdb->pollEvents(1000); // wait for event or 1000 ms
+      if (r > 0) {
+	// printf("got data! %d\n", r);
 	int overrun;
 	while (op->next(&overrun) > 0) {
 	  i++;
 	  if (!op->isConsistent())
-	    printf("A node failiure has occured and events might be missing\n");
+	    printf("A node failure has occured and events might be missing\n");
 	  switch (op->getEventType()) {
 	  case NdbDictionary::Event::TE_INSERT:
 	    printf("%u INSERT: ", i);
@@ -175,13 +180,17 @@ int main()
       } else
 	;//printf("timed out\n");
     }
-    // don't want to listen to eventsanymore
+    // don't want to listen to events anymore
     myNdb->dropEventOperation(op);
 
     j++;
   }
 
-  myDict->dropEvent(eventName); // remove event from database
+  {
+    NdbDictionary::Dictionary *myDict = myNdb->getDictionary();
+    if (!myDict) APIERROR(myNdb->getNdbError());
+    myDict->dropEvent(eventName); // remove event from database
+  }
 
   delete myNdb;
   delete cluster_connection;
@@ -195,12 +204,8 @@ int myCreateEvent(Ndb* myNdb,
 		  const char **eventColumnName,
 		  const int noEventColumnName)
 {
-  NdbDictionary::Dictionary *myDict = myNdb->getDictionary();
-
-  if (!myDict) {
-    printf("Event Creation failedDictionary not found");
-    exit(-1);
-  }
+  NdbDictionary::Dictionary *myDict= myNdb->getDictionary();
+  if (!myDict) APIERROR(myNdb->getNdbError());
 
   NdbDictionary::Event myEvent(eventName);
   myEvent.setTable(eventTableName);

ndb/examples/ndbapi_scan_example/Makefile

@@ -9,12 +9,12 @@ LFLAGS = -Wall
 TOP_SRCDIR = ../../..
 INCLUDE_DIR = $(TOP_SRCDIR)/ndb/include
 LIB_DIR = -L$(TOP_SRCDIR)/ndb/src/.libs \
-          -L$(TOP_SRCDIR)/libmysql/.libs \
+          -L$(TOP_SRCDIR)/libmysql_r/.libs \
           -L$(TOP_SRCDIR)/mysys
 SYS_LIB = 
 
 $(TARGET): $(OBJS)
-	$(CXX) $(CXXFLAGS) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient -lmysys $(SYS_LIB) -o $(TARGET)
+	$(CXX) $(CXXFLAGS) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient_r -lmysys -lz $(SYS_LIB) -o $(TARGET)
 
 $(TARGET).o: $(SRCS)
 	$(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)

ndb/examples/ndbapi_scan_example/ndbapi_scan.cpp

@@ -24,9 +24,12 @@
  *
  * Classes and methods used in this example:
  *
+ *  Ndb_cluster_connection
+ *       connect()
+ *       wait_until_ready()
+ *
  *  Ndb
  *       init()
- *       waitUntilRead()
  *       getDictionary()
  *       startTransaction()
  *       closeTransaction()
@@ -74,7 +77,6 @@
 
 
 #include <NdbApi.hpp>
-#include <NdbScanFilter.hpp>
 // Used for cout
 #include <iostream>
 
@@ -235,7 +237,7 @@ int scan_delete(Ndb* myNdb,
   int deletedRows = 0;
   int check;
   NdbError              err;
-  NdbConnection		*myTrans;
+  NdbTransaction	*myTrans;
   NdbScanOperation	*myScanOp;
 
   /**
@@ -407,7 +409,7 @@ int scan_update(Ndb* myNdb,
   int updatedRows = 0;
   int check;
   NdbError              err;
-  NdbConnection		*myTrans;
+  NdbTransaction	*myTrans;
   NdbScanOperation	*myScanOp;
 
   /**
@@ -588,7 +590,7 @@ int scan_print(Ndb * myNdb)
   int fetchedRows = 0;
   int check;
   NdbError              err;
-  NdbConnection		*myTrans;
+  NdbTransaction	*myTrans;
   NdbScanOperation	*myScanOp;
   /* Result of reading attribute value, three columns:
      REG_NO, BRAND, and COLOR

ndb/include/ndbapi/Ndb.hpp

@@ -122,8 +122,7 @@
      // 4. Attribute Actions
      MyRecAttr= MyOperation->getValue("ATTR2", NULL);
    @endcode
-   For additional examples of this sort, see @ref ndbapi_example1.cpp and 
-   @ref ndbapi_example2.cpp.
+   For additional examples of this sort, see @ref ndbapi_example1.cpp.
 
    The second example uses an NdbIndexOperation:
    @code
@@ -428,10 +427,12 @@
  * @include ndbapi_example1.cpp 
  */
 
+#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
 /**
  * @page ndbapi_example2.cpp ndbapi_example2.cpp
  * @include ndbapi_example2.cpp 
  */
+#endif
 
 /**
  * @page ndbapi_example3.cpp ndbapi_example3.cpp

ndb/include/ndbapi/NdbRecAttr.hpp

@@ -39,8 +39,7 @@ class NdbOperation;
  *   ndbout << MyRecAttr->u_32_value();
  * @endcode
  * For more examples, see 
- * @ref ndbapi_example1.cpp and 
- * @ref ndbapi_example2.cpp.
+ * @ref ndbapi_example1.cpp.
  *
  * @note The NdbRecAttr object is instantiated with its value when 
  *       NdbTransaction::execute is called.  Before this, the value is