Skip to content

M
MariaDB
Commit ccbadbc9 authored by unknown's avatar unknown
Browse files
Options

Merge mysql.com:/home/stewart/Documents/MySQL/5.0/ndb 

into mysql.com:/home/stewart/Documents/MySQL/5.0/ndb-dynamic-ports-impl3
parents 5de74593 d42ff5df
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1268 additions and 977 deletions
BitKeeper/etc/logging_ok
View file @ ccbadbc9
......@@ -96,6 +96,7 @@ jcole@tetra.spaceapes.com
jimw@mysql.com
joerg@mysql.com
jon@gigan.
jonas@mysql.com
joreland@bk-internal.mysql.com
joreland@mysql.com
jorge@linux.jorge.mysql.com
......
configure.in
View file @ ccbadbc9
......@@ -1770,6 +1770,7 @@ examine config.log for possible errors. If you want to report this, use
'scripts/mysqlbug' and include at least the last 20 rows from config.log!])
fi
AC_CHECK_SIZEOF(char*, 4)
AC_CHECK_SIZEOF(short, 2)
AC_CHECK_SIZEOF(int, 4)
if test "$ac_cv_sizeof_int" -eq 0
then
......@@ -2723,11 +2724,26 @@ then
fi
AC_SUBST([ndb_bin_am_ldflags])
AC_SUBST([ndb_opt_subdirs])
NDB_SIZEOF_CHARP="$ac_cv_sizeof_charp"
NDB_SIZEOF_CHAR="$ac_cv_sizeof_char"
NDB_SIZEOF_SHORT="$ac_cv_sizeof_short"
NDB_SIZEOF_INT="$ac_cv_sizeof_int"
NDB_SIZEOF_LONG="$ac_cv_sizeof_long"
NDB_SIZEOF_LONG_LONG="$ac_cv_sizeof_long_long"
AC_SUBST([NDB_SIZEOF_CHARP])
AC_SUBST([NDB_SIZEOF_CHAR])
AC_SUBST([NDB_SIZEOF_SHORT])
AC_SUBST([NDB_SIZEOF_INT])
AC_SUBST([NDB_SIZEOF_LONG])
AC_SUBST([NDB_SIZEOF_LONG_LONG])
AC_CONFIG_FILES(ndb/Makefile ndb/include/Makefile dnl
ndb/src/Makefile ndb/src/common/Makefile dnl
ndb/docs/Makefile dnl
ndb/tools/Makefile dnl
ndb/src/common/debugger/Makefile ndb/src/common/debugger/signaldata/Makefile dnl
ndb/src/common/debugger/Makefile dnl
ndb/src/common/debugger/signaldata/Makefile dnl
ndb/src/common/portlib/Makefile dnl
ndb/src/common/util/Makefile dnl
ndb/src/common/logger/Makefile dnl
......@@ -2766,6 +2782,7 @@ AC_CONFIG_FILES(ndb/Makefile ndb/include/Makefile dnl
ndb/test/tools/Makefile dnl
ndb/test/run-test/Makefile mysql-test/ndb/Makefile dnl
ndb/include/ndb_version.h ndb/include/ndb_global.h dnl
ndb/include/ndb_types.h dnl
)
fi
......
ndb/examples/Makefile
View file @ ccbadbc9
BIN_DIRS := ndbapi_example1 ndbapi_example3 ndbapi_example4 \
ndbapi_example5 ndbapi_scan_example
BIN_DIRS := ndbapi_simple_example \
ndbapi_async_example \
ndbapi_async_example1 \
ndbapi_retries_example \
ndbapi_simple_index_example \
ndbapi_event_example \
ndbapi_scan_example
bins: $(patsubst %, _bins_%, $(BIN_DIRS))
......
ndb/examples/ndbapi_async_example/Makefile
View file @ ccbadbc9
-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
View file @ ccbadbc9
......@@ -24,10 +24,12 @@
*
* Classes and methods in NDBAPI used in this example:
*
* Ndb_cluster_connection
* connect()
* wait_until_ready()
*
* Ndb
* init()
* waitUntilRead()
* getDictionary()
* startTransaction()
* closeTransaction()
* sendPollNdb()
......@@ -38,23 +40,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 +48,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 +70,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; \
exit(-1); }
#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
/**
......@@ -106,10 +96,10 @@ typedef struct {
} async_callback_t;
/**
* Structure used in "free list" to a NdbConnection
* Structure used in "free list" to a NdbTransaction
*/
typedef struct {
NdbConnection* conn;
NdbTransaction* conn;
int used;
} transaction_t;
......@@ -132,7 +122,7 @@ int populate(Ndb * myNdb, int data, async_callback_t * cbData);
/**
* Error handler.
*/
bool asynchErrorHandler(NdbConnection * trans, Ndb* ndb);
bool asynchErrorHandler(NdbTransaction * trans, Ndb* ndb);
/**
* Exit function
......@@ -171,7 +161,7 @@ closeTransaction(Ndb * ndb , async_callback_t * cb)
* Callback executed when transaction has return from NDB
*/
static void
callback(int result, NdbConnection* trans, void* aObject)
callback(int result, NdbTransaction* trans, void* aObject)
{
async_callback_t * cbData = (async_callback_t *)aObject;
if (result<0)
......@@ -207,61 +197,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;
}
......@@ -276,7 +231,7 @@ void asynchExitHandler(Ndb * m_ndb)
/* returns true if is recoverable (temporary),
* false if it is an error that is permanent.
*/
bool asynchErrorHandler(NdbConnection * trans, Ndb* ndb)
bool asynchErrorHandler(NdbTransaction * trans, Ndb* ndb)
{
NdbError error = trans->getNdbError();
switch(error.status)
......@@ -426,7 +381,7 @@ int populate(Ndb * myNdb, int data, async_callback_t * cbData)
}
/*Prepare transaction (the transaction is NOT yet sent to NDB)*/
transaction[current].conn->executeAsynchPrepare(Commit,
transaction[current].conn->executeAsynchPrepare(NdbTransaction::Commit,
&callback,
cb);
/**
......@@ -455,22 +410,48 @@ int populate(Ndb * myNdb, int data, async_callback_t * cbData)
int main()
{
ndb_init();
Ndb* myNdb = new Ndb( "TEST_DB" ); // Object representing the database
/*******************************************
* Initialize NDB and wait until its ready *
*******************************************/
if (myNdb->init(1024) == -1) { // Set max 1024 parallel transactions
APIERROR(myNdb->getNdbError());
MYSQL mysql;
/**************************************************************
* 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);
create_table(mysql);
}
if (myNdb->waitUntilReady(30) != 0) {
std::cout << "NDB was not ready within 30 secs." << std::endl;
/**************************************************************
* 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_example3/Makefile → ndb/examples/ndbapi_async_example1/Makefile
View file @ ccbadbc9
TARGET = ndbapi_example3
SRCS = ndbapi_example3.cpp
OBJS = ndbapi_example3.o
TARGET = ndbapi_async1
SRCS = ndbapi_async1.cpp
OBJS = ndbapi_async1.o
CXX = g++
CFLAGS = -c -Wall -fno-rtti -fno-exceptions
DEBUG =
......
ndb/examples/ndbapi_example2/ndbapi_example2.cpp → ndb/examples/ndbapi_async_example1/ndbapi_async1.cpp
View file @ ccbadbc9
......@@ -15,7 +15,7 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
//
// ndbapi_example2.cpp: Using asynchronous transactions in NDB API
// ndbapi_async1.cpp: Using asynchronous transactions in NDB API
//
// Execute ndbapi_example1 to create the table "MYTABLENAME"
// before executing this program.
......@@ -99,7 +99,8 @@ int main()
myNdbOperation->setValue("ATTR2", 20 + i);
// Prepare transaction (the transaction is NOT yet sent to NDB)
myNdbTransaction[i]->executeAsynchPrepare(Commit, &callback, NULL);
myNdbTransaction[i]->executeAsynchPrepare(NdbTransaction::Commit,
&callback, NULL);
}
// Send all transactions to NDB
......
ndb/examples/ndbapi_example5/Makefile → ndb/examples/ndbapi_event_example/Makefile
View file @ ccbadbc9
TARGET = ndbapi_example5
SRCS = ndbapi_example5.cpp
OBJS = ndbapi_example5.o
TARGET = ndbapi_event
SRCS = ndbapi_event.cpp
OBJS = ndbapi_event.o
CXX = g++
CFLAGS = -c -Wall -fno-rtti -fno-exceptions
CXXFLAGS =
......
ndb/examples/ndbapi_example5/ndbapi_example5.cpp → ndb/examples/ndbapi_event_example/ndbapi_event.cpp
View file @ ccbadbc9
......@@ -15,7 +15,38 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/**
* ndbapi_example5.cpp: Using API level events in NDB API
* ndbapi_event.cpp: Using API level events in NDB API
*
* Classes and methods used in this example:
*
* Ndb_cluster_connection
* connect()
* wait_until_ready()
*
* Ndb
* init()
* getDictionary()
* createEventOperation()
* dropEventOperation()
* pollEvents()
*
* NdbDictionary
* createEvent()
* dropEvent()
*
* NdbDictionary::Event
* setTable()
* addTableEvent()
* addEventColumn()
*
* NdbEventOperation
* getValue()
* getPreValue()
* execute()
* next()
* isConsistent()
* getEventType()
*
*/
#include <NdbApi.hpp>
......@@ -32,12 +63,12 @@
* another process (e.g. flexBench -l 0 -stdtables).
* We want to monitor what happens with columns COL0, COL2, COL11
*
* or together with the mysqlcluster client;
* or together with the mysql client;
*
* shell> mysqlcluster -u root
* shell> mysql -u root
* mysql> create database TEST_DB;
* mysql> use TEST_DB;
* mysql> create table TAB0 (COL0 int primary key, COL1 int, COL11 int);
* mysql> create table TAB0 (COL0 int primary key, COL1 int, COL11 int) engine=ndb;
*
* In another window start ndbapi_example5, wait until properly started
*
......@@ -168,7 +199,7 @@ int main()
printf("NULL");
}
if (recAttrPre[i]->isNULL() >= 0) { // we have a value
printf(" post[%u]=", i);
printf(" pre[%u]=", i);
if (recAttrPre[i]->isNULL() == 0) // we have a non-null value
printf("%u", recAttrPre[i]->u_32_value());
else // we have a null value
......@@ -181,7 +212,7 @@ int main()
;//printf("timed out\n");
}
// don't want to listen to events anymore
myNdb->dropEventOperation(op);
if (myNdb->dropEventOperation(op)) APIERROR(myNdb->getNdbError());
j++;
}
......@@ -189,7 +220,8 @@ int main()
{
NdbDictionary::Dictionary *myDict = myNdb->getDictionary();
if (!myDict) APIERROR(myNdb->getNdbError());
myDict->dropEvent(eventName); // remove event from database
// remove event from database
if (myDict->dropEvent(eventName)) APIERROR(myDict->getNdbError());
}
delete myNdb;
......@@ -201,8 +233,8 @@ int main()
int myCreateEvent(Ndb* myNdb,
const char *eventName,
const char *eventTableName,
const char **eventColumnName,
const int noEventColumnName)
const char **eventColumnNames,
const int noEventColumnNames)
{
NdbDictionary::Dictionary *myDict= myNdb->getDictionary();
if (!myDict) APIERROR(myNdb->getNdbError());
......@@ -214,24 +246,20 @@ int myCreateEvent(Ndb* myNdb,
// myEvent.addTableEvent(NdbDictionary::Event::TE_UPDATE);
// myEvent.addTableEvent(NdbDictionary::Event::TE_DELETE);
for (int i = 0; i < noEventColumnName; i++)
myEvent.addEventColumn(eventColumnName[i]);
myEvent.addEventColumns(noEventColumnNames, eventColumnNames);
int res = myDict->createEvent(myEvent); // Add event to database
if (res == 0)
// Add event to database
if (myDict->createEvent(myEvent) == 0)
myEvent.print();
else {
printf("Event creation failed\n");
printf("trying drop Event, maybe event exists\n");
res = myDict->dropEvent(eventName);
if (res)
exit(-1);
else if (myDict->getNdbError().code == 4709) {
printf("Event creation failed, event exists\n");
printf("dropping Event...\n");
if (myDict->dropEvent(eventName)) APIERROR(myDict->getNdbError());
// try again
res = myDict->createEvent(myEvent); // Add event to database
if (res)
exit(-1);
}
// Add event to database
if ( myDict->createEvent(myEvent)) APIERROR(myDict->getNdbError());
} else
APIERROR(myDict->getNdbError());
return res;
return 0;
}
ndb/examples/ndbapi_example4/Makefile deleted 100644 → 0
View file @ 5de74593
TARGET = ndbapi_example4
SRCS = ndbapi_example4.cpp
OBJS = ndbapi_example4.o
CXX = g++
CFLAGS = -c -Wall -fno-rtti -fno-exceptions
DEBUG =
LFLAGS = -Wall
INCLUDE_DIR = ../../include
LIB_DIR = -L../../src/.libs \
-L../../../libmysql_r/.libs \
-L../../../mysys
SYS_LIB =
$(TARGET): $(OBJS)
$(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)
clean:
rm -f *.o $(TARGET)
ndb/examples/ndbapi_example2/Makefile → ndb/examples/ndbapi_retries_example/Makefile
View file @ ccbadbc9
TARGET = ndbapi_example2
SRCS = ndbapi_example2.cpp
OBJS = ndbapi_example2.o
TARGET = ndbapi_retries
SRCS = ndbapi_retries.cpp
OBJS = ndbapi_retries.o
CXX = g++
CFLAGS = -c -Wall -fno-rtti -fno-exceptions
DEBUG =
......
ndb/examples/ndbapi_example3/ndbapi_example3.cpp → ndb/examples/ndbapi_retries_example/ndbapi_retries.cpp
View file @ ccbadbc9
......@@ -15,9 +15,9 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
//
// ndbapi_example3.cpp: Error handling and transaction retries
// ndbapi_retries.cpp: Error handling and transaction retries
//
// Execute ndbapi_example1 to create the table "MYTABLENAME"
// Execute ndbapi_simple to create the table "MYTABLENAME"
// before executing this program.
//
// There are many ways to program using the NDB API. In this example
......@@ -104,7 +104,7 @@ int insert(int transactionId, NdbTransaction* myTransaction) {
exit(-1);
}
return myTransaction->execute(NoCommit);
return myTransaction->execute(NdbTransaction::NoCommit);
}
......@@ -131,7 +131,7 @@ int executeInsertTransaction(int transactionId, Ndb* myNdb) {
result = -1; // Failure
} else if (insert(transactionId, myTransaction) ||
insert(10000+transactionId, myTransaction) ||
myTransaction->execute(Commit)) {
myTransaction->execute(NdbTransaction::Commit)) {
TRANSERROR(myTransaction);
ndberror = myTransaction->getNdbError();
result = -1; // Failure
......
ndb/examples/ndbapi_scan_example/Makefile
View file @ ccbadbc9
TARGET = ndbapi_scan
SRCS = ndbapi_scan.cpp
OBJS = ndbapi_scan.o
SRCS = $(TARGET).cpp
OBJS = $(TARGET).o
CXX = g++
CFLAGS = -c -Wall -fno-rtti -fno-exceptions
CXXFLAGS =
CFLAGS = -g -c -Wall -fno-rtti -fno-exceptions
CXXFLAGS = -g
DEBUG =
LFLAGS = -Wall
TOP_SRCDIR = ../../..
INCLUDE_DIR = $(TOP_SRCDIR)/ndb/include
INCLUDE_DIR = $(TOP_SRCDIR)
LIB_DIR = -L$(TOP_SRCDIR)/ndb/src/.libs \
-L$(TOP_SRCDIR)/libmysql_r/.libs \
-L$(TOP_SRCDIR)/mysys
......@@ -17,7 +17,7 @@ $(TARGET): $(OBJS)
$(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)/extra -I$(INCLUDE_DIR)/ndb/include -I$(INCLUDE_DIR)/ndb/include/ndbapi $(SRCS)
clean:
rm -f *.o $(TARGET)
ndb/examples/ndbapi_scan_example/ndbapi_scan.cpp
View file @ ccbadbc9
......@@ -38,8 +38,6 @@
* getNdbScanOperation()
* execute()
*
* NdbResultSet
*
* NdbScanOperation
* getValue()
* readTuples()
......@@ -47,21 +45,14 @@
* deleteCurrentTuple()
* updateCurrentTuple()
*
* NdbDictionary::Dictionary
* const NdbDictionary::Dictionary
* getTable()
* dropTable()
* createTable()
*
* NdbDictionary::Column
* setName()
* setType()
* setLength()
* setPrimaryKey()
* setNullable()
* const NdbDictionary::Table
* getColumn()
*
* NdbDictionary::Table
* setName()
* addColumn()
* const NdbDictionary::Column
* getLength()
*
* NdbOperation
* insertTuple()
......@@ -76,6 +67,8 @@
*/
#include <mysql.h>
#include <mysqld_error.h>
#include <NdbApi.hpp>
// Used for cout
#include <iostream>
......@@ -97,10 +90,16 @@ milliSleep(int milliseconds){
/**
* Helper sleep function
*/
#define APIERROR(error) \
{ std::cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \
<< error.code << ", msg: " << error.message << "." << std::endl; \
exit(-1); }
#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); }
struct Car
{
......@@ -112,55 +111,26 @@ struct Car
/**
* Function to create table
*/
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) {
std::cout << "NDB already has example table: GARAGE. "
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"))
{
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);
}
}
Car car;
myTable.setName("GARAGE");
myColumn.setName("REG_NO");
myColumn.setType(NdbDictionary::Column::Unsigned);
myColumn.setLength(1);
myColumn.setPrimaryKey(true);
myColumn.setNullable(false);
myTable.addColumn(myColumn);
myColumn.setName("BRAND");
myColumn.setType(NdbDictionary::Column::Char);
myColumn.setLength(sizeof(car.brand));
myColumn.setPrimaryKey(false);
myColumn.setNullable(false);
myTable.addColumn(myColumn);
myColumn.setName("COLOR");
myColumn.setType(NdbDictionary::Column::Char);
myColumn.setLength(sizeof(car.color));
myColumn.setPrimaryKey(false);
myColumn.setNullable(false);
myTable.addColumn(myColumn);
if (myDict->createTable(myTable) == -1) {
APIERROR(myDict->getNdbError());
return -1;
/**************
* Drop table *
**************/
if (mysql_query(&mysql, "DROP TABLE GARAGE"))
MYSQLERROR(mysql);
}
return 1;
}
......@@ -217,7 +187,7 @@ int populate(Ndb * myNdb)
myNdbOperation->setValue("COLOR", cars[i].color);
}
int check = myTrans->execute(Commit);
int check = myTrans->execute(NdbTransaction::Commit);
myTrans->close();
......@@ -310,7 +280,7 @@ int scan_delete(Ndb* myNdb,
/**
* Start scan (NoCommit since we are only reading at this stage);
*/
if(myTrans->execute(NoCommit) != 0){
if(myTrans->execute(NdbTransaction::NoCommit) != 0){
err = myTrans->getNdbError();
if(err.status == NdbError::TemporaryError){
std::cout << myTrans->getNdbError().message << std::endl;
......@@ -352,7 +322,7 @@ int scan_delete(Ndb* myNdb,
*/
if(check != -1)
{
check = myTrans->execute(Commit);
check = myTrans->execute(NdbTransaction::Commit);
}
if(check == -1)
......@@ -460,7 +430,7 @@ int scan_update(Ndb* myNdb,
/**
* Define a result set for the scan.
*/
if( myScanOp->readTuplesExclusive(NdbOperation::LM_Exclusive) )
if( myScanOp->readTuples(NdbOperation::LM_Exclusive) )
{
std::cout << myTrans->getNdbError().message << std::endl;
myNdb->closeTransaction(myTrans);
......@@ -483,7 +453,7 @@ int scan_update(Ndb* myNdb,
/**
* Start scan (NoCommit since we are only reading at this stage);
*/
if(myTrans->execute(NoCommit) != 0)
if(myTrans->execute(NdbTransaction::NoCommit) != 0)
{
err = myTrans->getNdbError();
if(err.status == NdbError::TemporaryError){
......@@ -531,7 +501,7 @@ int scan_update(Ndb* myNdb,
*/
if(check != -1)
{
check = myTrans->execute(NoCommit);
check = myTrans->execute(NdbTransaction::NoCommit);
}
/**
......@@ -555,7 +525,7 @@ int scan_update(Ndb* myNdb,
/**
* Commit all prepared operations
*/
if(myTrans->execute(Commit) == -1)
if(myTrans->execute(NdbTransaction::Commit) == -1)
{
if(err.status == NdbError::TemporaryError){
std::cout << myTrans->getNdbError().message << std::endl;
......@@ -670,7 +640,7 @@ int scan_print(Ndb * myNdb)
/**
* Start scan (NoCommit since we are only reading at this stage);
*/
if(myTrans->execute(NoCommit) != 0){
if(myTrans->execute(NdbTransaction::NoCommit) != 0){
err = myTrans->getNdbError();
if(err.status == NdbError::TemporaryError){
std::cout << myTrans->getNdbError().message << std::endl;
......@@ -726,36 +696,67 @@ int scan_print(Ndb * myNdb)
int main()
{
ndb_init();
MYSQL mysql;
Ndb_cluster_connection cluster_connection;
/**************************************************************
* 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 (cluster_connection.connect(12, 5, 1))
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);
}
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,0) < 0)
{
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(&cluster_connection,"TEST_DB" );
/*******************************************
* Initialize NDB and wait until its ready *
*******************************************/
if (myNdb.init(1024) == -1) { // Set max 1024 parallel transactions
Ndb myNdb(&cluster_connection,"TEST_DB");
if (myNdb.init(1024) == -1) { // Set max 1024 parallel transactions
APIERROR(myNdb.getNdbError());
exit(-1);
}
create_table(&myNdb);
NdbDictionary::Dictionary* myDict = myNdb.getDictionary();
int column_color = myDict->getTable("GARAGE")->getColumn("COLOR")->getColumnNo();
/*******************************************
* Check table definition *
*******************************************/
int column_color;
{
const NdbDictionary::Dictionary* myDict= myNdb.getDictionary();
const NdbDictionary::Table *t= myDict->getTable("GARAGE");
Car car;
if (t->getColumn("COLOR")->getLength() != sizeof(car.color) ||
t->getColumn("BRAND")->getLength() != sizeof(car.brand))
{
std::cout << "Wrong table definition" << std::endl;
exit(-1);
}
column_color= t->getColumn("COLOR")->getColumnNo();
}
if(populate(&myNdb) > 0)
std::cout << "populate: Success!" << std::endl;
......@@ -789,4 +790,6 @@ int main()
}
if(scan_print(&myNdb) > 0)
std::cout << "scan_print: Success!" << std::endl << std::endl;
return 0;
}
ndb/examples/ndbapi_example1/Makefile → ndb/examples/ndbapi_simple_example/Makefile
View file @ ccbadbc9
TARGET = ndbapi_example1
TARGET = ndbapi_simple
SRCS = $(TARGET).cpp
OBJS = $(TARGET).o
CXX = g++
......
ndb/examples/ndbapi_example1/ndbapi_example1.cpp → ndb/examples/ndbapi_simple_example/ndbapi_simple.cpp
View file @ ccbadbc9
......@@ -15,7 +15,7 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/*
* ndbapi_example1.cpp: Using synchronous transactions in NDB API
* ndbapi_simple.cpp: Using synchronous transactions in NDB API
*
* Correct output from this program is:
*
......@@ -72,7 +72,7 @@ int main()
}
// Optionally connect and wait for the storage nodes (ndbd's)
if (cluster_connection.wait_until_ready(30,30))
if (cluster_connection.wait_until_ready(30,0) < 0)
{
std::cout << "Cluster was not ready within 30 secs.\n";
exit(-1);
......@@ -92,7 +92,6 @@ int main()
run_application(mysql, cluster_connection);
}
// ndb_end should not be called until all "Ndb" objects are deleted
ndb_end(0);
std::cout << "\nTo drop created table use:\n"
......@@ -141,8 +140,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);
}
......@@ -170,7 +169,7 @@ static void do_insert(Ndb &myNdb)
myOperation->equal("ATTR1", i+5);
myOperation->setValue("ATTR2", i+5);
if (myTransaction->execute( Commit ) == -1)
if (myTransaction->execute( NdbTransaction::Commit ) == -1)
APIERROR(myTransaction->getNdbError());
myNdb.closeTransaction(myTransaction);
......@@ -193,7 +192,7 @@ static void do_update(Ndb &myNdb)
myOperation->equal( "ATTR1", i );
myOperation->setValue( "ATTR2", i+10);
if( myTransaction->execute( Commit ) == -1 )
if( myTransaction->execute( NdbTransaction::Commit ) == -1 )
APIERROR(myTransaction->getNdbError());
myNdb.closeTransaction(myTransaction);
......@@ -214,7 +213,7 @@ static void do_delete(Ndb &myNdb)
myOperation->deleteTuple();
myOperation->equal( "ATTR1", 3 );
if (myTransaction->execute(Commit) == -1)
if (myTransaction->execute(NdbTransaction::Commit) == -1)
APIERROR(myTransaction->getNdbError());
myNdb.closeTransaction(myTransaction);
......@@ -234,13 +233,13 @@ 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);
if (myRecAttr == NULL) APIERROR(myTransaction->getNdbError());
if(myTransaction->execute( Commit ) == -1)
if(myTransaction->execute( NdbTransaction::Commit ) == -1)
if (i == 3) {
std::cout << "Detected that deleted tuple doesn't exist!" << std::endl;
} else {
......
ndb/examples/ndbapi_simple_index_example/Makefile 0 → 100644
View file @ ccbadbc9
TARGET = ndbapi_simple_index
SRCS = $(TARGET).cpp
OBJS = $(TARGET).o
CXX = g++
CFLAGS = -c -Wall -fno-rtti -fno-exceptions
CXXFLAGS =
DEBUG =
LFLAGS = -Wall
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) $(CXXFLAGS) $(LFLAGS) $(LIB_DIR) $(OBJS) -lndbclient -lmysqlclient_r -lmysys -lz $(SYS_LIB) -o $(TARGET)
$(TARGET).o: $(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/select_all/Makefile deleted 100644 → 0
View file @ 5de74593
-include .defs.mk
#NDB_OS = OS_YOU_ARE_RUNNING_ON
#You need to set the NDB_OS variable here
TARGET = select_all
SRCS = select_all.cpp
OBJS = select_all.o
CXX = g++
CFLAGS = -c -Wall -fno-rtti -fno-exceptions
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 =
endif
ifeq ($(NDB_OS), LINUX)
# Here is the definition of system libraries necessary for Linux 2.4
SYS_LIB =
endif
ifeq ($(NDB_OS), MACOSX)
# Here is the definition of system libraries necessary for Mac OS X
SYS_LIB =
endif
$(TARGET): $(OBJS)
$(CXX) $(LFLAGS) -L$(LIB_DIR) $(OBJS) -lNDB_API $(SYS_LIB) -o $(TARGET)
$(TARGET).o: $(SRCS)
$(CXX) $(CFLAGS) -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/ndbapi $(SRCS)
clean:
rm -f *.o $(TARGET)
ndb/examples/select_all/select_all.cpp deleted 100644 → 0
View file @ 5de74593
/* Copyright (C) 2003 MySQL AB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
//
// select_all.cpp: Prints all rows of a table
//
// Usage: select_all <table_name>+
#include <NdbApi.hpp>
// Used for cout
#include <iostream>
using namespace std;
#include <stdio.h>
#include <string.h>
#define APIERROR(error) \
{ cout << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" \
<< error.code << ", msg: " << error.message << "." << endl; \
exit(-1); }
void usage(const char* prg) {
cout << "Usage: " << prg << " <table name>" << endl;
cout << "Prints all rows of table named <table name>" << endl;
exit(0);
}
/*****************************************************************************
*************************** Result Set Container ****************************
*****************************************************************************/
/*
* Container of NdbRecAttr objects.
* (NdbRecAttr objects are database rows read by a scan operation.)
*/
class ResultSetContainer {
public:
/**
* Initialize ResultSetContainer object for table named <tableName>
* - Allocates memory
* - Fetches attribute names from NDB Cluster
*/
void init(NdbDictionary::Dictionary* dict, const char* tableName);
/**
* Get no of attributes for stored NdbRecAttr objects
*/
int getNoOfAttributes() const;
/**
* Get NdbRecAttr object no i
*/
NdbRecAttr* & getAttrStore(int i);
/**
* Get attribute name of attribute no i
*/
const char* getAttrName(int i) const;
/**
* Print header of rows
*/
void header() const;
private:
int m_cols; // No of attributes for stored NdbRecAttr objects
char **m_names; // Names of attributes
NdbRecAttr **m_data; // The actual stored NdbRecAttr objects
};
void ResultSetContainer::init(NdbDictionary::Dictionary * dict,
const char* tableName)
{
// Get Table object from NDB (this contains metadata about all tables)
const NdbDictionary::Table * tab = dict->getTable(tableName);
// Get table id of the table we are interested in
if (tab == 0) APIERROR(dict->getNdbError()); // E.g. table didn't exist
// Get no of attributes and allocate memory
m_cols = tab->getNoOfColumns();
m_names = new char* [m_cols];
m_data = new NdbRecAttr* [m_cols];
// Store all attribute names for the table
for (int i = 0; i < m_cols; i++) {
m_names[i] = new char[255];
BaseString::snprintf(m_names[i], 255, "%s", tab->getColumn(i)->getName());
}
}
int ResultSetContainer::getNoOfAttributes() const {return m_cols;}
NdbRecAttr*& ResultSetContainer::getAttrStore(int i) {return m_data[i];}
const char* ResultSetContainer::getAttrName(int i) const {return m_names[i];}
/*****************************************************************************
********************************** MAIN ***********************************
*****************************************************************************/
int main(int argc, const char** argv)
{
ndb_init();
Ndb* myNdb = new Ndb("ndbapi_example4"); // Object representing the database
NdbConnection* myNdbConnection; // For transactions
NdbOperation* myNdbOperation; // For operations
int check;
if (argc != 2) {
usage(argv[0]);
exit(0);
}
const char* tableName = argv[1];
/*******************************************
* Initialize NDB and wait until its ready *
*******************************************/
if (myNdb->init() == -1) {
APIERROR(myNdb->getNdbError());
exit(-1);
}
if (myNdb->waitUntilReady(30) != 0) {
cout << "NDB was not ready within 30 secs." << endl;
exit(-1);
}
/***************************
* Define and execute scan *
***************************/
cout << "Select * from " << tableName << endl;
ResultSetContainer * container = new ResultSetContainer;
container->init(myNdb->getDictionary(), tableName);
myNdbConnection = myNdb->startTransaction();
if (myNdbConnection == NULL) APIERROR(myNdb->getNdbError());
myNdbOperation = myNdbConnection->getNdbOperation(tableName);
if (myNdbOperation == NULL) APIERROR(myNdbConnection->getNdbError());
// Define the operation to be an 'openScanRead' operation.
check = myNdbOperation->openScanRead(1);
if (check == -1) APIERROR(myNdbConnection->getNdbError());
// Set interpreted program to just be the single instruction
// 'interpret_exit_ok'. (This approves all rows of the table.)
if (myNdbOperation->interpret_exit_ok() == -1)
APIERROR(myNdbConnection->getNdbError());
// Get all attribute values of the row
for(int i = 0; i < container->getNoOfAttributes(); i++){
if((container->getAttrStore(i) =
myNdbOperation->getValue(container->getAttrName(i))) == 0)
APIERROR(myNdbConnection->getNdbError());
}
// Execute scan operation
check = myNdbConnection->executeScan();
if (check == -1) APIERROR(myNdbConnection->getNdbError());
/****************
* Print header *
****************/
for (int i = 0; i < container->getNoOfAttributes(); i++)
cout << container->getAttrName(i) << "\t";
cout << endl;
for (int i = 0; i < container->getNoOfAttributes(); i++) {
for (int j = strlen(container->getAttrName(i)); j > 0; j--)
cout << "-";
cout << "\t";
}
cout << "\n";
/**************
* Scan table *
**************/
int eof;
int rows = 0;
// Print all rows of table
while ((eof = myNdbConnection->nextScanResult()) == 0) {
rows++;
for (int i = 0; i < container->getNoOfAttributes(); i++) {
if (container->getAttrStore(i)->isNULL()) {
cout << "NULL";
} else {
// Element size of value (No of bits per element in attribute value)
const int size = container->getAttrStore(i)->attrSize();
// No of elements in an array attribute (Is 1 if non-array attribute)
const int aSize = container->getAttrStore(i)->arraySize();
switch(container->getAttrStore(i)->attrType()){
case UnSigned:
switch(size) {
case 8: cout << container->getAttrStore(i)->u_64_value(); break;
case 4: cout << container->getAttrStore(i)->u_32_value(); break;
case 2: cout << container->getAttrStore(i)->u_short_value(); break;
case 1: cout << (unsigned) container->getAttrStore(i)->u_char_value();
break;
default: cout << "Unknown size" << endl;
}
break;
case Signed:
switch(size) {
case 8: cout << container->getAttrStore(i)->int64_value(); break;
case 4: cout << container->getAttrStore(i)->int32_value(); break;
case 2: cout << container->getAttrStore(i)->short_value(); break;
case 1: cout << (int) container->getAttrStore(i)->char_value(); break;
default: cout << "Unknown size" << endl;
}
break;
case String:
{
char* buf = new char[aSize+1];
memcpy(buf, container->getAttrStore(i)->aRef(), aSize);
buf[aSize] = 0;
cout << buf;
delete [] buf;
}
break;
case Float:
cout << container->getAttrStore(i)->float_value();
break;
default:
cout << "Unknown";
break;
}
}
cout << "\t";
}
cout << endl;
}
if (eof == -1) APIERROR(myNdbConnection->getNdbError());
myNdb->closeTransaction(myNdbConnection);
cout << "Selected " << rows << " rows." << endl;
}
ndb/include/kernel/signaldata/CreateEvnt.hpp
View file @ ccbadbc9
......@@ -101,7 +101,7 @@ public:
Busy = 701,
NotMaster = 702,
SeizeError = 703,
EventNotFound = 4238,
EventNotFound = 4710,
EventNameTooLong = 4241,
TooManyEvents = 4242,
BadRequestType = 4247,
......@@ -363,11 +363,10 @@ struct CreateEvntRef {
Busy = 701,
NotMaster = 702,
SeizeError = 703,
EventNotFound = 4238,
EventExists = 4239,
EventNameTooLong = 4241,
TooManyEvents = 4242,
// EventExists = 4244,
TooManyEvents = 4707,
EventNameTooLong = 4708,
EventExists = 4709,
EventNotFound = 4731,
AttributeNotStored = 4245,
AttributeNullable = 4246,
BadRequestType = 4247,
......@@ -376,7 +375,7 @@ struct CreateEvntRef {
InvalidEventType = 4250,
NotUnique = 4251,
AllocationError = 4252,
CreateEventTableFailed = 4253,
CreateEventTableFailed = 4711,
InvalidAttributeOrder = 4255,
Temporary = 0x1 << 16
};
......
ndb/include/ndb_global.h.in
View file @ ccbadbc9
......@@ -14,8 +14,8 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#ifndef NDBGLOBAL_H
#define NDBGLOBAL_H
#ifndef NDB_GLOBAL_H
#define NDB_GLOBAL_H
#include <ndb_types.h>
......@@ -31,45 +31,22 @@
#define HAVE_STRCASECMP
#define strcasecmp _strcmpi
#pragma warning(disable: 4503 4786)
typedef unsigned __int64 Uint64;
typedef signed __int64 Int64;
#else
#undef NDB_WIN32
#define DIR_SEPARATOR "/"
typedef unsigned long long Uint64;
typedef signed long long Int64;
#endif
#include <my_global.h>
typedef signed char Int8;
typedef unsigned char Uint8;
typedef signed short Int16;
typedef unsigned short Uint16;
typedef signed int Int32;
typedef unsigned int Uint32;
typedef unsigned int UintR;
#ifdef __SIZE_TYPE__
typedef __SIZE_TYPE__ UintPtr;
#elif SIZEOF_CHARP == 4
typedef Uint32 UintPtr;
#elif SIZEOF_CHARP == 8
typedef Uint64 UintPtr;
#else
#error "Unknown size of (char *)"
#endif
#if ! (SIZEOF_CHAR == 1)
#if ! (NDB_SIZEOF_CHAR == SIZEOF_CHAR)
#error "Invalid define for Uint8"
#endif
#if ! (SIZEOF_INT == 4)
#if ! (NDB_SIZEOF_INT == SIZEOF_INT)
#error "Invalid define for Uint32"
#endif
#if ! (SIZEOF_LONG_LONG == 8)
#if ! (NDB_SIZEOF_LONG_LONG == SIZEOF_LONG_LONG)
#error "Invalid define for Uint64"
#endif
......
ndb/include/ndb_types.h → ndb/include/ndb_types.h.in
View file @ ccbadbc9
......@@ -21,7 +21,61 @@
#ifndef NDB_TYPES_H
#define NDB_TYPES_H
#include "ndb_global.h"
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(_WIN64)
#define NDB_SIZEOF_CHARP SIZEOF_CHARP
#define NDB_SIZEOF_CHAR SIZEOF_CHAR
#define NDB_SIZEOF_SHORT 2
#define NDB_SIZEOF_INT SIZEOF_INT
#define NDB_SIZEOF_LONG SIZEOF_LONG
#define NDB_SIZEOF_LONG_LONG SIZEOF_LONG_LONG
typedef unsigned __int64 Uint64;
typedef signed __int64 Int64;
#else
#define NDB_SIZEOF_CHARP @NDB_SIZEOF_CHARP@
#define NDB_SIZEOF_CHAR @NDB_SIZEOF_CHAR@
#define NDB_SIZEOF_INT @NDB_SIZEOF_INT@
#define NDB_SIZEOF_SHORT @NDB_SIZEOF_SHORT@
#define NDB_SIZEOF_LONG @NDB_SIZEOF_LONG@
#define NDB_SIZEOF_LONG_LONG @NDB_SIZEOF_LONG_LONG@
typedef unsigned long long Uint64;
typedef signed long long Int64;
#endif
typedef signed char Int8;
typedef unsigned char Uint8;
typedef signed short Int16;
typedef unsigned short Uint16;
typedef signed int Int32;
typedef unsigned int Uint32;
typedef unsigned int UintR;
#ifdef __SIZE_TYPE__
typedef __SIZE_TYPE__ UintPtr;
#elif NDB_SIZEOF_CHARP == 4
typedef Uint32 UintPtr;
#elif NDB_SIZEOF_CHARP == 8
typedef Uint64 UintPtr;
#else
#error "Unknown size of (char *)"
#endif
#if ! (NDB_SIZEOF_CHAR == 1)
#error "Invalid define for Uint8"
#endif
#if ! (NDB_SIZEOF_SHORT == 2)
#error "Invalid define for Uint16"
#endif
#if ! (NDB_SIZEOF_INT == 4)
#error "Invalid define for Uint32"
#endif
#if ! (NDB_SIZEOF_LONG_LONG == 8)
#error "Invalid define for Uint64"
#endif
#include "ndb_constants.h"
#endif
ndb/include/ndbapi/Ndb.hpp
View file @ ccbadbc9
This diff is collapsed.
ndb/include/ndbapi/NdbBlob.hpp
View file @ ccbadbc9
......@@ -309,8 +309,8 @@ private:
int invokeActiveHook();
// blob handle maintenance
int atPrepare(NdbTransaction* aCon, NdbOperation* anOp, const NdbColumnImpl* aColumn);
int preExecute(ExecType anExecType, bool& batch);
int postExecute(ExecType anExecType);
int preExecute(NdbTransaction::ExecType anExecType, bool& batch);
int postExecute(NdbTransaction::ExecType anExecType);
int preCommit();
int atNextResult();
// errors
......
ndb/include/ndbapi/NdbDictionary.hpp
View file @ ccbadbc9
......@@ -56,7 +56,7 @@ typedef struct charset_info_st CHARSET_INFO;
* -# NdbDictionary::Column for creating table columns
* -# NdbDictionary::Index for creating secondary indexes
*
* See @ref ndbapi_example4.cpp for details of usage.
* See @ref ndbapi_simple_index.cpp for details of usage.
*/
class NdbDictionary {
public:
......@@ -286,14 +286,14 @@ public:
int getSize() const;
/**
* Check if column is part of distribution key
* Check if column is part of partition key
*
* A <em>distribution key</em> is a set of attributes which are used
* A <em>partition key</em> is a set of attributes which are used
* to distribute the tuples onto the NDB nodes.
* The distribution key uses the NDB Cluster hashing function.
* The partition key uses the NDB Cluster hashing function.
*
* An example where this is useful is TPC-C where it might be
* good to use the warehouse id and district id as the distribution key.
* good to use the warehouse id and district id as the partition key.
* This would place all data for a specific district and warehouse
* in the same database node.
*
......@@ -301,9 +301,12 @@ public:
* will still be used with the hashing algorithm.
*
* @return true then the column is part of
* the distribution key.
* the partition key.
*/
bool getDistributionKey() const;
bool getPartitionKey() const;
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
inline bool getDistributionKey() const { return getPartitionKey(); };
#endif
/** @} *******************************************************************/
......@@ -401,13 +404,17 @@ public:
void setStripeSize(int size);
/**
* Set distribution key
* @see getDistributionKey
* Set partition key
* @see getPartitionKey
*
* @param enable If set to true, then the column will be part of
* the distribution key.
* the partition key.
*/
void setDistributionKey(bool enable);
void setPartitionKey(bool enable);
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
inline void setDistributionKey(bool enable)
{ setPartitionKey(enable); };
#endif
/** @} *******************************************************************/
......@@ -691,7 +698,7 @@ public:
/** @} *******************************************************************/
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
void setStoredTable(bool x) { setLogging(x); }
bool getStoredTable() const { return getLogging(); }
......@@ -894,32 +901,80 @@ public:
*/
class Event : public Object {
public:
enum TableEvent { TE_INSERT=1, TE_DELETE=2, TE_UPDATE=4, TE_ALL=7 };
enum TableEvent {
TE_INSERT=1, ///< Insert event on table
TE_DELETE=2, ///< Delete event on table
TE_UPDATE=4, ///< Update event on table
TE_ALL=7 ///< Any/all event on table (not relevant when
///< events are received)
};
enum EventDurability {
ED_UNDEFINED = 0,
ED_UNDEFINED
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
= 0
#endif
#if 0 // not supported
ED_SESSION = 1,
,ED_SESSION = 1,
// Only this API can use it
// and it's deleted after api has disconnected or ndb has restarted
ED_TEMPORARY = 2,
ED_TEMPORARY = 2
// All API's can use it,
// But's its removed when ndb is restarted
#endif
ED_PERMANENT = 3
// All API's can use it,
// It's still defined after a restart
#endif
,ED_PERMANENT ///< All API's can use it,
///< It's still defined after a restart
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
= 3
#endif
};
Event(const char *name);
virtual ~Event();
void setName(const char *);
void setTable(const char *);
void addTableEvent(const TableEvent);
void setDurability(const EventDurability);
/**
* Set unique identifier for the event
*/
void setName(const char *name);
/**
* Set table for which events should be detected
*/
void setTable(const char *tableName);
/**
* Add type of event that should be detected
*/
void addTableEvent(const TableEvent te);
/**
* Set durability of the event
*/
void setDurability(const EventDurability ed);
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
void addColumn(const Column &c);
#endif
/**
* Add a column on which events should be detected
*
* @param attrId Column id
*
* @note errors will mot be detected until createEvent() is called
*/
void addEventColumn(unsigned attrId);
/**
* Add a column on which events should be detected
*
* @param columnName Column name
*
* @note errors will mot be detected until createEvent() is called
*/
void addEventColumn(const char * columnName);
/**
* Add several columns on which events should be detected
*
* @param n Number of columns
* @param columnNames Column names
*
* @note errors will mot be detected until
* NdbDictionary::Dictionary::createEvent() is called
*/
void addEventColumns(int n, const char ** columnNames);
/**
......@@ -932,7 +987,9 @@ public:
*/
virtual int getObjectVersion() const;
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
void print();
#endif
private:
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
......@@ -1003,6 +1060,8 @@ public:
* Fetch list of all objects, optionally restricted to given type.
*/
int listObjects(List & list, Object::Type type = Object::TypeUndefined);
int listObjects(List & list,
Object::Type type = Object::TypeUndefined) const;
/**
* Get the latest error
......@@ -1023,7 +1082,7 @@ public:
* @param name Name of table to get
* @return table if successful otherwise NULL.
*/
const Table * getTable(const char * name);
const Table * getTable(const char * name) const;
/**
* Get index with given name, NULL if undefined
......@@ -1032,7 +1091,7 @@ public:
* @return index if successful, otherwise 0.
*/
const Index * getIndex(const char * indexName,
const char * tableName);
const char * tableName) const;
/**
* Fetch list of indexes of given table.
......@@ -1041,6 +1100,7 @@ public:
* @return 0 if successful, otherwise -1
*/
int listIndexes(List & list, const char * tableName);
int listIndexes(List & list, const char * tableName) const;
/** @} *******************************************************************/
/**
......@@ -1173,10 +1233,10 @@ public:
class NdbDictionaryImpl & m_impl;
Dictionary(NdbDictionaryImpl&);
const Table * getIndexTable(const char * indexName,
const char * tableName);
const char * tableName) const;
public:
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
const Table * getTable(const char * name, void **data);
const Table * getTable(const char * name, void **data) const;
void set_local_table_data_size(unsigned sz);
#endif
};
......
ndb/include/ndbapi/NdbError.hpp
View file @ ccbadbc9
......@@ -41,7 +41,7 @@
* The <em>error messages</em> and <em>error details</em> may
* change without notice.
*
* For example of use, see @ref ndbapi_example3.cpp.
* For example of use, see @ref ndbapi_retries.cpp.
*/
struct NdbError {
/**
......
ndb/include/ndbapi/NdbEventOperation.hpp
View file @ ccbadbc9
......@@ -46,7 +46,7 @@ class NdbEventOperationImpl;
* The instance is removed by Ndb::dropEventOperation
*
* For more info see:
* @ref ndbapi_example5.cpp
* @ref ndbapi_event.cpp
*
* Known limitations:
*
......
ndb/include/ndbapi/NdbIndexScanOperation.hpp
View file @ ccbadbc9
......@@ -73,7 +73,7 @@ public:
*
* For equality, it is better to use BoundEQ instead of the equivalent
* pair of BoundLE and BoundGE. This is especially true when table
* distribution key is an initial part of the index key.
* partition key is an initial part of the index key.
*
* The sets of lower and upper bounds must be on initial sequences of
* index keys. All but possibly the last bound must be non-strict.
......
ndb/include/ndbapi/NdbOperation.hpp
View file @ ccbadbc9
......@@ -59,10 +59,17 @@ public:
*/
enum LockMode {
LM_Read = 0,
LM_Exclusive = 1,
LM_CommittedRead = 2,
LM_Read ///< Read with shared lock
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
= 0
#endif
,LM_Exclusive ///< Read with exclusive lock
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
= 1
#endif
,LM_CommittedRead ///< Ignore locks, read last committed value
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
= 2,
LM_Dirty = 2
#endif
};
......@@ -237,10 +244,13 @@ public:
* use several equals (then all of them must be satisfied for the
* tuple to be selected).
*
* @note There are 10 versions of NdbOperation::equal with
* @note For insertTuple() it is also allowed to define the
* search key by using setValue().
*
* @note There are 10 versions of equal() with
* slightly different parameters.
*
* @note When using NdbOperation::equal with a string (char *) as
* @note When using equal() with a string (char *) as
* second argument, the string needs to be padded with
* zeros in the following sense:
* @code
......@@ -248,6 +258,8 @@ public:
* strncpy(buf, str, sizeof(buf));
* NdbOperation->equal("Attr1", buf);
* @endcode
*
*
*
* @param anAttrName Attribute name
* @param aValue Attribute value.
......@@ -328,6 +340,12 @@ public:
* then the API will assume that the pointer
* is correct and not bother with checking it.
*
* @note For insertTuple() the NDB API will automatically detect that
* it is supposed to use equal() instead.
*
* @note For insertTuple() it is not necessary to use
* setValue() on key attributes before other attributes.
*
* @note There are 14 versions of NdbOperation::setValue with
* slightly different parameters.
*
......@@ -720,7 +738,7 @@ public:
void setAbortOption(Int8 ao) { m_abortOption = ao; }
/**
* Set/get distribution/partition key
* Set/get partition key
*/
void setPartitionId(Uint32 id);
void setPartitionHash(Uint32 key);
......
ndb/include/ndbapi/NdbRecAttr.hpp
View file @ ccbadbc9
......@@ -39,7 +39,7 @@ class NdbOperation;
* ndbout << MyRecAttr->u_32_value();
* @endcode
* For more examples, see
* @ref ndbapi_example1.cpp.
* @ref ndbapi_simple.cpp.
*
* @note The NdbRecAttr object is instantiated with its value when
* NdbTransaction::execute is called. Before this, the value is
......
ndb/include/ndbapi/NdbTransaction.hpp
View file @ ccbadbc9
......@@ -42,72 +42,62 @@ class NdbBlob;
typedef void (* NdbAsynchCallback)(int, NdbTransaction*, void*);
#endif
/**
* Commit type of transaction
*/
enum AbortOption {
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
CommitIfFailFree = 0,
CommitAsMuchAsPossible = 2, ///< Commit transaction with as many
TryCommit = 0, ///< <i>Missing explanation</i>
#endif
AbortOnError = 0, ///< Abort transaction on failed operation
AO_IgnoreError = 2 ///< Transaction continues on failed operation
enum AbortOption {
CommitIfFailFree= 0,
TryCommit= 0,
AbortOnError= 0,
CommitAsMuchAsPossible= 2,
AO_IgnoreError= 2
};
typedef AbortOption CommitType;
/**
* Execution type of transaction
*/
enum ExecType {
NoExecTypeDef = -1, ///< Erroneous type (Used for debugging only)
Prepare, ///< <i>Missing explanation</i>
NoCommit, ///< Execute the transaction as far as it has
///< been defined, but do not yet commit it
Commit, ///< Execute and try to commit the transaction
Rollback ///< Rollback transaction
NoExecTypeDef = -1,
Prepare,
NoCommit,
Commit,
Rollback
};
#endif
/**
* @class NdbTransaction
* @brief Represents a transaction.
*
* A transaction (represented by an NdbTransaction object)
* belongs to an Ndb object and is typically created using
* Ndb::startTransaction.
* belongs to an Ndb object and is created using
* Ndb::startTransaction().
* A transaction consists of a list of operations
* (represented by NdbOperation objects).
* (represented by NdbOperation, NdbScanOperation, NdbIndexOperation,
* and NdbIndexScanOperation objects).
* Each operation access exactly one table.
*
* After getting the NdbTransaction object,
* the first step is to get (allocate) an operation given the table name.
* the first step is to get (allocate) an operation given the table name using
* one of the methods getNdbOperation(), getNdbScanOperation(),
* getNdbIndexOperation(), or getNdbIndexScanOperation().
* Then the operation is defined.
* Several operations can be defined in parallel on the same
* NdbTransaction object.
* When all operations are defined, the NdbTransaction::execute
* method sends them to the NDB kernel for execution.
* Several operations can be defined on the same
* NdbTransaction object, they will in that case be executed in parallell.
* When all operations are defined, the execute()
* method sends them to the NDB kernel for execution.
*
* The NdbTransaction::execute method returns when the NDB kernel has
* The execute() method returns when the NDB kernel has
* completed execution of all operations defined before the call to
* NdbTransaction::execute.
* All allocated operations should be properly defined
* before calling NdbTransaction::execute.
* execute(). All allocated operations should be properly defined
* before calling execute().
*
* A call to NdbTransaction::execute uses one out of three types of execution:
* -# ExecType::NoCommit Executes operations without committing them.
* -# ExecType::Commit Executes remaining operation and commits the
* A call to execute() uses one out of three types of execution:
* -# NdbTransaction::NoCommit Executes operations without committing them.
* -# NdbTransaction::Commit Executes remaining operation and commits the
* complete transaction
* -# ExecType::Rollback Rollbacks the entire transaction.
* -# NdbTransaction::Rollback Rollbacks the entire transaction.
*
* NdbTransaction::execute is equipped with an extra error handling parameter
* execute() is equipped with an extra error handling parameter.
* There are two alternatives:
* -# AbortOption::AbortOnError (default).
* -# NdbTransaction::AbortOnError (default).
* The transaction is aborted if there are any error during the
* execution
* -# AbortOption::IgnoreError
* -# NdbTransaction::AO_IgnoreError
* Continue execution of transaction even if operation fails
*
*/
......@@ -139,6 +129,7 @@ enum ExecType {
* primary key since it came along from the scanned tuple.
*
*/
class NdbTransaction
{
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
......@@ -152,6 +143,44 @@ class NdbTransaction
public:
/**
* Commit type of transaction
*/
enum AbortOption {
AbortOnError= ///< Abort transaction on failed operation
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
::AbortOnError
#endif
,AO_IgnoreError= ///< Transaction continues on failed operation
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
::AO_IgnoreError
#endif
};
/**
* Execution type of transaction
*/
enum ExecType {
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
NoExecTypeDef=
::NoExecTypeDef, ///< Erroneous type (Used for debugging only)
Prepare= ::Prepare, ///< <i>Missing explanation</i>
#endif
NoCommit= ///< Execute the transaction as far as it has
///< been defined, but do not yet commit it
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
::NoCommit
#endif
,Commit= ///< Execute and try to commit the transaction
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
::Commit
#endif
,Rollback ///< Rollback transaction
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
= ::Rollback
#endif
};
/**
* Get an NdbOperation for a table.
* Note that the operation has to be defined before it is executed.
......@@ -279,9 +308,15 @@ public:
* the send.
* @return 0 if successful otherwise -1.
*/
int execute(ExecType execType,
int execute(ExecType execType,
AbortOption abortOption = AbortOnError,
int force = 0 );
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
int execute(::ExecType execType,
::AbortOption abortOption = ::AbortOnError,
int force = 0 )
{ return execute ((ExecType)execType,(AbortOption)abortOption,force); }
#endif
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
// to be documented later
......@@ -298,7 +333,7 @@ public:
* ExecType::Rollback rollbacks the entire transaction.
* @param callback A callback method. This method gets
* called when the transaction has been
* executed. See @ref ndbapi_example2.cpp
* executed. See @ref ndbapi_async1.cpp
* for an example on how to specify and use
* a callback method.
* @param anyObject A void pointer. This pointer is forwarded to the
......@@ -312,6 +347,14 @@ public:
NdbAsynchCallback callback,
void* anyObject,
AbortOption abortOption = AbortOnError);
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
void executeAsynchPrepare(::ExecType execType,
NdbAsynchCallback callback,
void* anyObject,
::AbortOption abortOption = ::AbortOnError)
{ executeAsynchPrepare((ExecType)execType, callback, anyObject,
(AbortOption)abortOption); }
#endif
/**
* Prepare and send an asynchronous transaction.
......@@ -330,6 +373,14 @@ public:
NdbAsynchCallback aCallback,
void* anyObject,
AbortOption abortOption = AbortOnError);
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
void executeAsynch(::ExecType aTypeOfExec,
NdbAsynchCallback aCallback,
void* anyObject,
::AbortOption abortOption= ::AbortOnError)
{ executeAsynch((ExecType)aTypeOfExec, aCallback, anyObject,
(AbortOption)abortOption); }
#endif
#endif
/**
* Refresh
......@@ -345,6 +396,8 @@ public:
/**
* Close transaction
*
* @note Equivalent to to calling Ndb::closeTransaction()
*/
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
/**
......@@ -366,7 +419,13 @@ public:
* Once a transaction has been completed successfully
* it can be started again wo/ calling closeTransaction/startTransaction
*
* Note this method also releases completed operations
* @note This method also releases completed operations
*
* @note This method does not close open scans,
* c.f. NdbScanOperation::close()
*
* @note This method can only be called _directly_ after commit
* and only if commit is successful
*/
int restart();
#endif
......@@ -409,10 +468,7 @@ public:
Uint64 getTransactionId();
/**
* Returns the commit status of the transaction.
*
* @return The commit status of the transaction, i.e. one of
* { NotStarted, Started, TimeOut, Committed, Aborted, NeedAbort }
* The commit status of the transaction.
*/
enum CommitStatusType {
NotStarted, ///< Transaction not yet started
......@@ -422,6 +478,11 @@ public:
NeedAbort ///< <i>Missing explanation</i>
};
/**
* Get the commit status of the transaction.
*
* @return The commit status of the transaction
*/
CommitStatusType commitStatus();
/** @} *********************************************************************/
......@@ -443,7 +504,7 @@ public:
* This method is used on the NdbTransaction object to find the
* NdbOperation causing an error.
* To find more information about the
* actual error, use method NdbOperation::getNdbError
* actual error, use method NdbOperation::getNdbError()
* on the returned NdbOperation object.
*
* @return The NdbOperation causing the latest error.
......
ndb/src/ndbapi/NdbBlob.cpp
View file @ ccbadbc9
......@@ -875,7 +875,7 @@ NdbBlob::readParts(char* buf, Uint32 part, Uint32 count)
setErrorCode(tOp);
return -1;
}
tOp->m_abortOption = AbortOnError;
tOp->m_abortOption = NdbTransaction::AbortOnError;
buf += thePartSize;
n++;
thePendingBlobOps |= (1 << NdbOperation::ReadRequest);
......@@ -898,7 +898,7 @@ NdbBlob::insertParts(const char* buf, Uint32 part, Uint32 count)
setErrorCode(tOp);
return -1;
}
tOp->m_abortOption = AbortOnError;
tOp->m_abortOption = NdbTransaction::AbortOnError;
buf += thePartSize;
n++;
thePendingBlobOps |= (1 << NdbOperation::InsertRequest);
......@@ -921,7 +921,7 @@ NdbBlob::updateParts(const char* buf, Uint32 part, Uint32 count)
setErrorCode(tOp);
return -1;
}
tOp->m_abortOption = AbortOnError;
tOp->m_abortOption = NdbTransaction::AbortOnError;
buf += thePartSize;
n++;
thePendingBlobOps |= (1 << NdbOperation::UpdateRequest);
......@@ -943,7 +943,7 @@ NdbBlob::deleteParts(Uint32 part, Uint32 count)
setErrorCode(tOp);
return -1;
}
tOp->m_abortOption = AbortOnError;
tOp->m_abortOption = NdbTransaction::AbortOnError;
n++;
thePendingBlobOps |= (1 << NdbOperation::DeleteRequest);
theNdbCon->thePendingBlobOps |= (1 << NdbOperation::DeleteRequest);
......@@ -976,11 +976,11 @@ NdbBlob::deletePartsUnknown(Uint32 part)
setErrorCode(tOp);
return -1;
}
tOp->m_abortOption = AO_IgnoreError;
tOp->m_abortOption= NdbTransaction::AO_IgnoreError;
n++;
}
DBG("deletePartsUnknown: executeNoBlobs [in] bat=" << bat);
if (theNdbCon->executeNoBlobs(NoCommit) == -1)
if (theNdbCon->executeNoBlobs(NdbTransaction::NoCommit) == -1)
return -1;
DBG("deletePartsUnknown: executeNoBlobs [out]");
n = 0;
......@@ -1012,7 +1012,7 @@ NdbBlob::executePendingBlobReads()
Uint8 flags = (1 << NdbOperation::ReadRequest);
if (thePendingBlobOps & flags) {
DBG("executePendingBlobReads: executeNoBlobs [in]");
if (theNdbCon->executeNoBlobs(NoCommit) == -1)
if (theNdbCon->executeNoBlobs(NdbTransaction::NoCommit) == -1)
return -1;
DBG("executePendingBlobReads: executeNoBlobs [out]");
thePendingBlobOps = 0;
......@@ -1027,7 +1027,7 @@ NdbBlob::executePendingBlobWrites()
Uint8 flags = 0xFF & ~(1 << NdbOperation::ReadRequest);
if (thePendingBlobOps & flags) {
DBG("executePendingBlobWrites: executeNoBlobs [in]");
if (theNdbCon->executeNoBlobs(NoCommit) == -1)
if (theNdbCon->executeNoBlobs(NdbTransaction::NoCommit) == -1)
return -1;
DBG("executePendingBlobWrites: executeNoBlobs [out]");
thePendingBlobOps = 0;
......@@ -1175,7 +1175,7 @@ NdbBlob::atPrepare(NdbTransaction* aCon, NdbOperation* anOp, const NdbColumnImpl
* back after postExecute.
*/
int
NdbBlob::preExecute(ExecType anExecType, bool& batch)
NdbBlob::preExecute(NdbTransaction::ExecType anExecType, bool& batch)
{
DBG("preExecute [in]");
if (theState == Invalid)
......@@ -1224,7 +1224,7 @@ NdbBlob::preExecute(ExecType anExecType, bool& batch)
return -1;
}
if (isWriteOp()) {
tOp->m_abortOption = AO_IgnoreError;
tOp->m_abortOption = NdbTransaction::AO_IgnoreError;
}
theHeadInlineReadOp = tOp;
// execute immediately
......@@ -1270,7 +1270,7 @@ NdbBlob::preExecute(ExecType anExecType, bool& batch)
return -1;
}
if (isWriteOp()) {
tOp->m_abortOption = AO_IgnoreError;
tOp->m_abortOption = NdbTransaction::AO_IgnoreError;
}
theHeadInlineReadOp = tOp;
// execute immediately
......@@ -1316,18 +1316,18 @@ NdbBlob::preExecute(ExecType anExecType, bool& batch)
* any remaining prepared operations.
*/
int
NdbBlob::postExecute(ExecType anExecType)
NdbBlob::postExecute(NdbTransaction::ExecType anExecType)
{
DBG("postExecute [in] type=" << anExecType);
if (theState == Invalid)
return -1;
if (theState == Active) {
setState(anExecType == NoCommit ? Active : Closed);
setState(anExecType == NdbTransaction::NoCommit ? Active : Closed);
DBG("postExecute [skip]");
return 0;
}
assert(theState == Prepared);
setState(anExecType == NoCommit ? Active : Closed);
setState(anExecType == NdbTransaction::NoCommit ? Active : Closed);
assert(isKeyOp());
if (isIndexOp()) {
NdbBlob* tFirstBlob = theNdbOp->theBlobList;
......@@ -1343,14 +1343,15 @@ NdbBlob::postExecute(ExecType anExecType)
return -1;
if (theGetFlag) {
assert(theGetSetBytes == 0 || theGetBuf != 0);
assert(theGetSetBytes <= theInlineSize || anExecType == NoCommit);
assert(theGetSetBytes <= theInlineSize ||
anExecType == NdbTransaction::NoCommit);
Uint32 bytes = theGetSetBytes;
if (readDataPrivate(theGetBuf, bytes) == -1)
return -1;
}
}
if (isUpdateOp()) {
assert(anExecType == NoCommit);
assert(anExecType == NdbTransaction::NoCommit);
getHeadFromRecAttr();
if (theSetFlag) {
// setValue overwrites everything
......@@ -1367,7 +1368,7 @@ NdbBlob::postExecute(ExecType anExecType)
}
}
if (isWriteOp() && isTableOp()) {
assert(anExecType == NoCommit);
assert(anExecType == NdbTransaction::NoCommit);
if (theHeadInlineReadOp->theError.code == 0) {
int tNullFlag = theNullFlag;
Uint64 tLength = theLength;
......@@ -1418,18 +1419,18 @@ NdbBlob::postExecute(ExecType anExecType)
}
}
if (isDeleteOp()) {
assert(anExecType == NoCommit);
assert(anExecType == NdbTransaction::NoCommit);
getHeadFromRecAttr();
if (deleteParts(0, getPartCount()) == -1)
return -1;
}
setState(anExecType == NoCommit ? Active : Closed);
setState(anExecType == NdbTransaction::NoCommit ? Active : Closed);
// activation callback
if (theActiveHook != NULL) {
if (invokeActiveHook() == -1)
return -1;
}
if (anExecType == NoCommit && theHeadInlineUpdateFlag) {
if (anExecType == NdbTransaction::NoCommit && theHeadInlineUpdateFlag) {
NdbOperation* tOp = theNdbCon->getNdbOperation(theTable);
if (tOp == NULL ||
tOp->updateTuple() == -1 ||
......@@ -1438,7 +1439,7 @@ NdbBlob::postExecute(ExecType anExecType)
setErrorCode(NdbBlobImpl::ErrAbort);
return -1;
}
tOp->m_abortOption = AbortOnError;
tOp->m_abortOption = NdbTransaction::AbortOnError;
DBG("added op to update head+inline");
}
DBG("postExecute [out]");
......@@ -1468,7 +1469,7 @@ NdbBlob::preCommit()
setErrorCode(NdbBlobImpl::ErrAbort);
return -1;
}
tOp->m_abortOption = AbortOnError;
tOp->m_abortOption = NdbTransaction::AbortOnError;
DBG("added op to update head+inline");
}
}
......
ndb/src/ndbapi/NdbDictionary.cpp
View file @ ccbadbc9
......@@ -177,12 +177,12 @@ NdbDictionary::Column::getPrimaryKey() const {
}
void
NdbDictionary::Column::setDistributionKey(bool val){
NdbDictionary::Column::setPartitionKey(bool val){
m_impl.m_distributionKey = val;
}
bool
NdbDictionary::Column::getDistributionKey() const{
NdbDictionary::Column::getPartitionKey() const{
return m_impl.m_distributionKey;
}
......@@ -706,7 +706,8 @@ NdbDictionary::Dictionary::alterTable(const Table & t){
}
const NdbDictionary::Table *
NdbDictionary::Dictionary::getTable(const char * name, void **data){
NdbDictionary::Dictionary::getTable(const char * name, void **data) const
{
NdbTableImpl * t = m_impl.getTable(name, data);
if(t)
return t->m_facade;
......@@ -719,7 +720,8 @@ void NdbDictionary::Dictionary::set_local_table_data_size(unsigned sz)
}
const NdbDictionary::Table *
NdbDictionary::Dictionary::getTable(const char * name){
NdbDictionary::Dictionary::getTable(const char * name) const
{
return getTable(name, 0);
}
......@@ -752,7 +754,7 @@ NdbDictionary::Dictionary::dropIndex(const char * indexName,
const NdbDictionary::Index *
NdbDictionary::Dictionary::getIndex(const char * indexName,
const char * tableName)
const char * tableName) const
{
NdbIndexImpl * i = m_impl.getIndex(indexName, tableName);
if(i)
......@@ -782,7 +784,7 @@ NdbDictionary::Dictionary::removeCachedIndex(const char * indexName,
const NdbDictionary::Table *
NdbDictionary::Dictionary::getIndexTable(const char * indexName,
const char * tableName)
const char * tableName) const
{
NdbIndexImpl * i = m_impl.getIndex(indexName, tableName);
NdbTableImpl * t = m_impl.getTable(tableName);
......@@ -821,6 +823,12 @@ NdbDictionary::Dictionary::listObjects(List& list, Object::Type type)
return m_impl.listObjects(list, type);
}
int
NdbDictionary::Dictionary::listObjects(List& list, Object::Type type) const
{
return m_impl.listObjects(list, type);
}
int
NdbDictionary::Dictionary::listIndexes(List& list, const char * tableName)
{
......@@ -832,6 +840,18 @@ NdbDictionary::Dictionary::listIndexes(List& list, const char * tableName)
return m_impl.listIndexes(list, tab->getTableId());
}
int
NdbDictionary::Dictionary::listIndexes(List& list,
const char * tableName) const
{
const NdbDictionary::Table* tab= getTable(tableName);
if(tab == 0)
{
return -1;
}
return m_impl.listIndexes(list, tab->getTableId());
}
const struct NdbError &
NdbDictionary::Dictionary::getNdbError() const {
return m_impl.getNdbError();
......
ndb/src/ndbapi/NdbDictionaryImpl.cpp
View file @ ccbadbc9
......@@ -941,7 +941,7 @@ NdbDictInterface::dictSignal(NdbApiSignal* signal,
for (int j=0; j < noerrcodes; j++)
if(m_error.code == errcodes[j]) {
doContinue = 1;
continue;
break;
}
if (doContinue)
continue;
......@@ -1007,12 +1007,14 @@ NdbDictInterface::getTable(class NdbApiSignal * signal,
Uint32 noOfSections, bool fullyQualifiedNames)
{
//GetTabInfoReq * const req = CAST_PTR(GetTabInfoReq, signal->getDataPtrSend());
int errCodes[] = {GetTabInfoRef::Busy };
int r = dictSignal(signal,ptr,noOfSections,
0/*do not use masternode id*/,
100,
WAIT_GET_TAB_INFO_REQ,
WAITFOR_RESPONSE_TIMEOUT,
NULL,0);
errCodes, 1);
if (r) return 0;
NdbTableImpl * rt = 0;
......@@ -2234,10 +2236,9 @@ NdbDictionaryImpl::createEvent(NdbEventImpl & evnt)
NdbTableImpl* tab = getTable(evnt.getTable());
if(tab == 0){
// m_error.code = 3249;
ndbout_c(":createEvent: table %s not found", evnt.getTable());
#ifdef EVENT_DEBUG
ndbout_c("NdbDictionaryImpl::createEvent: table not found: %s", evnt.getTable());
ndbout_c("NdbDictionaryImpl::createEvent: table not found: %s",
evnt.getTable());
#endif
return -1;
}
......
ndb/src/ndbapi/NdbRecAttr.cpp
View file @ ccbadbc9
......@@ -15,17 +15,6 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/************************************************************************************************
Name: NdbRecAttr.C
Include:
Link:
Author: UABRONM Mikael Ronstrm UAB/B/SD
Date: 971206
Version: 0.1
Description: Interface between TIS and NDB
Documentation:
Adjust: 971206 UABRONM First version
************************************************************************************************/
#include <ndb_global.h>
#include <NdbOut.hpp>
#include <NdbRecAttr.hpp>
......@@ -148,6 +137,39 @@ NdbRecAttr::receive_data(const Uint32 * data, Uint32 sz){
return false;
}
static void
ndbrecattr_print_string(NdbOut& out, const char *type,
const char *ref, unsigned sz)
{
int i, len, printable= 1;
// trailing zeroes are not printed
for (i=sz-1; i >= 0; i--)
if (ref[i] == 0) sz--;
else break;
if (sz == 0) return; // empty
for (len=0; len < (int)sz && ref[i] != 0; len++)
if (printable && !isprint((int)ref[i]))
printable= 0;
if (printable)
out.print("%.*s", len, ref);
else
{
out.print("0x");
for (i=0; i < len; i++)
out.print("%02X", (int)ref[i]);
}
if (len != (int)sz)
{
out.print("[");
for (i= len+1; ref[i] != 0; i++)
out.print("%u]",len-i);
assert((int)sz > i);
ndbrecattr_print_string(out,type,ref+i,sz-i);
}
}
NdbOut& operator<<(NdbOut& out, const NdbRecAttr &r)
{
if (r.isNULL())
......@@ -193,17 +215,19 @@ NdbOut& operator<<(NdbOut& out, const NdbRecAttr &r)
case NdbDictionary::Column::Tinyint:
out << (int) r.char_value();
break;
case NdbDictionary::Column::Binary:
ndbrecattr_print_string(out,"Binary",r.aRef(),r.arraySize());
j = r.arraySize();
break;
case NdbDictionary::Column::Char:
out.print("%.*s", r.arraySize(), r.aRef());
ndbrecattr_print_string(out,"Char",r.aRef(),r.arraySize());
j = r.arraySize();
break;
case NdbDictionary::Column::Varchar:
{
short len = ntohs(r.u_short_value());
out.print("%.*s", len, r.aRef()+2);
}
ndbrecattr_print_string(out,"Varchar", r.aRef()+ 2,
ntohs(r.u_short_value()));
j = r.arraySize();
break;
break;
case NdbDictionary::Column::Float:
out << r.float_value();
break;
......
ndb/src/ndbapi/NdbTransaction.cpp
View file @ ccbadbc9
......@@ -1076,15 +1076,15 @@ NdbTransaction::getNdbScanOperation(const char* aTableName)
}//NdbTransaction::getNdbScanOperation()
/*****************************************************************************
NdbScanOperation* getNdbScanOperation(const char* anIndexName, const char* aTableName);
NdbScanOperation* getNdbIndexScanOperation(const char* anIndexName, const char* aTableName);
Return Value Return a pointer to a NdbScanOperation object if getNdbScanOperation was succesful.
Return Value Return a pointer to a NdbIndexScanOperation object if getNdbIndexScanOperation was succesful.
Return NULL : In all other case.
Parameters: anIndexName : Name of the index to use.
aTableName : Name of the database table.
Remark: Get an operation from NdbScanOperation idlelist and get the NdbTransaction object
Remark: Get an operation from NdbIndexScanOperation idlelist and get the NdbTransaction object
who was fetch by startTransaction pointing to this operation
getOperation will set the theTableId in the NdbOperation object.synchronous
getOperation will set the theTableId in the NdbIndexScanOperation object.synchronous
******************************************************************************/
NdbIndexScanOperation*
NdbTransaction::getNdbIndexScanOperation(const char* anIndexName,
......@@ -1134,12 +1134,12 @@ NdbTransaction::getNdbIndexScanOperation(const NdbDictionary::Index * index,
/*****************************************************************************
NdbScanOperation* getNdbScanOperation(int aTableId);
Return Value Return a pointer to a NdbOperation object if getNdbOperation was succesful.
Return Value Return a pointer to a NdbScanOperation object if getNdbScanOperation was succesful.
Return NULL: In all other case.
Parameters: tableId : Id of the database table beeing deleted.
Remark: Get an operation from NdbScanOperation object idlelist and get the NdbTransaction
object who was fetch by startTransaction pointing to this operation
getOperation will set the theTableId in the NdbOperation object, synchronous.
getOperation will set the theTableId in the NdbScanOperation object, synchronous.
*****************************************************************************/
NdbIndexScanOperation*
NdbTransaction::getNdbScanOperation(const NdbTableImpl * tab)
......@@ -1203,12 +1203,12 @@ NdbTransaction::getNdbScanOperation(const NdbDictionary::Table * table)
NdbIndexOperation* getNdbIndexOperation(const char* anIndexName,
const char* aTableName);
Return Value Return a pointer to a NdbOperation object if getNdbScanOperation was succesful.
Return Value Return a pointer to a NdbOperation object if getNdbIndexOperation was succesful.
Return NULL : In all other case.
Parameters: aTableName : Name of the database table.
Remark: Get an operation from NdbScanOperation idlelist and get the NdbTransaction object
who was fetch by startTransaction pointing to this operation
getOperation will set the theTableId in the NdbScanOperation object.synchronous
Remark: Get an operation from NdbIndexOperation idlelist and get the NdbTransaction object
who was fetch by startTransaction pointing to this operation
getOperation will set the theTableId in the NdbIndexOperation object.synchronous
******************************************************************************/
NdbIndexOperation*
NdbTransaction::getNdbIndexOperation(const char* anIndexName,
......@@ -1216,8 +1216,21 @@ NdbTransaction::getNdbIndexOperation(const char* anIndexName,
{
if (theCommitStatus == Started) {
NdbTableImpl * table = theNdb->theDictionary->getTable(aTableName);
NdbIndexImpl * index = theNdb->theDictionary->getIndex(anIndexName,
aTableName);
NdbIndexImpl * index;
if (table->m_frm.get_data())
{
// This unique index is defined from SQL level
static const char* uniqueSuffix= "$unique";
char uniqueIndexName[MAX_TAB_NAME_SIZE];
strxnmov(uniqueIndexName, MAX_TAB_NAME_SIZE, anIndexName, uniqueSuffix, NullS);
index = theNdb->theDictionary->getIndex(uniqueIndexName,
aTableName);
}
else
index = theNdb->theDictionary->getIndex(anIndexName,
aTableName);
if(table != 0 && index != 0){
return getNdbIndexOperation(index, table);
}
......
ndb/src/ndbapi/ndberror.c
View file @ ccbadbc9
......@@ -79,6 +79,7 @@ static const char* empty_string = "";
* 4400 - ""
* 4500 - ""
* 4600 - ""
* 4700 - "" Event
* 5000 - Management server
*/
......@@ -296,6 +297,22 @@ ErrorBundle ErrorCodes[] = {
{ 4232, AE, "Parallelism can only be between 1 and 240" },
{ 290, AE, "Scan not started or has been closed by kernel due to timeout" },
/**
* Event application errors
*/
{ 4707, AE, "Too many event have been defined"},
{ 4708, AE, "Event name is too long"},
{ 4709, AE, "Event already exists"},
{ 4710, AE, "Event not found"},
{ 4711, AE, "Creation of event failed"},
/**
* Event internal errors
*/
{ 4731, IE, "Event not found"},
/**
* SchemaError
*/
......
ndb/tools/delete_all.cpp
View file @ ccbadbc9
......@@ -80,19 +80,21 @@ int main(int argc, char** argv){
Ndb_cluster_connection con(opt_connect_str);
if(con.connect(12, 5, 1) != 0)
{
ndbout << "Unable to connect to management server." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, _dbname );
Ndb MyNdb(&con, _dbname );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
// Connect to Ndb and wait for it to become ready
while(MyNdb.waitUntilReady() != 0)
ndbout << "Waiting for ndb to become ready..." << endl;
// Check if table exists in db
int res = NDBT_OK;
for(int i = 0; i<argc; i++){
......@@ -119,7 +121,7 @@ int clear_table(Ndb* pNdb, const NdbDictionary::Table* pTab, int parallelism)
const int retryMax = 10;
int deletedRows = 0;
int check;
NdbConnection *pTrans;
NdbTransaction *pTrans;
NdbScanOperation *pOp;
NdbError err;
......@@ -148,11 +150,11 @@ int clear_table(Ndb* pNdb, const NdbDictionary::Table* pTab, int parallelism)
goto failed;
}
if( pOp->readTuplesExclusive(par) ) {
if( pOp->readTuples(NdbOperation::LM_Exclusive,par) ) {
goto failed;
}
if(pTrans->execute(NoCommit) != 0){
if(pTrans->execute(NdbTransaction::NoCommit) != 0){
err = pTrans->getNdbError();
if(err.status == NdbError::TemporaryError){
ERR(err);
......@@ -172,7 +174,7 @@ int clear_table(Ndb* pNdb, const NdbDictionary::Table* pTab, int parallelism)
} while((check = pOp->nextResult(false)) == 0);
if(check != -1){
check = pTrans->execute(Commit);
check = pTrans->execute(NdbTransaction::Commit);
pTrans->restart();
}
......
ndb/tools/desc.cpp
View file @ ccbadbc9
......@@ -80,19 +80,22 @@ int main(int argc, char** argv){
Ndb_cluster_connection con(opt_connect_str);
if(con.connect(12, 5, 1) != 0)
{
ndbout << "Unable to connect to management server." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb* pMyNdb = new Ndb(&con, _dbname);
pMyNdb->init();
ndbout << "Waiting...";
while (pMyNdb->waitUntilReady() != 0) {
ndbout << "...";
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
ndbout << endl;
NdbDictionary::Dictionary * dict = pMyNdb->getDictionary();
Ndb MyNdb(&con, _dbname);
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
const NdbDictionary::Dictionary * dict= MyNdb.getDictionary();
for (int i = 0; i < argc; i++) {
NDBT_Table* pTab = (NDBT_Table*)dict->getTable(argv[i]);
if (pTab != 0){
......@@ -132,6 +135,5 @@ int main(int argc, char** argv){
ndbout << argv[i] << ": " << dict->getNdbError() << endl;
}
delete pMyNdb;
return NDBT_ProgramExit(NDBT_OK);
}
ndb/tools/drop_index.cpp
View file @ ccbadbc9
......@@ -83,16 +83,18 @@ int main(int argc, char** argv){
{
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, _dbname );
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, _dbname );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
while(MyNdb.waitUntilReady() != 0)
ndbout << "Waiting for ndb to become ready..." << endl;
int res = 0;
for(int i = 0; i<argc; i++){
ndbout << "Dropping index " << argv[i] << "...";
......
ndb/tools/drop_tab.cpp
View file @ ccbadbc9
......@@ -81,18 +81,21 @@ int main(int argc, char** argv){
Ndb_cluster_connection con(opt_connect_str);
if(con.connect(12, 5, 1) != 0)
{
ndbout << "Unable to connect to management server." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, _dbname );
Ndb MyNdb(&con, _dbname );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
while(MyNdb.waitUntilReady() != 0)
ndbout << "Waiting for ndb to become ready..." << endl;
int res = 0;
for(int i = 0; i<argc; i++){
ndbout << "Dropping table " << argv[i] << "...";
......
ndb/tools/listTables.cpp
View file @ ccbadbc9
......@@ -29,7 +29,7 @@
static Ndb_cluster_connection *ndb_cluster_connection= 0;
static Ndb* ndb = 0;
static NdbDictionary::Dictionary* dic = 0;
static const NdbDictionary::Dictionary * dic = 0;
static int _unqualified = 0;
static void
......@@ -233,16 +233,19 @@ int main(int argc, char** argv){
ndb_cluster_connection = new Ndb_cluster_connection(opt_connect_str);
if (ndb_cluster_connection->connect(12,5,1))
fatal("unable to connect");
fatal("Unable to connect to management server.");
if (ndb_cluster_connection->wait_until_ready(30,0) < 0)
fatal("Cluster nodes not ready in 30 seconds.");
ndb = new Ndb(ndb_cluster_connection, _dbname);
if (ndb->init() != 0)
fatal("init");
if (ndb->waitUntilReady(30) < 0)
fatal("waitUntilReady");
dic = ndb->getDictionary();
for (int i = 0; _loops == 0 || i < _loops; i++) {
list(_tabname, (NdbDictionary::Object::Type)_type);
}
delete ndb;
delete ndb_cluster_connection;
return NDBT_ProgramExit(NDBT_OK);
}
......
ndb/tools/restore/consumer_restore.cpp
View file @ ccbadbc9
......@@ -21,7 +21,7 @@ extern FilteredNdbOut err;
extern FilteredNdbOut info;
extern FilteredNdbOut debug;
static void callback(int, NdbConnection*, void*);
static void callback(int, NdbTransaction*, void*);
extern const char * g_connect_string;
bool
......@@ -375,7 +375,8 @@ void BackupRestore::tuple_a(restore_callback_t *cb)
}
// Prepare transaction (the transaction is NOT yet sent to NDB)
cb->connection->executeAsynchPrepare(Commit, &callback, cb);
cb->connection->executeAsynchPrepare(NdbTransaction::Commit,
&callback, cb);
m_transactions++;
return;
}
......@@ -492,7 +493,7 @@ BackupRestore::logEntry(const LogEntry & tup)
if (!m_restore)
return;
NdbConnection * trans = m_ndb->startTransaction();
NdbTransaction * trans = m_ndb->startTransaction();
if (trans == NULL)
{
// Deep shit, TODO: handle the error
......@@ -543,7 +544,7 @@ BackupRestore::logEntry(const LogEntry & tup)
op->setValue(attr->Desc->attrId, dataPtr, length);
}
const int ret = trans->execute(Commit);
const int ret = trans->execute(NdbTransaction::Commit);
if (ret != 0)
{
// Both insert update and delete can fail during log running
......@@ -584,12 +585,12 @@ BackupRestore::endOfLogEntrys()
*
* (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* trans, void* aObject)
callback(int result, NdbTransaction* trans, void* aObject)
{
restore_callback_t *cb = (restore_callback_t *)aObject;
(cb->restore)->cback(result, cb);
......@@ -603,7 +604,7 @@ BackupRestore::tuple(const TupleS & tup)
return;
while (1)
{
NdbConnection * trans = m_ndb->startTransaction();
NdbTransaction * trans = m_ndb->startTransaction();
if (trans == NULL)
{
// Deep shit, TODO: handle the error
......@@ -654,7 +655,7 @@ BackupRestore::tuple(const TupleS & tup)
else
op->setValue(i, dataPtr, length);
}
int ret = trans->execute(Commit);
int ret = trans->execute(NdbTransaction::Commit);
if (ret != 0)
{
ndbout << "execute failed: ";
......
ndb/tools/restore/consumer_restorem.cpp
View file @ ccbadbc9
......@@ -21,8 +21,8 @@ extern FilteredNdbOut err;
extern FilteredNdbOut info;
extern FilteredNdbOut debug;
static bool asynchErrorHandler(NdbConnection * trans, Ndb * ndb);
static void callback(int result, NdbConnection* trans, void* aObject);
static bool asynchErrorHandler(NdbTransaction * trans, Ndb * ndb);
static void callback(int result, NdbTransaction* trans, void* aObject);
bool
BackupRestore::init()
......@@ -371,7 +371,7 @@ BackupRestore::tuple(const TupleS & tup)
return;
while (1)
{
NdbConnection * trans = m_ndb->startTransaction();
NdbTransaction * trans = m_ndb->startTransaction();
if (trans == NULL)
{
// Deep shit, TODO: handle the error
......@@ -460,7 +460,7 @@ BackupRestore::logEntry(const LogEntry & tup)
if (!m_restore)
return;
NdbConnection * trans = m_ndb->startTransaction();
NdbTransaction * trans = m_ndb->startTransaction();
if (trans == NULL)
{
// Deep shit, TODO: handle the error
......@@ -551,7 +551,7 @@ BackupRestore::endOfLogEntrys()
*
******************************************/
static void restoreCallback(int result, // Result for transaction
NdbConnection *object, // Transaction object
NdbTransaction *object, // Transaction object
void *anything) // Not used
{
static Uint32 counter = 0;
......@@ -593,12 +593,12 @@ static void restoreCallback(int result, // Result for transaction
*
* (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* trans, void* aObject)
callback(int result, NdbTransaction* trans, void* aObject)
{
restore_callback_t *cb = (restore_callback_t *)aObject;
(cb->restore)->cback(result, cb);
......@@ -610,7 +610,7 @@ callback(int result, NdbConnection* trans, void* aObject)
* false if it is an error that generates an abort.
*/
static
bool asynchErrorHandler(NdbConnection * trans, Ndb* ndb)
bool asynchErrorHandler(NdbTransaction * trans, Ndb* ndb)
{
NdbError error = trans->getNdbError();
ndb->closeTransaction(trans);
......
ndb/tools/select_all.cpp
View file @ ccbadbc9
......@@ -24,7 +24,6 @@
#include <NdbMain.h>
#include <NDBT.hpp>
#include <NdbSleep.h>
#include <NdbScanFilter.hpp>
int scanReadRecords(Ndb*,
const NdbDictionary::Table*,
......@@ -127,19 +126,21 @@ int main(int argc, char** argv){
Ndb_cluster_connection con(opt_connect_str);
if(con.connect(12, 5, 1) != 0)
{
ndbout << "Unable to connect to management server." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, _dbname );
Ndb MyNdb(&con, _dbname );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
// Connect to Ndb and wait for it to become ready
while(MyNdb.waitUntilReady() != 0)
ndbout << "Waiting for ndb to become ready..." << endl;
// Check if table exists in db
const NdbDictionary::Table* pTab = NDBT_Table::discoverTableFromDb(&MyNdb, _tabname);
const NdbDictionary::Index * pIdx = 0;
......@@ -194,7 +195,7 @@ int scanReadRecords(Ndb* pNdb,
int retryAttempt = 0;
const int retryMax = 100;
int check;
NdbConnection *pTrans;
NdbTransaction *pTrans;
NdbScanOperation *pOp;
NdbIndexScanOperation * pIOp= 0;
......@@ -320,7 +321,7 @@ int scanReadRecords(Ndb* pNdb,
}
}
check = pTrans->execute(NoCommit);
check = pTrans->execute(NdbTransaction::NoCommit);
if( check == -1 ) {
const NdbError err = pTrans->getNdbError();
......
ndb/tools/select_count.cpp
View file @ ccbadbc9
......@@ -100,19 +100,21 @@ int main(int argc, char** argv){
Ndb_cluster_connection con(opt_connect_str);
if(con.connect(12, 5, 1) != 0)
{
ndbout << "Unable to connect to management server." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, _dbname );
Ndb MyNdb(&con, _dbname );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
// Connect to Ndb and wait for it to become ready
while(MyNdb.waitUntilReady() != 0)
ndbout << "Waiting for ndb to become ready..." << endl;
for(int i = 0; i<argc; i++){
// Check if table exists in db
const NdbDictionary::Table * pTab = NDBT_Table::discoverTableFromDb(&MyNdb, argv[i]);
......@@ -141,7 +143,7 @@ select_count(Ndb* pNdb, const NdbDictionary::Table* pTab,
int retryAttempt = 0;
const int retryMax = 100;
int check;
NdbConnection *pTrans;
NdbTransaction *pTrans;
NdbScanOperation *pOp;
while (true){
......@@ -189,7 +191,7 @@ select_count(Ndb* pNdb, const NdbDictionary::Table* pTab,
Uint32 row_size;
pOp->getValue(NdbDictionary::Column::ROW_COUNT, (char*)&tmp);
pOp->getValue(NdbDictionary::Column::ROW_SIZE, (char*)&row_size);
check = pTrans->execute(NoCommit);
check = pTrans->execute(NdbTransaction::NoCommit);
if( check == -1 ) {
ERR(pTrans->getNdbError());
pNdb->closeTransaction(pTrans);
......
sql/ha_ndbcluster.cc
View file @ ccbadbc9
......@@ -154,47 +154,55 @@ static int ndb_to_mysql_error(const NdbError *err)
inline
int execute_no_commit(ha_ndbcluster *h, NdbConnection *trans)
int execute_no_commit(ha_ndbcluster *h, NdbTransaction *trans)
{
int m_batch_execute= 0;
#ifdef NOT_USED
if (m_batch_execute)
return 0;
#endif
return trans->execute(NoCommit,AbortOnError,h->m_force_send);
return trans->execute(NdbTransaction::NoCommit,
NdbTransaction::AbortOnError,
h->m_force_send);
}
inline
int execute_commit(ha_ndbcluster *h, NdbConnection *trans)
int execute_commit(ha_ndbcluster *h, NdbTransaction *trans)
{
int m_batch_execute= 0;
#ifdef NOT_USED
if (m_batch_execute)
return 0;
#endif
return trans->execute(Commit,AbortOnError,h->m_force_send);
return trans->execute(NdbTransaction::Commit,
NdbTransaction::AbortOnError,
h->m_force_send);
}
inline
int execute_commit(THD *thd, NdbConnection *trans)
int execute_commit(THD *thd, NdbTransaction *trans)
{
int m_batch_execute= 0;
#ifdef NOT_USED
if (m_batch_execute)
return 0;
#endif
return trans->execute(Commit,AbortOnError,thd->variables.ndb_force_send);
return trans->execute(NdbTransaction::Commit,
NdbTransaction::AbortOnError,
thd->variables.ndb_force_send);
}
inline
int execute_no_commit_ie(ha_ndbcluster *h, NdbConnection *trans)
int execute_no_commit_ie(ha_ndbcluster *h, NdbTransaction *trans)
{
int m_batch_execute= 0;
#ifdef NOT_USED
if (m_batch_execute)
return 0;
#endif
return trans->execute(NoCommit,AO_IgnoreError,h->m_force_send);
return trans->execute(NdbTransaction::NoCommit,
NdbTransaction::AO_IgnoreError,
h->m_force_send);
}
/*
......@@ -330,7 +338,7 @@ void ha_ndbcluster::no_uncommitted_rows_reset(THD *thd)
*/
int ha_ndbcluster::ndb_err(NdbConnection *trans)
int ha_ndbcluster::ndb_err(NdbTransaction *trans)
{
int res;
const NdbError err= trans->getNdbError();
......@@ -1091,7 +1099,7 @@ int ha_ndbcluster::pk_read(const byte *key, uint key_len, byte *buf)
DBUG_PRINT("enter", ("key_len: %u", key_len));
DBUG_DUMP("key", (char*)key, key_len);
uint no_fields= table->fields, i;
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
NdbOperation *op;
THD *thd= current_thd;
......@@ -1141,7 +1149,7 @@ int ha_ndbcluster::pk_read(const byte *key, uint key_len, byte *buf)
int ha_ndbcluster::complemented_pk_read(const byte *old_data, byte *new_data)
{
uint no_fields= table->fields, i;
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
NdbOperation *op;
THD *thd= current_thd;
DBUG_ENTER("complemented_pk_read");
......@@ -1204,7 +1212,7 @@ int ha_ndbcluster::complemented_pk_read(const byte *old_data, byte *new_data)
int ha_ndbcluster::peek_row()
{
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
NdbOperation *op;
THD *thd= current_thd;
DBUG_ENTER("peek_row");
......@@ -1235,7 +1243,7 @@ int ha_ndbcluster::unique_index_read(const byte *key,
uint key_len, byte *buf)
{
int res;
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
NdbIndexOperation *op;
DBUG_ENTER("ha_ndbcluster::unique_index_read");
DBUG_PRINT("enter", ("key_len: %u, index: %u", key_len, active_index));
......@@ -1271,7 +1279,7 @@ inline int ha_ndbcluster::fetch_next(NdbScanOperation* cursor)
{
DBUG_ENTER("fetch_next");
int check;
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
bool contact_ndb= m_lock.type < TL_WRITE_ALLOW_WRITE;
do {
......@@ -1551,7 +1559,7 @@ int ha_ndbcluster::define_read_attrs(byte* buf, NdbOperation* op)
{
uint i;
THD *thd= current_thd;
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
DBUG_ENTER("define_read_attrs");
......@@ -1598,7 +1606,7 @@ int ha_ndbcluster::ordered_index_scan(const key_range *start_key,
{
int res;
bool restart;
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
NdbIndexScanOperation *op;
DBUG_ENTER("ha_ndbcluster::ordered_index_scan");
......@@ -1668,7 +1676,7 @@ int ha_ndbcluster::filtered_scan(const byte *key, uint key_len,
enum ha_rkey_function find_flag)
{
int res;
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
NdbScanOperation *op;
DBUG_ENTER("filtered_scan");
......@@ -1748,7 +1756,7 @@ int ha_ndbcluster::full_table_scan(byte *buf)
uint i;
int res;
NdbScanOperation *op;
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
DBUG_ENTER("full_table_scan");
DBUG_PRINT("enter", ("Starting new scan on %s", m_tabname));
......@@ -1776,7 +1784,7 @@ int ha_ndbcluster::write_row(byte *record)
{
bool has_auto_increment;
uint i;
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
NdbOperation *op;
int res;
THD *thd= current_thd;
......@@ -1945,7 +1953,7 @@ int ha_ndbcluster::key_cmp(uint keynr, const byte * old_row,
int ha_ndbcluster::update_row(const byte *old_data, byte *new_data)
{
THD *thd= current_thd;
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
NdbScanOperation* cursor= m_active_cursor;
NdbOperation *op;
uint i;
......@@ -2063,7 +2071,7 @@ int ha_ndbcluster::update_row(const byte *old_data, byte *new_data)
int ha_ndbcluster::delete_row(const byte *record)
{
THD *thd= current_thd;
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
NdbScanOperation* cursor= m_active_cursor;
NdbOperation *op;
DBUG_ENTER("delete_row");
......@@ -2635,7 +2643,7 @@ int ha_ndbcluster::rnd_init(bool scan)
int ha_ndbcluster::close_scan()
{
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
DBUG_ENTER("close_scan");
m_multi_cursor= 0;
......@@ -2983,7 +2991,7 @@ int ha_ndbcluster::end_bulk_insert()
// Check if last inserts need to be flushed
if (m_bulk_insert_not_flushed)
{
NdbConnection *trans= m_active_trans;
NdbTransaction *trans= m_active_trans;
// Send rows to NDB
DBUG_PRINT("info", ("Sending inserts to NDB, "\
"rows_inserted:%d, bulk_insert_rows: %d",
......@@ -3102,7 +3110,7 @@ THR_LOCK_DATA **ha_ndbcluster::store_lock(THD *thd,
int ha_ndbcluster::external_lock(THD *thd, int lock_type)
{
int error=0;
NdbConnection* trans= NULL;
NdbTransaction* trans= NULL;
DBUG_ENTER("external_lock");
/*
......@@ -3189,8 +3197,8 @@ int ha_ndbcluster::external_lock(THD *thd, int lock_type)
// m_use_local_query_cache= thd->variables.ndb_use_local_query_cache;
m_active_trans= thd->transaction.all.ndb_tid ?
(NdbConnection*)thd->transaction.all.ndb_tid:
(NdbConnection*)thd->transaction.stmt.ndb_tid;
(NdbTransaction*)thd->transaction.all.ndb_tid:
(NdbTransaction*)thd->transaction.stmt.ndb_tid;
DBUG_ASSERT(m_active_trans);
// Start of transaction
m_retrieve_all_fields= FALSE;
......@@ -3272,13 +3280,13 @@ int ha_ndbcluster::start_stmt(THD *thd)
DBUG_ENTER("start_stmt");
PRINT_OPTION_FLAGS(thd);
NdbConnection *trans= (NdbConnection*)thd->transaction.stmt.ndb_tid;
NdbTransaction *trans= (NdbTransaction*)thd->transaction.stmt.ndb_tid;
if (!trans){
Ndb *ndb= ((Thd_ndb*)thd->transaction.thd_ndb)->ndb;
DBUG_PRINT("trans",("Starting transaction stmt"));
NdbConnection *tablock_trans=
(NdbConnection*)thd->transaction.all.ndb_tid;
NdbTransaction *tablock_trans=
(NdbTransaction*)thd->transaction.all.ndb_tid;
DBUG_PRINT("info", ("tablock_trans: %x", (uint)tablock_trans));
DBUG_ASSERT(tablock_trans);
// trans= ndb->hupp(tablock_trans);
......@@ -3307,7 +3315,7 @@ int ndbcluster_commit(THD *thd, void *ndb_transaction)
{
int res= 0;
Ndb *ndb= ((Thd_ndb*)thd->transaction.thd_ndb)->ndb;
NdbConnection *trans= (NdbConnection*)ndb_transaction;
NdbTransaction *trans= (NdbTransaction*)ndb_transaction;
DBUG_ENTER("ndbcluster_commit");
DBUG_PRINT("transaction",("%s",
......@@ -3337,7 +3345,7 @@ int ndbcluster_rollback(THD *thd, void *ndb_transaction)
{
int res= 0;
Ndb *ndb= ((Thd_ndb*)thd->transaction.thd_ndb)->ndb;
NdbConnection *trans= (NdbConnection*)ndb_transaction;
NdbTransaction *trans= (NdbTransaction*)ndb_transaction;
DBUG_ENTER("ndbcluster_rollback");
DBUG_PRINT("transaction",("%s",
......@@ -3345,7 +3353,7 @@ int ndbcluster_rollback(THD *thd, void *ndb_transaction)
"stmt" : "all"));
DBUG_ASSERT(ndb && trans);
if (trans->execute(Rollback) != 0)
if (trans->execute(NdbTransaction::Rollback) != 0)
{
const NdbError err= trans->getNdbError();
const NdbOperation *error_op= trans->getNdbErrorOperation();
......@@ -4842,7 +4850,7 @@ ndb_get_table_statistics(Ndb* ndb, const char * table,
{
DBUG_ENTER("ndb_get_table_statistics");
DBUG_PRINT("enter", ("table: %s", table));
NdbConnection* pTrans= ndb->startTransaction();
NdbTransaction* pTrans= ndb->startTransaction();
do
{
if (pTrans == NULL)
......@@ -4863,7 +4871,9 @@ ndb_get_table_statistics(Ndb* ndb, const char * table,
pOp->getValue(NdbDictionary::Column::ROW_COUNT, (char*)&rows);
pOp->getValue(NdbDictionary::Column::COMMIT_COUNT, (char*)&commits);
check= pTrans->execute(NoCommit, AbortOnError, TRUE);
check= pTrans->execute(NdbTransaction::NoCommit,
NdbTransaction::AbortOnError,
TRUE);
if (check == -1)
break;
......
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