Merge tulin@bk-internal.mysql.com:/home/bk/mysql-5.0-ndb (5f0f39d0) · Commits · Software / OSDI20 Artifacts / mariadb

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)