updated ndbapi examples

    removed references to example2 (asynch api)


ndb/examples/Makefile:
  updated ndbapi examples
ndb/examples/ndbapi_example1/ndbapi_example1.cpp:
  updated ndbapi examples
ndb/examples/ndbapi_example2/Makefile:
  updated ndbapi examples
ndb/examples/ndbapi_example2/ndbapi_example2.cpp:
  updated ndbapi examples
ndb/examples/ndbapi_example3/Makefile:
  updated ndbapi examples
ndb/examples/ndbapi_example3/ndbapi_example3.cpp:
  updated ndbapi examples
ndb/examples/ndbapi_example4/Makefile:
  updated ndbapi examples
ndb/examples/ndbapi_example4/ndbapi_example4.cpp:
  updated ndbapi examples
ndb/examples/ndbapi_example5/Makefile:
  updated ndbapi examples
ndb/examples/ndbapi_example5/ndbapi_example5.cpp:
  updated ndbapi examples
ndb/include/ndbapi/Ndb.hpp:
  removed references to example2 (asynch api)
ndb/include/ndbapi/NdbRecAttr.hpp:
  removed references to example2 (asynch api)

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_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

@@ -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
@@ -87,14 +87,14 @@ void printTransactionError(NdbConnection *ndbConnection) {
 //
 //  Example insert
 //  @param myNdb         Ndb object representing NDB Cluster
-//  @param myConnection  NdbConnection used for transaction
+//  @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,6 +181,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;
@@ -190,19 +206,11 @@ int main()
   Ndb* myNdb = new Ndb( cluster_connection,
 			"TEST_DB_1" );  // Object representing the database
   
-  /*******************************************
-   * Initialize NDB and wait until its 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);
-  }
-  
   /************************************
    * 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>
@@ -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;

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