Commit f3c62560 authored by unknown's avatar unknown
Browse files

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)
parent cf3e08c5

ndb/examples/Makefile

+2 −3
Original line number Diff line number Diff line 
# 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/ndbapi_example1.cpp

+129 −103
Original line number Diff line number Diff line
@@ -32,73 +32,95 @@ 
//    9     9



#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(Ndb_cluster_connection &);



int main()

{

  // ndb_init must be called first

  ndb_init();



  Ndb_cluster_connection *cluster_connection=

    new Ndb_cluster_connection(); // Object representing the cluster

  // connect to cluster and run application

  {

    // Object representing the cluster

    Ndb_cluster_connection cluster_connection;



  int r= cluster_connection->connect(5 /* retries               */,

				     3 /* delay between retries */,

				     1 /* verbose               */);

  if (r > 0)

    // Connect to cluster management server (ndb_mgmd)

    if (cluster_connection.connect(4 /* retries               */,

				   5 /* delay between retries */,

				   1 /* verbose               */))

    {

    std::cout

      << "Cluster connect failed, possibly resolved with more retries.\n";

      std::cout << "Cluster management server was not ready within 30 secs.\n";

      exit(-1);

    }

  else if (r < 0)



    // Optionally connect and wait for the storage nodes (ndbd's)

    if (cluster_connection.wait_until_ready(30,30))

    {

    std::cout

      << "Cluster connect failed.\n";

      std::cout << "Cluster was not ready within 30 secs.\n";

      exit(-1);

    }



    // run the application code

    run_application(cluster_connection);

  }



  if (cluster_connection->wait_until_ready(30,30))

  {

    std::cout << "Cluster was not ready within 30 secs." << std::endl;

    exit(-1);

  // ndb_end should not be called until all "Ndb" objects are deleted

  ndb_end(0);



  return 0;

}



  Ndb* myNdb = new Ndb( cluster_connection,

			"TEST_DB_1" );  // Object representing the database

  NdbDictionary::Table myTable;

  NdbDictionary::Column myColumn;

#define APIERROR(error) \

  { std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \

              << error.code << ", msg: " << error.message << "." << std::endl; \

    exit(-1); }



  NdbConnection	 *myConnection;         // For other transactions

  NdbOperation	 *myOperation;          // For other operations

  NdbRecAttr     *myRecAttr;            // Result of reading attribute value

static void create_table(Ndb &myNdb);

static void do_insert(Ndb &myNdb);

static void do_update(Ndb &myNdb);

static void do_delete(Ndb &myNdb);

static void do_read(Ndb &myNdb);



static void run_application(Ndb_cluster_connection &cluster_connection)

{

  /********************************************

   * Initialize NDB and wait until it's ready *

   * Connect to database                      *

   ********************************************/

  if (myNdb->init()) { 

    APIERROR(myNdb->getNdbError());

    exit(-1);

  // Object representing the database

  Ndb myNdb( &cluster_connection, "TEST_DB_1" );

  if (myNdb.init()) APIERROR(myNdb.getNdbError());



  /*

   * Do different operations on database

   */

  create_table(myNdb);

  do_insert(myNdb);

  do_update(myNdb);

  do_delete(myNdb);

  do_read(myNdb);

}



  NdbDictionary::Dictionary* myDict = myNdb->getDictionary();

  

/*********************************************************

 * Create a table named MYTABLENAME if it does not exist *

 *********************************************************/

static void create_table(Ndb &myNdb)

{

  NdbDictionary::Dictionary* myDict = myNdb.getDictionary();



  if (myDict->getTable("MYTABLENAME") != NULL) {

    std::cout << "NDB already has example table: MYTABLENAME." << std::endl; 

    std::cout 

      << "NDB already has example table: MYTABLENAME.\n"

      << "Use ndb_drop_table -d TEST_DB_1 MYTABLENAME\n";

    exit(-1);

  }



  NdbDictionary::Table myTable;

  NdbDictionary::Column myColumn;

  

  myTable.setName("MYTABLENAME");

  

  myColumn.setName("ATTR1");
@@ -115,108 +137,112 @@ int main() 
  myColumn.setNullable(false);

  myTable.addColumn(myColumn);



  if (myDict->createTable(myTable) == -1) 

      APIERROR(myDict->getNdbError());

  if (myDict->createTable(myTable) == -1) APIERROR(myDict->getNdbError());

}



/**************************************************************************

 * 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) *

 *****************************************************************/

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());

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());

  if (myTransaction->execute(Commit) == -1) 

    APIERROR(myTransaction->getNdbError());

  

  myNdb->closeTransaction(myConnection);

  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);



    myRecAttr = myOperation->getValue("ATTR2", NULL);

    if (myRecAttr == NULL) APIERROR(myConnection->getNdbError());

    NdbRecAttr *myRecAttr= myOperation->getValue("ATTR2", NULL);

    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);

  }



  delete myNdb;

  delete cluster_connection;



  ndb_end(0);

  return 0;

}

ndb/examples/ndbapi_example2/Makefile

+2 −2
Original line number Diff line number Diff line
@@ -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

+32 −18
Original line number Diff line number Diff line
@@ -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

+2 −2
Original line number Diff line number Diff line
@@ -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)