updated all examples to use mysql c-api create table (c33a0fc5) · Commits · Software / OSDI20 Artifacts / mariadb

ndb/examples/ndbapi_async_example/Makefile

+12 −23

Original line number	Diff line number	Diff line
		-include .defs.mk
		#NDB_OS = OS_YOU_ARE_RUNNING_ON
		#NDB_OS = LINUX
		#You need to set the NDB_OS variable here (LINUX, SOLARIS, MACOSX)
		TARGET = ndbapi_async
		SRCS = ndbapi_async.cpp
		OBJS = ndbapi_async.o
		CC = g++
		CFLAGS = -c -Wall -fno-rtti -D$(NDB_OS)
		SRCS = $(TARGET).cpp
		OBJS = $(TARGET).o
		CXX = g++
		CFLAGS = -g -c -Wall -fno-rtti -fno-exceptions
		CXXFLAGS = -g
		DEBUG =
		LFLAGS = -Wall
		INCLUDE_DIR = ../../include
		LIB_DIR = ../../lib
		ifeq ($(NDB_OS), SOLARIS)
		# Here is the definition of system libraries necessary for Solaris 7
		SYS_LIB = -lpthread -lsocket -lnsl -lrt
		endif
		ifeq ($(NDB_OS), LINUX)
		# Here is the definition of system libraries necessary for Linux 2.4
		SYS_LIB = -lpthread
		endif
		ifeq ($(NDB_OS), MACOSX)
		# Here is the definition of system libraries necessary for Mac OS X
		TOP_SRCDIR = ../../..
		INCLUDE_DIR = $(TOP_SRCDIR)
		LIB_DIR = -L$(TOP_SRCDIR)/ndb/src/.libs \
		-L$(TOP_SRCDIR)/libmysql_r/.libs \
		-L$(TOP_SRCDIR)/mysys
		SYS_LIB =
		endif

		$(TARGET): $(OBJS)
		$(CC) $(LFLAGS) -L$(LIB_DIR) -lNDB_API $(OBJS) $(SYS_LIB) -o $(TARGET)
		$(CXX) $(CXXFLAGS) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient_r -lmysys -lz $(SYS_LIB) -o $(TARGET)

		$(TARGET).o: $(SRCS)
		$(CC) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)
		$(CXX) $(CFLAGS) -I$(INCLUDE_DIR)/include -I$(INCLUDE_DIR)/extra -I$(INCLUDE_DIR)/ndb/include -I$(INCLUDE_DIR)/ndb/include/ndbapi $(SRCS)

		clean:
		rm -f *.o $(TARGET)

ndb/examples/ndbapi_async_example/ndbapi_async.cpp

+71 −89

