Skip to content

M
mariadb
Commit 51863a7f authored by tomas@poseidon.ndb.mysql.com's avatar tomas@poseidon.ndb.mysql.com
Browse files
Options

updated ndbapi examples 

    removed references to example2 (asynch api)
parent e57c0909
Hide whitespace changes
Inline Side-by-side
Showing with 286 additions and 216 deletions
ndb/examples/Makefile
View file @ 51863a7f
# XXX ndbapi_example4, select_all commented out until fixed BIN_DIRS := ndbapi_example1 ndbapi_example3 ndbapi_example4 \
BIN_DIRS := ndbapi_example1 ndbapi_example2 ndbapi_example3 $(ndbapi_example4) \ ndbapi_example5 ndbapi_scan_example
ndbapi_example5 $(select_all) ndbapi_scan_example
bins: $(patsubst %, _bins_%, $(BIN_DIRS)) bins: $(patsubst %, _bins_%, $(BIN_DIRS))
......
ndb/examples/ndbapi_example1/ndbapi_example1.cpp
View file @ 51863a7f
...@@ -32,73 +32,95 @@ ...@@ -32,73 +32,95 @@
// 9 9 // 9 9
#include <NdbApi.hpp> #include <NdbApi.hpp>
// Used for cout // Used for cout
#include <stdio.h> #include <stdio.h>
#include <iostream> #include <iostream>
#define APIERROR(error) \ static void run_application(Ndb_cluster_connection &);
{ std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \
<< error.code << ", msg: " << error.message << "." << std::endl; \
exit(-1); }
int main() int main()
{ {
// ndb_init must be called first
ndb_init(); ndb_init();
Ndb_cluster_connection *cluster_connection= // connect to cluster and run application
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 // Object representing the cluster
<< "Cluster connect failed, possibly resolved with more retries.\n"; Ndb_cluster_connection cluster_connection;
exit(-1);
} // Connect to cluster management server (ndb_mgmd)
else if (r < 0) if (cluster_connection.connect(4 /* retries */,
{ 5 /* delay between retries */,
std::cout 1 /* verbose */))
<< "Cluster connect failed.\n"; {
exit(-1); std::cout << "Cluster management server was not ready within 30 secs.\n";
} exit(-1);
}
if (cluster_connection->wait_until_ready(30,30)) // 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." << std::endl; {
exit(-1); std::cout << "Cluster was not ready within 30 secs.\n";
exit(-1);
}
// run the application code
run_application(cluster_connection);
} }
Ndb* myNdb = new Ndb( cluster_connection, // ndb_end should not be called until all "Ndb" objects are deleted
"TEST_DB_1" ); // Object representing the database ndb_end(0);
NdbDictionary::Table myTable;
NdbDictionary::Column myColumn;
NdbConnection *myConnection; // For other transactions return 0;
NdbOperation *myOperation; // For other operations }
NdbRecAttr *myRecAttr; // Result of reading attribute value
#define APIERROR(error) \
{ std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \
<< error.code << ", msg: " << error.message << "." << std::endl; \
exit(-1); }
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()) { // Object representing the database
APIERROR(myNdb->getNdbError()); Ndb myNdb( &cluster_connection, "TEST_DB_1" );
exit(-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);
}
/*********************************************************
* Create a table named MYTABLENAME if it does not exist *
*********************************************************/
static void create_table(Ndb &myNdb)
{
NdbDictionary::Dictionary* myDict = myNdb.getDictionary();
NdbDictionary::Dictionary* myDict = myNdb->getDictionary();
/*********************************************************
* Create a table named MYTABLENAME if it does not exist *
*********************************************************/
if (myDict->getTable("MYTABLENAME") != NULL) { 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); exit(-1);
} }
NdbDictionary::Table myTable;
NdbDictionary::Column myColumn;
myTable.setName("MYTABLENAME"); myTable.setName("MYTABLENAME");
myColumn.setName("ATTR1"); myColumn.setName("ATTR1");
...@@ -115,108 +137,112 @@ int main() ...@@ -115,108 +137,112 @@ int main()
myColumn.setNullable(false); myColumn.setNullable(false);
myTable.addColumn(myColumn); myTable.addColumn(myColumn);
if (myDict->createTable(myTable) == -1) if (myDict->createTable(myTable) == -1) APIERROR(myDict->getNdbError());
APIERROR(myDict->getNdbError()); }
/************************************************************************** /**************************************************************************
* Using 5 transactions, insert 10 tuples in table: (0,0),(1,1),...,(9,9) * * 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++) { for (int i = 0; i < 5; i++) {
myConnection = myNdb->startTransaction(); NdbTransaction *myTransaction= myNdb.startTransaction();
if (myConnection == NULL) APIERROR(myNdb->getNdbError()); if (myTransaction == NULL) APIERROR(myNdb.getNdbError());
myOperation = myConnection->getNdbOperation("MYTABLENAME"); NdbOperation *myOperation= myTransaction->getNdbOperation("MYTABLENAME");
if (myOperation == NULL) APIERROR(myConnection->getNdbError()); if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
myOperation->insertTuple(); myOperation->insertTuple();
myOperation->equal("ATTR1", i); myOperation->equal("ATTR1", i);
myOperation->setValue("ATTR2", i); myOperation->setValue("ATTR2", i);
myOperation = myConnection->getNdbOperation("MYTABLENAME"); myOperation= myTransaction->getNdbOperation("MYTABLENAME");
if (myOperation == NULL) APIERROR(myConnection->getNdbError()); if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
myOperation->insertTuple(); myOperation->insertTuple();
myOperation->equal("ATTR1", i+5); myOperation->equal("ATTR1", i+5);
myOperation->setValue("ATTR2", i+5); myOperation->setValue("ATTR2", i+5);
if (myConnection->execute( Commit ) == -1) if (myTransaction->execute( Commit ) == -1)
APIERROR(myConnection->getNdbError()); 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) { for (int i = 0; i < 10; i+=2) {
myConnection = myNdb->startTransaction(); NdbTransaction *myTransaction= myNdb.startTransaction();
if (myConnection == NULL) APIERROR(myNdb->getNdbError()); if (myTransaction == NULL) APIERROR(myNdb.getNdbError());
myOperation = myConnection->getNdbOperation("MYTABLENAME"); NdbOperation *myOperation= myTransaction->getNdbOperation("MYTABLENAME");
if (myOperation == NULL) APIERROR(myConnection->getNdbError()); if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
myOperation->updateTuple(); myOperation->updateTuple();
myOperation->equal( "ATTR1", i ); myOperation->equal( "ATTR1", i );
myOperation->setValue( "ATTR2", i+10); myOperation->setValue( "ATTR2", i+10);
if( myConnection->execute( Commit ) == -1 ) if( myTransaction->execute( Commit ) == -1 )
APIERROR(myConnection->getNdbError()); APIERROR(myTransaction->getNdbError());
myNdb->closeTransaction(myConnection); myNdb.closeTransaction(myTransaction);
} }
}
/************************************************* /*************************************************
* Delete one tuple (the one with primary key 3) * * Delete one tuple (the one with primary key 3) *
*************************************************/ *************************************************/
myConnection = myNdb->startTransaction(); static void do_delete(Ndb &myNdb)
if (myConnection == NULL) APIERROR(myNdb->getNdbError()); {
NdbTransaction *myTransaction= myNdb.startTransaction();
if (myTransaction == NULL) APIERROR(myNdb.getNdbError());
myOperation = myConnection->getNdbOperation("MYTABLENAME"); NdbOperation *myOperation= myTransaction->getNdbOperation("MYTABLENAME");
if (myOperation == NULL) if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
APIERROR(myConnection->getNdbError());
myOperation->deleteTuple(); myOperation->deleteTuple();
myOperation->equal( "ATTR1", 3 ); myOperation->equal( "ATTR1", 3 );
if (myConnection->execute(Commit) == -1) if (myTransaction->execute(Commit) == -1)
APIERROR(myConnection->getNdbError()); APIERROR(myTransaction->getNdbError());
myNdb->closeTransaction(myConnection); myNdb.closeTransaction(myTransaction);
}
/*****************************
* Read and print all tuples * /*****************************
*****************************/ * Read and print all tuples *
*****************************/
static void do_read(Ndb &myNdb)
{
std::cout << "ATTR1 ATTR2" << std::endl; std::cout << "ATTR1 ATTR2" << std::endl;
for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
myConnection = myNdb->startTransaction(); NdbTransaction *myTransaction= myNdb.startTransaction();
if (myConnection == NULL) APIERROR(myNdb->getNdbError()); if (myTransaction == NULL) APIERROR(myNdb.getNdbError());
myOperation = myConnection->getNdbOperation("MYTABLENAME"); NdbOperation *myOperation= myTransaction->getNdbOperation("MYTABLENAME");
if (myOperation == NULL) APIERROR(myConnection->getNdbError()); if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
myOperation->readTuple(); myOperation->readTuple();
myOperation->equal("ATTR1", i); myOperation->equal("ATTR1", i);
NdbRecAttr *myRecAttr= myOperation->getValue("ATTR2", NULL);
if (myRecAttr == NULL) APIERROR(myTransaction->getNdbError());
myRecAttr = myOperation->getValue("ATTR2", NULL); if(myTransaction->execute( Commit ) == -1)
if (myRecAttr == NULL) APIERROR(myConnection->getNdbError());
if(myConnection->execute( Commit ) == -1)
if (i == 3) { if (i == 3) {
std::cout << "Detected that deleted tuple doesn't exist!" << std::endl; std::cout << "Detected that deleted tuple doesn't exist!" << std::endl;
} else { } else {
APIERROR(myConnection->getNdbError()); APIERROR(myTransaction->getNdbError());
} }
if (i != 3) { if (i != 3) {
printf(" %2d %2d\n", i, myRecAttr->u_32_value()); 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
View file @ 51863a7f
...@@ -7,12 +7,12 @@ DEBUG = ...@@ -7,12 +7,12 @@ DEBUG =
LFLAGS = -Wall LFLAGS = -Wall
INCLUDE_DIR = ../../include INCLUDE_DIR = ../../include
LIB_DIR = -L../../src/.libs \ LIB_DIR = -L../../src/.libs \
-L../../../libmysql/.libs \ -L../../../libmysql_r/.libs \
-L../../../mysys -L../../../mysys
SYS_LIB = SYS_LIB =
$(TARGET): $(OBJS) $(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) $(TARGET).o: $(SRCS)
$(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS) $(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)
......
ndb/examples/ndbapi_example2/ndbapi_example2.cpp
View file @ 51863a7f
...@@ -35,7 +35,7 @@ ...@@ -35,7 +35,7 @@
<< error.code << ", msg: " << error.message << "." << std::endl; \ << error.code << ", msg: " << error.message << "." << std::endl; \
exit(-1); } exit(-1); }
static void callback(int result, NdbConnection* NdbObject, void* aObject); static void callback(int result, NdbTransaction* NdbObject, void* aObject);
int main() int main()
{ {
...@@ -50,42 +50,56 @@ int main() ...@@ -50,42 +50,56 @@ int main()
exit(-1); 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, Ndb* myNdb = new Ndb( cluster_connection,
"TEST_DB_2" ); // Object representing the database "TEST_DB_2" ); // Object representing the database
NdbConnection* myNdbConnection[2]; // For transactions NdbTransaction* myNdbTransaction[2]; // For transactions
NdbOperation* myNdbOperation; // For operations NdbOperation* myNdbOperation; // For operations
/*******************************************
* Initialize NDB and wait until its ready *
*******************************************/
if (myNdb->init(2) == -1) { // Want two parallel insert transactions if (myNdb->init(2) == -1) { // Want two parallel insert transactions
APIERROR(myNdb->getNdbError()); APIERROR(myNdb->getNdbError());
exit(-1); 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) * * Insert (we do two insert transactions in parallel) *
******************************************************/ ******************************************************/
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
myNdbConnection[i] = myNdb->startTransaction(); myNdbTransaction[i] = myNdb->startTransaction();
if (myNdbConnection[i] == NULL) APIERROR(myNdb->getNdbError()); 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 // 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->insertTuple();
myNdbOperation->equal("ATTR1", 20 + i); myNdbOperation->equal("ATTR1", 20 + i);
myNdbOperation->setValue("ATTR2", 20 + i); myNdbOperation->setValue("ATTR2", 20 + i);
// Prepare transaction (the transaction is NOT yet sent to NDB) // 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 // Send all transactions to NDB
...@@ -96,7 +110,7 @@ int main() ...@@ -96,7 +110,7 @@ int main()
// Close all transactions // Close all transactions
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; i++)
myNdb->closeTransaction(myNdbConnection[i]); myNdb->closeTransaction(myNdbTransaction[i]);
delete myNdb; delete myNdb;
delete cluster_connection; delete cluster_connection;
...@@ -110,12 +124,12 @@ int main() ...@@ -110,12 +124,12 @@ int main()
* *
* (This function must have three arguments: * (This function must have three arguments:
* - The result of the transaction, * - The result of the transaction,
* - The NdbConnection object, and * - The NdbTransaction object, and
* - A pointer to an arbitrary object.) * - A pointer to an arbitrary object.)
*/ */
static void static void
callback(int result, NdbConnection* myTrans, void* aObject) callback(int result, NdbTransaction* myTrans, void* aObject)
{ {
if (result == -1) { if (result == -1) {
std::cout << "Poll error: " << std::endl; std::cout << "Poll error: " << std::endl;
......
ndb/examples/ndbapi_example3/Makefile
View file @ 51863a7f
...@@ -7,12 +7,12 @@ DEBUG = ...@@ -7,12 +7,12 @@ DEBUG =
LFLAGS = -Wall LFLAGS = -Wall
INCLUDE_DIR = ../../include INCLUDE_DIR = ../../include
LIB_DIR = -L../../src/.libs \ LIB_DIR = -L../../src/.libs \
-L../../../libmysql/.libs \ -L../../../libmysql_r/.libs \
-L../../../mysys -L../../../mysys
SYS_LIB = SYS_LIB =
$(TARGET): $(OBJS) $(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) $(TARGET).o: $(SRCS)
$(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS) $(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)
......
ndb/examples/ndbapi_example3/ndbapi_example3.cpp
View file @ 51863a7f
...@@ -52,28 +52,28 @@ ...@@ -52,28 +52,28 @@
} }
// //
// CONERROR prints all error info regarding an NdbConnection // TRANSERROR prints all error info regarding an NdbTransaction
// //
#define CONERROR(ndbConnection) \ #define TRANSERROR(ndbTransaction) \
{ NdbError error = ndbConnection->getNdbError(); \ { NdbError error = ndbTransaction->getNdbError(); \
std::cout << "CON ERROR: " << error.code << " " << error.message \ std::cout << "TRANS ERROR: " << error.code << " " << error.message \
<< std::endl \ << std::endl \
<< " " << "Status: " << error.status \ << " " << "Status: " << error.status \
<< ", Classification: " << error.classification << std::endl \ << ", Classification: " << error.classification << std::endl \
<< " " << "File: " << __FILE__ \ << " " << "File: " << __FILE__ \
<< " (Line: " << __LINE__ << ")" << std::endl \ << " (Line: " << __LINE__ << ")" << std::endl \
; \ ; \
printTransactionError(ndbConnection); \ printTransactionError(ndbTransaction); \
} }
void printTransactionError(NdbConnection *ndbConnection) { void printTransactionError(NdbTransaction *ndbTransaction) {
const NdbOperation *ndbOp = NULL; const NdbOperation *ndbOp = NULL;
int i=0; int i=0;
/**************************************************************** /****************************************************************
* Print NdbError object of every operations in the transaction * * 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(); NdbError error = ndbOp->getNdbError();
std::cout << " OPERATION " << i+1 << ": " std::cout << " OPERATION " << i+1 << ": "
<< error.code << " " << error.message << std::endl << error.code << " " << error.message << std::endl
...@@ -87,14 +87,14 @@ void printTransactionError(NdbConnection *ndbConnection) { ...@@ -87,14 +87,14 @@ void printTransactionError(NdbConnection *ndbConnection) {
// //
// Example insert // Example insert
// @param myNdb Ndb object representing NDB Cluster // @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 // @param error NdbError object returned in case of errors
// @return -1 in case of failures, 0 otherwise // @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 NdbOperation *myOperation; // For other operations
myOperation = myConnection->getNdbOperation("MYTABLENAME"); myOperation = myTransaction->getNdbOperation("MYTABLENAME");
if (myOperation == NULL) return -1; if (myOperation == NULL) return -1;
if (myOperation->insertTuple() || if (myOperation->insertTuple() ||
...@@ -104,7 +104,7 @@ int insert(int transactionId, NdbConnection* myConnection) { ...@@ -104,7 +104,7 @@ int insert(int transactionId, NdbConnection* myConnection) {
exit(-1); exit(-1);
} }
return myConnection->execute(NoCommit); return myTransaction->execute(NoCommit);
} }
...@@ -116,7 +116,7 @@ int insert(int transactionId, NdbConnection* myConnection) { ...@@ -116,7 +116,7 @@ int insert(int transactionId, NdbConnection* myConnection) {
int executeInsertTransaction(int transactionId, Ndb* myNdb) { int executeInsertTransaction(int transactionId, Ndb* myNdb) {
int result = 0; // No result yet int result = 0; // No result yet
int noOfRetriesLeft = 10; int noOfRetriesLeft = 10;
NdbConnection *myConnection; // For other transactions NdbTransaction *myTransaction; // For other transactions
NdbError ndberror; NdbError ndberror;
while (noOfRetriesLeft > 0 && !result) { while (noOfRetriesLeft > 0 && !result) {
...@@ -124,16 +124,16 @@ int executeInsertTransaction(int transactionId, Ndb* myNdb) { ...@@ -124,16 +124,16 @@ int executeInsertTransaction(int transactionId, Ndb* myNdb) {
/********************************* /*********************************
* Start and execute transaction * * Start and execute transaction *
*********************************/ *********************************/
myConnection = myNdb->startTransaction(); myTransaction = myNdb->startTransaction();
if (myConnection == NULL) { if (myTransaction == NULL) {
APIERROR(myNdb->getNdbError()); APIERROR(myNdb->getNdbError());
ndberror = myNdb->getNdbError(); ndberror = myNdb->getNdbError();
result = -1; // Failure result = -1; // Failure
} else if (insert(transactionId, myConnection) || } else if (insert(transactionId, myTransaction) ||
insert(10000+transactionId, myConnection) || insert(10000+transactionId, myTransaction) ||
myConnection->execute(Commit)) { myTransaction->execute(Commit)) {
CONERROR(myConnection); TRANSERROR(myTransaction);
ndberror = myConnection->getNdbError(); ndberror = myTransaction->getNdbError();
result = -1; // Failure result = -1; // Failure
} else { } else {
result = 1; // Success result = 1; // Success
...@@ -164,8 +164,8 @@ int executeInsertTransaction(int transactionId, Ndb* myNdb) { ...@@ -164,8 +164,8 @@ int executeInsertTransaction(int transactionId, Ndb* myNdb) {
/********************* /*********************
* Close transaction * * Close transaction *
*********************/ *********************/
if (myConnection != NULL) { if (myTransaction != NULL) {
myNdb->closeTransaction(myConnection); myNdb->closeTransaction(myTransaction);
} }
} }
...@@ -181,6 +181,22 @@ int main() ...@@ -181,6 +181,22 @@ int main()
Ndb_cluster_connection *cluster_connection= Ndb_cluster_connection *cluster_connection=
new Ndb_cluster_connection(); // Object representing the cluster 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)) if (cluster_connection->wait_until_ready(30,30))
{ {
std::cout << "Cluster was not ready within 30 secs." << std::endl; std::cout << "Cluster was not ready within 30 secs." << std::endl;
...@@ -190,19 +206,11 @@ int main() ...@@ -190,19 +206,11 @@ int main()
Ndb* myNdb = new Ndb( cluster_connection, Ndb* myNdb = new Ndb( cluster_connection,
"TEST_DB_1" ); // Object representing the database "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()); APIERROR(myNdb->getNdbError());
exit(-1); exit(-1);
} }
if (myNdb->waitUntilReady(30) != 0) {
std::cout << "NDB was not ready within 30 secs." << std::endl;
exit(-1);
}
/************************************ /************************************
* Execute some insert transactions * * Execute some insert transactions *
************************************/ ************************************/
......
ndb/examples/ndbapi_example4/Makefile
View file @ 51863a7f
...@@ -7,12 +7,12 @@ DEBUG = ...@@ -7,12 +7,12 @@ DEBUG =
LFLAGS = -Wall LFLAGS = -Wall
INCLUDE_DIR = ../../include INCLUDE_DIR = ../../include
LIB_DIR = -L../../src/.libs \ LIB_DIR = -L../../src/.libs \
-L../../../libmysql/.libs \ -L../../../libmysql_r/.libs \
-L../../../mysys -L../../../mysys
SYS_LIB = SYS_LIB =
$(TARGET): $(OBJS) $(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) $(TARGET).o: $(SRCS)
$(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS) $(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)
......
ndb/examples/ndbapi_example4/ndbapi_example4.cpp
View file @ 51863a7f
...@@ -49,6 +49,22 @@ int main() ...@@ -49,6 +49,22 @@ int main()
Ndb_cluster_connection *cluster_connection= Ndb_cluster_connection *cluster_connection=
new Ndb_cluster_connection(); // Object representing the cluster 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)) if (cluster_connection->wait_until_ready(30,30))
{ {
std::cout << "Cluster was not ready within 30 secs." << std::endl; std::cout << "Cluster was not ready within 30 secs." << std::endl;
...@@ -61,24 +77,16 @@ int main() ...@@ -61,24 +77,16 @@ int main()
NdbDictionary::Column myColumn; NdbDictionary::Column myColumn;
NdbDictionary::Index myIndex; NdbDictionary::Index myIndex;
NdbConnection *myConnection; // For transactions NdbTransaction *myTransaction; // For transactions
NdbOperation *myOperation; // For primary key operations NdbOperation *myOperation; // For primary key operations
NdbIndexOperation *myIndexOperation; // For index operations NdbIndexOperation *myIndexOperation; // For index operations
NdbRecAttr *myRecAttr; // Result of reading attribute value NdbRecAttr *myRecAttr; // Result of reading attribute value
/********************************************
* Initialize NDB and wait until it's ready *
********************************************/
if (myNdb->init() == -1) { if (myNdb->init() == -1) {
APIERROR(myNdb->getNdbError()); APIERROR(myNdb->getNdbError());
exit(-1); 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 * * Create a table named MYTABLENAME if it does not exist *
*********************************************************/ *********************************************************/
...@@ -130,27 +138,27 @@ int main() ...@@ -130,27 +138,27 @@ int main()
* Using 5 transactions, insert 10 tuples in table: (0,0),(1,1),...,(9,9) * * Using 5 transactions, insert 10 tuples in table: (0,0),(1,1),...,(9,9) *
**************************************************************************/ **************************************************************************/
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
myConnection = myNdb->startTransaction(); myTransaction = myNdb->startTransaction();
if (myConnection == NULL) APIERROR(myNdb->getNdbError()); if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
myOperation = myConnection->getNdbOperation("MYTABLENAME"); myOperation = myTransaction->getNdbOperation("MYTABLENAME");
if (myOperation == NULL) APIERROR(myConnection->getNdbError()); if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
myOperation->insertTuple(); myOperation->insertTuple();
myOperation->equal("ATTR1", i); myOperation->equal("ATTR1", i);
myOperation->setValue("ATTR2", i); myOperation->setValue("ATTR2", i);
myOperation = myConnection->getNdbOperation("MYTABLENAME"); myOperation = myTransaction->getNdbOperation("MYTABLENAME");
if (myOperation == NULL) APIERROR(myConnection->getNdbError()); if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
myOperation->insertTuple(); myOperation->insertTuple();
myOperation->equal("ATTR1", i+5); myOperation->equal("ATTR1", i+5);
myOperation->setValue("ATTR2", i+5); myOperation->setValue("ATTR2", i+5);
if (myConnection->execute( Commit ) == -1) if (myTransaction->execute( Commit ) == -1)
APIERROR(myConnection->getNdbError()); APIERROR(myTransaction->getNdbError());
myNdb->closeTransaction(myConnection); myNdb->closeTransaction(myTransaction);
} }
/***************************************** /*****************************************
...@@ -159,63 +167,63 @@ int main() ...@@ -159,63 +167,63 @@ int main()
std::cout << "ATTR1 ATTR2" << std::endl; std::cout << "ATTR1 ATTR2" << std::endl;
for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
myConnection = myNdb->startTransaction(); myTransaction = myNdb->startTransaction();
if (myConnection == NULL) APIERROR(myNdb->getNdbError()); if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
myIndexOperation = myConnection->getNdbIndexOperation("MYINDEXNAME", myIndexOperation = myTransaction->getNdbIndexOperation("MYINDEXNAME",
"MYTABLENAME"); "MYTABLENAME");
if (myIndexOperation == NULL) APIERROR(myConnection->getNdbError()); if (myIndexOperation == NULL) APIERROR(myTransaction->getNdbError());
myIndexOperation->readTuple(); myIndexOperation->readTuple();
myIndexOperation->equal("ATTR2", i); myIndexOperation->equal("ATTR2", i);
myRecAttr = myIndexOperation->getValue("ATTR1", NULL); 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); 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) * * Update the second attribute in half of the tuples (adding 10) *
*****************************************************************/ *****************************************************************/
for (int i = 0; i < 10; i+=2) { for (int i = 0; i < 10; i+=2) {
myConnection = myNdb->startTransaction(); myTransaction = myNdb->startTransaction();
if (myConnection == NULL) APIERROR(myNdb->getNdbError()); if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
myIndexOperation = myConnection->getNdbIndexOperation("MYINDEXNAME", myIndexOperation = myTransaction->getNdbIndexOperation("MYINDEXNAME",
"MYTABLENAME"); "MYTABLENAME");
if (myIndexOperation == NULL) APIERROR(myConnection->getNdbError()); if (myIndexOperation == NULL) APIERROR(myTransaction->getNdbError());
myIndexOperation->updateTuple(); myIndexOperation->updateTuple();
myIndexOperation->equal( "ATTR2", i ); myIndexOperation->equal( "ATTR2", i );
myIndexOperation->setValue( "ATTR2", i+10); myIndexOperation->setValue( "ATTR2", i+10);
if( myConnection->execute( Commit ) == -1 ) if( myTransaction->execute( Commit ) == -1 )
APIERROR(myConnection->getNdbError()); APIERROR(myTransaction->getNdbError());
myNdb->closeTransaction(myConnection); myNdb->closeTransaction(myTransaction);
} }
/************************************************* /*************************************************
* Delete one tuple (the one with primary key 3) * * Delete one tuple (the one with primary key 3) *
*************************************************/ *************************************************/
myConnection = myNdb->startTransaction(); myTransaction = myNdb->startTransaction();
if (myConnection == NULL) APIERROR(myNdb->getNdbError()); if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
myIndexOperation = myConnection->getNdbIndexOperation("MYINDEXNAME", myIndexOperation = myTransaction->getNdbIndexOperation("MYINDEXNAME",
"MYTABLENAME"); "MYTABLENAME");
if (myIndexOperation == NULL) if (myIndexOperation == NULL)
APIERROR(myConnection->getNdbError()); APIERROR(myTransaction->getNdbError());
myIndexOperation->deleteTuple(); myIndexOperation->deleteTuple();
myIndexOperation->equal( "ATTR2", 3 ); myIndexOperation->equal( "ATTR2", 3 );
if (myConnection->execute(Commit) == -1) if (myTransaction->execute(Commit) == -1)
APIERROR(myConnection->getNdbError()); APIERROR(myTransaction->getNdbError());
myNdb->closeTransaction(myConnection); myNdb->closeTransaction(myTransaction);
/***************************** /*****************************
* Read and print all tuples * * Read and print all tuples *
...@@ -223,29 +231,29 @@ int main() ...@@ -223,29 +231,29 @@ int main()
std::cout << "ATTR1 ATTR2" << std::endl; std::cout << "ATTR1 ATTR2" << std::endl;
for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
myConnection = myNdb->startTransaction(); myTransaction = myNdb->startTransaction();
if (myConnection == NULL) APIERROR(myNdb->getNdbError()); if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
myOperation = myConnection->getNdbOperation("MYTABLENAME"); myOperation = myTransaction->getNdbOperation("MYTABLENAME");
if (myOperation == NULL) APIERROR(myConnection->getNdbError()); if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
myOperation->readTuple(); myOperation->readTuple();
myOperation->equal("ATTR1", i); myOperation->equal("ATTR1", i);
myRecAttr = myOperation->getValue("ATTR2", NULL); 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) { if (i == 3) {
std::cout << "Detected that deleted tuple doesn't exist!" << std::endl; std::cout << "Detected that deleted tuple doesn't exist!" << std::endl;
} else { } else {
APIERROR(myConnection->getNdbError()); APIERROR(myTransaction->getNdbError());
} }
if (i != 3) { if (i != 3) {
printf(" %2d %2d\n", i, myRecAttr->u_32_value()); printf(" %2d %2d\n", i, myRecAttr->u_32_value());
} }
myNdb->closeTransaction(myConnection); myNdb->closeTransaction(myTransaction);
} }
/************** /**************
......
ndb/examples/ndbapi_example5/Makefile
View file @ 51863a7f
...@@ -9,12 +9,12 @@ LFLAGS = -Wall ...@@ -9,12 +9,12 @@ LFLAGS = -Wall
TOP_SRCDIR = ../../.. TOP_SRCDIR = ../../..
INCLUDE_DIR = $(TOP_SRCDIR)/ndb/include INCLUDE_DIR = $(TOP_SRCDIR)/ndb/include
LIB_DIR = -L$(TOP_SRCDIR)/ndb/src/.libs \ LIB_DIR = -L$(TOP_SRCDIR)/ndb/src/.libs \
-L$(TOP_SRCDIR)/libmysql/.libs \ -L$(TOP_SRCDIR)/libmysql_r/.libs \
-L$(TOP_SRCDIR)/mysys -L$(TOP_SRCDIR)/mysys
SYS_LIB = SYS_LIB =
$(TARGET): $(OBJS) $(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) $(TARGET).o: $(SRCS)
$(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS) $(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)
......
ndb/examples/ndbapi_example5/ndbapi_example5.cpp
View file @ 51863a7f
...@@ -19,7 +19,6 @@ ...@@ -19,7 +19,6 @@
*/ */
#include <NdbApi.hpp> #include <NdbApi.hpp>
#include <NdbEventOperation.hpp>
// Used for cout // Used for cout
#include <stdio.h> #include <stdio.h>
...@@ -69,6 +68,22 @@ int main() ...@@ -69,6 +68,22 @@ int main()
Ndb_cluster_connection *cluster_connection= Ndb_cluster_connection *cluster_connection=
new Ndb_cluster_connection(); // Object representing the cluster 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)) if (cluster_connection->wait_until_ready(30,30))
{ {
std::cout << "Cluster was not ready within 30 secs." << std::endl; std::cout << "Cluster was not ready within 30 secs." << std::endl;
......
ndb/include/ndbapi/Ndb.hpp
View file @ 51863a7f
...@@ -122,8 +122,7 @@ ...@@ -122,8 +122,7 @@
// 4. Attribute Actions // 4. Attribute Actions
MyRecAttr= MyOperation->getValue("ATTR2", NULL); MyRecAttr= MyOperation->getValue("ATTR2", NULL);
@endcode @endcode
For additional examples of this sort, see @ref ndbapi_example1.cpp and For additional examples of this sort, see @ref ndbapi_example1.cpp.
@ref ndbapi_example2.cpp.
The second example uses an NdbIndexOperation: The second example uses an NdbIndexOperation:
@code @code
...@@ -428,10 +427,12 @@ ...@@ -428,10 +427,12 @@
* @include ndbapi_example1.cpp * @include ndbapi_example1.cpp
*/ */
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
/** /**
* @page ndbapi_example2.cpp ndbapi_example2.cpp * @page ndbapi_example2.cpp ndbapi_example2.cpp
* @include ndbapi_example2.cpp * @include ndbapi_example2.cpp
*/ */
#endif
/** /**
* @page ndbapi_example3.cpp ndbapi_example3.cpp * @page ndbapi_example3.cpp ndbapi_example3.cpp
......
ndb/include/ndbapi/NdbRecAttr.hpp
View file @ 51863a7f
...@@ -39,8 +39,7 @@ class NdbOperation; ...@@ -39,8 +39,7 @@ class NdbOperation;
* ndbout << MyRecAttr->u_32_value(); * ndbout << MyRecAttr->u_32_value();
* @endcode * @endcode
* For more examples, see * For more examples, see
* @ref ndbapi_example1.cpp and * @ref ndbapi_example1.cpp.
* @ref ndbapi_example2.cpp.
* *
* @note The NdbRecAttr object is instantiated with its value when * @note The NdbRecAttr object is instantiated with its value when
* NdbTransaction::execute is called. Before this, the value is * NdbTransaction::execute is called. Before this, the value is
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7