Original line number	Diff line number	Diff line
		@@ -24,9 +24,12 @@
		*
		* Classes and methods in NDBAPI used in this example:
		*
		* Ndb_cluster_connection
		* connect()
		* wait_until_ready()
		*
		* Ndb
		* init()
		* waitUntilRead()
		* getDictionary()
		* startTransaction()
		* closeTransaction()
		@@ -38,23 +41,6 @@
		* executeAsynchPrepare()
		* getNdbError()
		*
		* NdbDictionary::Dictionary
		* getTable()
		* dropTable()
		* createTable()
		* getNdbError()
		*
		* NdbDictionary::Column
		* setName()
		* setType()
		* setLength()
		* setPrimaryKey()
		* setNullable()
		*
		* NdbDictionary::Table
		* setName()
		* addColumn()
		*
		* NdbOperation
		* insertTuple()
		* equal()
		@@ -63,10 +49,10 @@
		*/


		#include <ndb_global.h>

		#include <mysql.h>
		#include <mysqld_error.h>
		#include <NdbApi.hpp>
		#include <NdbScanFilter.hpp>

		#include <iostream> // Used for cout

		/**
		@@ -85,11 +71,16 @@ milliSleep(int milliseconds){
		/**
		* error printout macro
		*/
		#define APIERROR(error) \
		{ std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \
		<< error.code << ", msg: " << error.message << "." << std::endl; \
		#define PRINT_ERROR(code,msg) \
		std::cout << "Error in " << __FILE__ << ", line: " << __LINE__ \
		<< ", code: " << code \
		<< ", msg: " << msg << "." << std::endl
		#define MYSQLERROR(mysql) { \
		PRINT_ERROR(mysql_errno(&mysql),mysql_error(&mysql)); \
		exit(-1); }
		#define APIERROR(error) { \
		PRINT_ERROR(error.code,error.message); \
		exit(-1); }


		#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
		/**
		@@ -207,61 +198,26 @@ callback(int result, NdbConnection* trans, void* aObject)
		/**
		* Create table "GARAGE"
		*/
		int create_table(Ndb * myNdb)
		int create_table(MYSQL &mysql)
		{
		NdbDictionary::Table myTable;
		NdbDictionary::Column myColumn;

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

		/*********************************************************
		* Create a table named GARAGE if it does not exist *
		*********************************************************/
		if (myDict->getTable("GARAGE") != NULL)
		while (mysql_query(&mysql,
		"CREATE TABLE"
		" GARAGE"
		" (REG_NO INT UNSIGNED NOT NULL,"
		" BRAND CHAR(20) NOT NULL,"
		" COLOR CHAR(20) NOT NULL,"
		" PRIMARY KEY USING HASH (REG_NO))"
		" ENGINE=NDB"))
		{
		std::cout << "NDB already has example table: GARAGE. "
		if (mysql_errno(&mysql) != ER_TABLE_EXISTS_ERROR)
		MYSQLERROR(mysql);
		std::cout << "MySQL Cluster already has example table: GARAGE. "
		<< "Dropping it..." << std::endl;
		if(myDict->dropTable("GARAGE") == -1)
		{
		std::cout << "Failed to drop: GARAGE." << std::endl;
		exit(1);
		}
		}

		myTable.setName("GARAGE");

		/**
		* Column REG_NO
		*/
		myColumn.setName("REG_NO");
		myColumn.setType(NdbDictionary::Column::Unsigned);
		myColumn.setLength(1);
		myColumn.setPrimaryKey(true);
		myColumn.setNullable(false);
		myTable.addColumn(myColumn);

		/**
		* Column BRAND
		*/
		myColumn.setName("BRAND");
		myColumn.setType(NdbDictionary::Column::Char);
		myColumn.setLength(20);
		myColumn.setPrimaryKey(false);
		myColumn.setNullable(false);
		myTable.addColumn(myColumn);

		/**
		* Column COLOR
		*/
		myColumn.setName("COLOR");
		myColumn.setType(NdbDictionary::Column::Char);
		myColumn.setLength(20);
		myColumn.setPrimaryKey(false);
		myColumn.setNullable(false);
		myTable.addColumn(myColumn);

		if (myDict->createTable(myTable) == -1) {
		APIERROR(myDict->getNdbError());
		/**************
		* Drop table *
		**************/
		if (mysql_query(&mysql, "DROP TABLE GARAGE"))
		MYSQLERROR(mysql);
		}
		return 1;
		}
		@@ -455,21 +411,47 @@ int populate(Ndb * myNdb, int data, async_callback_t * cbData)
		int main()
		{
		ndb_init();
		Ndb* myNdb = new Ndb( "TEST_DB" ); // Object representing the database
		MYSQL mysql;

		/*******************************************
		* Initialize NDB and wait until its ready *
		*******************************************/
		if (myNdb->init(1024) == -1) { // Set max 1024 parallel transactions
		APIERROR(myNdb->getNdbError());
		/**************************************************************
		* Connect to mysql server and create table *
		**************************************************************/
		{
		if ( !mysql_init(&mysql) ) {
		std::cout << "mysql_init failed\n";
		exit(-1);
		}
		if ( !mysql_real_connect(&mysql, "localhost", "root", "", "",
		3306, "/tmp/mysql.sock", 0) )
		MYSQLERROR(mysql);

		mysql_query(&mysql, "CREATE DATABASE TEST_DB");
		if (mysql_query(&mysql, "USE TEST_DB") != 0) MYSQLERROR(mysql);

		if (myNdb->waitUntilReady(30) != 0) {
		std::cout << "NDB was not ready within 30 secs." << std::endl;
		create_table(mysql);
		}

		/**************************************************************
		* Connect to ndb cluster *
		**************************************************************/
		Ndb_cluster_connection cluster_connection;
		if (cluster_connection.connect(4, 5, 1))
		{
		std::cout << "Unable to connect to cluster within 30 secs." << std::endl;
		exit(-1);
		}
		// Optionally connect and wait for the storage nodes (ndbd's)
		if (cluster_connection.wait_until_ready(30,0) < 0)
		{
		std::cout << "Cluster was not ready within 30 secs.\n";
		exit(-1);
		}
		create_table(myNdb);

		Ndb* myNdb = new Ndb( &cluster_connection,
		"TEST_DB" ); // Object representing the database
		if (myNdb->init(1024) == -1) { // Set max 1024 parallel transactions
		APIERROR(myNdb->getNdbError());
		}

		/**
		* Initialise transaction array

ndb/examples/ndbapi_example1/ndbapi_example1.cpp

+3 −3

Original line number	Diff line number	Diff line
		@@ -141,8 +141,8 @@ static void create_table(MYSQL &mysql)
		if (mysql_query(&mysql,
		"CREATE TABLE"
		" MYTABLENAME"
		" (ATTR1 INT UNSIGNED PRIMARY KEY,"
		" ATTR2 INT UNSIGNED)"
		" (ATTR1 INT UNSIGNED NOT NULL PRIMARY KEY,"
		" ATTR2 INT UNSIGNED NOT NULL)"
		" ENGINE=NDB"))
		MYSQLERROR(mysql);
		}
		@@ -234,7 +234,7 @@ static void do_read(Ndb &myNdb)
		NdbOperation *myOperation= myTransaction->getNdbOperation("MYTABLENAME");
		if (myOperation == NULL) APIERROR(myTransaction->getNdbError());

		myOperation->readTuple();
		myOperation->readTuple(NdbOperation::LM_Read);
		myOperation->equal("ATTR1", i);

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

ndb/examples/ndbapi_example4/Makefile

+10 −8

Original line number	Diff line number	Diff line
		TARGET = ndbapi_example4
		SRCS = ndbapi_example4.cpp
		OBJS = ndbapi_example4.o
		SRCS = $(TARGET).cpp
		OBJS = $(TARGET).o
		CXX = g++
		CFLAGS = -c -Wall -fno-rtti -fno-exceptions
		CXXFLAGS =
		DEBUG =
		LFLAGS = -Wall
		INCLUDE_DIR = ../../include
		LIB_DIR = -L../../src/.libs \
		-L../../../libmysql_r/.libs \
		-L../../../mysys
		TOP_SRCDIR = ../../..
		INCLUDE_DIR = $(TOP_SRCDIR)
		LIB_DIR = -L$(TOP_SRCDIR)/ndb/src/.libs \
		-L$(TOP_SRCDIR)/libmysql_r/.libs \
		-L$(TOP_SRCDIR)/mysys
		SYS_LIB =

		$(TARGET): $(OBJS)
		$(CXX) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient_r -lmysys -lz $(SYS_LIB) -o $(TARGET)
		$(CXX) $(CXXFLAGS) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient_r -lmysys -lz $(SYS_LIB) -o $(TARGET)

		$(TARGET).o: $(SRCS)
		$(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)
		$(CXX) $(CFLAGS) -I$(INCLUDE_DIR)/include -I$(INCLUDE_DIR)/ndb/include -I$(INCLUDE_DIR)/ndb/include/ndbapi $(SRCS)

		clean:
		rm -f *.o $(TARGET)

ndb/examples/ndbapi_example4/ndbapi_example4.cpp

+98 −128

Original line number	Diff line number	Diff line
		@@ -31,117 +31,89 @@
		// 8 18
		// 9 9

		#include <mysql.h>
		#include <NdbApi.hpp>

		// Used for cout
		#include <stdio.h>
		#include <iostream>

		#define APIERROR(error) \
		{ std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \
		<< error.code << ", msg: " << error.message << "." << std::endl; \
		#define PRINT_ERROR(code,msg) \
		std::cout << "Error in " << __FILE__ << ", line: " << __LINE__ \
		<< ", code: " << code \
		<< ", msg: " << msg << "." << std::endl
		#define MYSQLERROR(mysql) { \
		PRINT_ERROR(mysql_errno(&mysql),mysql_error(&mysql)); \
		exit(-1); }
		#define APIERROR(error) { \
		PRINT_ERROR(error.code,error.message); \
		exit(-1); }

		int main()
		{
		ndb_init();
		MYSQL mysql;

		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)
		/**************************************************************
		* Connect to mysql server and create table *
		**************************************************************/
		{
		std::cout
		<< "Cluster connect failed, possibly resolved with more retries.\n";
		if ( !mysql_init(&mysql) ) {
		std::cout << "mysql_init failed\n";
		exit(-1);
		}
		else if (r < 0)
		if ( !mysql_real_connect(&mysql, "localhost", "root", "", "",
		3306, "/tmp/mysql.sock", 0) )
		MYSQLERROR(mysql);

		mysql_query(&mysql, "CREATE DATABASE TEST_DB_1");
		if (mysql_query(&mysql, "USE TEST_DB_1") != 0) MYSQLERROR(mysql);

		if (mysql_query(&mysql,
		"CREATE TABLE"
		" MYTABLENAME"
		" (ATTR1 INT UNSIGNED,"
		" ATTR2 INT UNSIGNED NOT NULL,"
		" PRIMARY KEY USING HASH (ATTR1),"
		" UNIQUE MYINDEXNAME USING HASH (ATTR2))"
		" ENGINE=NDB"))
		MYSQLERROR(mysql);
		}

		/**************************************************************
		* Connect to ndb cluster *
		**************************************************************/

		Ndb_cluster_connection *cluster_connection=
		new Ndb_cluster_connection(); // Object representing the cluster

		if (cluster_connection->connect(5,3,1))
		{
		std::cout
		<< "Cluster connect failed.\n";
		std::cout << "Connect to cluster management server failed.\n";
		exit(-1);
		}

		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.\n";
		exit(-1);
		}

		Ndb* myNdb = new Ndb( cluster_connection,
		"TEST_DB_1" ); // Object representing the database
		NdbDictionary::Table myTable;
		NdbDictionary::Column myColumn;
		NdbDictionary::Index myIndex;

		NdbTransaction *myTransaction; // For transactions
		NdbOperation *myOperation; // For primary key operations
		NdbIndexOperation *myIndexOperation; // For index operations
		NdbRecAttr *myRecAttr; // Result of reading attribute value

		if (myNdb->init() == -1) {
		APIERROR(myNdb->getNdbError());
		exit(-1);
		}

		/*********************************************************
		* Create a table named MYTABLENAME if it does not exist *
		*********************************************************/
		NdbDictionary::Dictionary* myDict = myNdb->getDictionary();
		if (myDict->getTable("MYTABLENAME") != NULL) {
		std::cout << "NDB already has example table: MYTABLENAME." << std::endl;
		exit(-1);
		}

		myTable.setName("MYTABLENAME");

		myColumn.setName("ATTR1");
		myColumn.setType(NdbDictionary::Column::Unsigned);
		myColumn.setLength(1);
		myColumn.setPrimaryKey(true);
		myColumn.setNullable(false);
		myTable.addColumn(myColumn);

		myColumn.setName("ATTR2");
		myColumn.setType(NdbDictionary::Column::Unsigned);
		myColumn.setLength(1);
		myColumn.setPrimaryKey(false);
		myColumn.setNullable(false);
		myTable.addColumn(myColumn);

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


		/**********************************************************
		* Create an index named MYINDEXNAME if it does not exist *
		**********************************************************/
		if (myDict->getIndex("MYINDEXNAME", "MYTABLENAME") != NULL) {
		std::cout << "NDB already has example index: MYINDEXNAME." << std::endl;
		exit(-1);
		}

		myIndex.setName("MYINDEXNAME");
		myIndex.setTable("MYTABLENAME");
		myIndex.setType(NdbDictionary::Index::UniqueHashIndex);
		const char* attr_arr[] = {"ATTR2"};
		myIndex.addIndexColumns(1, attr_arr);

		if (myDict->createIndex(myIndex) == -1)
		APIERROR(myDict->getNdbError());


		/**************************************************************************
		* Using 5 transactions, insert 10 tuples in table: (0,0),(1,1),...,(9,9) *
		**************************************************************************/
		for (int i = 0; i < 5; i++) {
		myTransaction = myNdb->startTransaction();
		NdbTransaction *myTransaction= myNdb->startTransaction();
		if (myTransaction == NULL) APIERROR(myNdb->getNdbError());

		myOperation = myTransaction->getNdbOperation("MYTABLENAME");
		NdbOperation *myOperation= myTransaction->getNdbOperation("MYTABLENAME");
		if (myOperation == NULL) APIERROR(myTransaction->getNdbError());

		myOperation->insertTuple();
		@@ -167,33 +139,34 @@ int main()
		std::cout << "ATTR1 ATTR2" << std::endl;

		for (int i = 0; i < 10; i++) {
		myTransaction = myNdb->startTransaction();
		NdbTransaction *myTransaction= myNdb->startTransaction();
		if (myTransaction == NULL) APIERROR(myNdb->getNdbError());

		myIndexOperation = myTransaction->getNdbIndexOperation("MYINDEXNAME",
		"MYTABLENAME");
		NdbIndexOperation *myIndexOperation=
		myTransaction->getNdbIndexOperation("MYINDEXNAME$unique","MYTABLENAME");
		if (myIndexOperation == NULL) APIERROR(myTransaction->getNdbError());

		myIndexOperation->readTuple();
		myIndexOperation->readTuple(NdbOperation::LM_Read);
		myIndexOperation->equal("ATTR2", i);

		myRecAttr = myIndexOperation->getValue("ATTR1", NULL);
		NdbRecAttr *myRecAttr= myIndexOperation->getValue("ATTR1", NULL);
		if (myRecAttr == NULL) APIERROR(myTransaction->getNdbError());

		if(myTransaction->execute( Commit ) != -1)
		printf(" %2d %2d\n", myRecAttr->u_32_value(), i);
		}

		myNdb->closeTransaction(myTransaction);
		}

		/*****************************************************************
		* Update the second attribute in half of the tuples (adding 10) *
		*****************************************************************/
		for (int i = 0; i < 10; i+=2) {
		myTransaction = myNdb->startTransaction();
		NdbTransaction *myTransaction= myNdb->startTransaction();
		if (myTransaction == NULL) APIERROR(myNdb->getNdbError());

		myIndexOperation = myTransaction->getNdbIndexOperation("MYINDEXNAME",
		"MYTABLENAME");
		NdbIndexOperation *myIndexOperation=
		myTransaction->getNdbIndexOperation("MYINDEXNAME$unique", "MYTABLENAME");
		if (myIndexOperation == NULL) APIERROR(myTransaction->getNdbError());

		myIndexOperation->updateTuple();
		@@ -209,13 +182,13 @@ int main()
		/*************************************************
		* Delete one tuple (the one with primary key 3) *
		*************************************************/
		myTransaction = myNdb->startTransaction();
		{
		NdbTransaction *myTransaction= myNdb->startTransaction();
		if (myTransaction == NULL) APIERROR(myNdb->getNdbError());

		myIndexOperation = myTransaction->getNdbIndexOperation("MYINDEXNAME",
		"MYTABLENAME");
		if (myIndexOperation == NULL)
		APIERROR(myTransaction->getNdbError());
		NdbIndexOperation *myIndexOperation=
		myTransaction->getNdbIndexOperation("MYINDEXNAME$unique", "MYTABLENAME");
		if (myIndexOperation == NULL) APIERROR(myTransaction->getNdbError());

		myIndexOperation->deleteTuple();
		myIndexOperation->equal( "ATTR2", 3 );
		@@ -224,28 +197,30 @@ int main()
		APIERROR(myTransaction->getNdbError());

		myNdb->closeTransaction(myTransaction);
		}

		/*****************************
		* Read and print all tuples *
		*****************************/
		{
		std::cout << "ATTR1 ATTR2" << std::endl;

		for (int i = 0; i < 10; i++) {
		myTransaction = myNdb->startTransaction();
		NdbTransaction *myTransaction= myNdb->startTransaction();
		if (myTransaction == NULL) APIERROR(myNdb->getNdbError());

		myOperation = myTransaction->getNdbOperation("MYTABLENAME");
		NdbOperation *myOperation= myTransaction->getNdbOperation("MYTABLENAME");
		if (myOperation == NULL) APIERROR(myTransaction->getNdbError());

		myOperation->readTuple();
		myOperation->readTuple(NdbOperation::LM_Read);
		myOperation->equal("ATTR1", i);

		myRecAttr = myOperation->getValue("ATTR2", NULL);
		NdbRecAttr *myRecAttr= myOperation->getValue("ATTR2", NULL);
		if (myRecAttr == NULL) APIERROR(myTransaction->getNdbError());

		if(myTransaction->execute( Commit ) == -1)
		if (i == 3) {
		std::cout << "Detected that deleted tuple doesn't exist!" << std::endl;
		std::cout << "Detected that deleted tuple doesn't exist!\n";
		} else {
		APIERROR(myTransaction->getNdbError());
		}
		@@ -255,18 +230,13 @@ int main()
		}
		myNdb->closeTransaction(myTransaction);
		}

		/**************
		* Drop index *
		**************/
		if (myDict->dropIndex("MYINDEXNAME", "MYTABLENAME") == -1)
		APIERROR(myDict->getNdbError());
		}

		/**************
		* Drop table *
		**************/
		if (myDict->dropTable("MYTABLENAME") == -1)
		APIERROR(myDict->getNdbError());
		if (mysql_query(&mysql, "DROP TABLE MYTABLENAME"))
		MYSQLERROR(mysql);

		delete myNdb;
		delete cluster_connection;