int CMT_createTableHook(Ndb* ndb,
NdbDictionary::Table& table,
int when,
void* arg)
{
if (when == 0)
{
Uint32 num = ((Uint32*) arg)[0];
Uint32 fragCount = ((Uint32*) arg)[1];
/* Substitute a unique name */
char buf[100];
BaseString::snprintf(buf, sizeof(buf),
"%s_%u",
table.getName(),
num);
table.setName(buf);
if (fragCount > 0)
table.setFragmentCount(fragCount);
ndbout << "Creating " << buf
<< " with fragment count " << fragCount
<< endl;
}
return 0;
}
/*
DBIndex = {
name : "" , // Index name; undefined for PK
isPrimaryKey : true , // true for PK; otherwise undefined
isUnique : true , // true or false
isOrdered : true , // true or false; can scan if true
columnNumbers : [] , // an ordered array of column numbers
};
*/
Handle<Object> GetTableCall::buildDBIndex_PK() {
HandleScope scope;
Local<Object> obj = Object::New();
obj->Set(String::NewSymbol("isPrimaryKey"), Boolean::New(true), ReadOnly);
obj->Set(String::NewSymbol("isUnique"), Boolean::New(true), ReadOnly);
obj->Set(String::NewSymbol("isOrdered"), Boolean::New(false), ReadOnly);
/* Loop over the columns of the key.
Build the "columnNumbers" array and the "record" object, then set both.
*/
int ncol = ndb_table->getNoOfPrimaryKeys();
DEBUG_PRINT("Creating Primary Key Record");
Record * pk_record = new Record(arg0->dict, ncol);
Local<Array> idx_columns = Array::New(ncol);
for(int i = 0 ; i < ncol ; i++) {
const char * col_name = ndb_table->getPrimaryKey(i);
const NdbDictionary::Column * col = ndb_table->getColumn(col_name);
pk_record->addColumn(col);
idx_columns->Set(i, v8::Int32::New(col->getColumnNo()));
}
pk_record->completeTableRecord(ndb_table);
obj->Set(String::NewSymbol("columnNumbers"), idx_columns);
obj->Set(String::NewSymbol("record"), Record_Wrapper(pk_record), ReadOnly);
return scope.Close(obj);
}
int
runDDL(NDBT_Context* ctx, NDBT_Step* step){
Ndb* pNdb= GETNDB(step);
NdbDictionary::Dictionary* pDict = pNdb->getDictionary();
const int tables = NDBT_Tables::getNumTables();
while(!ctx->isTestStopped())
{
const int tab_no = rand() % (tables);
NdbDictionary::Table tab = *NDBT_Tables::getTable(tab_no);
BaseString name= tab.getName();
name.appfmt("-%d", step->getStepNo());
tab.setName(name.c_str());
if(pDict->createTable(tab) == 0)
{
HugoTransactions hugoTrans(* pDict->getTable(name.c_str()));
if (hugoTrans.loadTable(pNdb, 10000) != 0){
return NDBT_FAILED;
}
while(pDict->dropTable(tab.getName()) != 0 &&
pDict->getNdbError().code != 4009)
g_err << pDict->getNdbError() << endl;
sleep(1);
}
}
return NDBT_OK;
}
int
NDBT_TestSuite::createHook(Ndb* ndb, NdbDictionary::Table& tab, int when)
{
if (when == 0) {
if (diskbased)
{
for (int i = 0; i < tab.getNoOfColumns(); i++)
{
NdbDictionary::Column* col = tab.getColumn(i);
if (! col->getPrimaryKey())
{
col->setStorageType(NdbDictionary::Column::StorageTypeDisk);
}
}
}
else if (temporaryTables)
{
tab.setTemporary(true);
tab.setLogging(false);
}
if (tsname != NULL) {
tab.setTablespaceName(tsname);
}
}
return 0;
}
/*
DBIndex = {
name : "" , // Index name
isPrimaryKey : true , // true for PK; otherwise undefined
isUnique : true , // true or false
isOrdered : true , // true or false; can scan if true
columnNumbers : [] , // an ordered array of column numbers
};
*/
Handle<Object> GetTableCall::buildDBIndex_PK() {
EscapableHandleScope scope(isolate);
Local<Object> obj = Object::New(isolate);
SET_RO_PROPERTY(obj, SYMBOL(isolate, "name"), String::NewFromUtf8(isolate, "PRIMARY_KEY"));
SET_RO_PROPERTY(obj, SYMBOL(isolate, "isPrimaryKey"), Boolean::New(isolate, true));
SET_RO_PROPERTY(obj, SYMBOL(isolate, "isUnique"), Boolean::New(isolate, true));
SET_RO_PROPERTY(obj, SYMBOL(isolate, "isOrdered"), Boolean::New(isolate, false));
/* Loop over the columns of the key.
Build the "columnNumbers" array and the "record" object, then set both.
*/
int ncol = ndb_table->getNoOfPrimaryKeys();
DEBUG_PRINT("Creating Primary Key Record");
Record * pk_record = new Record(dict, ncol);
Local<Array> idx_columns = Array::New(isolate, ncol);
for(int i = 0 ; i < ncol ; i++) {
const char * col_name = ndb_table->getPrimaryKey(i);
const NdbDictionary::Column * col = ndb_table->getColumn(col_name);
pk_record->addColumn(col);
idx_columns->Set(i, v8::Int32::New(isolate, col->getColumnNo()));
}
pk_record->completeTableRecord(ndb_table);
obj->Set(SYMBOL(isolate, "columnNumbers"), idx_columns);
SET_RO_PROPERTY(obj, SYMBOL(isolate, "record"), Record_Wrapper(pk_record));
return scope.Escape(obj);
}
int
create_table(){
NdbDictionary::Dictionary* dict = g_ndb->getDictionary();
assert(dict);
if(g_paramters[P_CREATE].value){
g_ndb->getDictionary()->dropTable(g_tablename);
const NdbDictionary::Table * pTab = NDBT_Tables::getTable(g_tablename);
assert(pTab);
NdbDictionary::Table copy = * pTab;
copy.setLogging(false);
if(dict->createTable(copy) != 0){
g_err << "Failed to create table: " << g_tablename << endl;
return -1;
}
NdbDictionary::Index x(g_indexname);
x.setTable(g_tablename);
x.setType(NdbDictionary::Index::OrderedIndex);
x.setLogging(false);
for (unsigned k = 0; k < copy.getNoOfColumns(); k++){
if(copy.getColumn(k)->getPrimaryKey()){
x.addColumnName(copy.getColumn(k)->getName());
}
}
if(dict->createIndex(x) != 0){
g_err << "Failed to create index: " << endl;
return -1;
}
}
g_table = dict->getTable(g_tablename);
g_index = dict->getIndex(g_indexname, g_tablename);
assert(g_table);
assert(g_index);
if(g_paramters[P_CREATE].value)
{
int rows = g_paramters[P_ROWS].value;
HugoTransactions hugoTrans(* g_table);
if (hugoTrans.loadTable(g_ndb, rows)){
g_err.println("Failed to load %s with %d rows",
g_table->getName(), rows);
return -1;
}
}
return 0;
}
void GetTableCall::run() {
DEBUG_PRINT("GetTableCall::run() [%s.%s]", arg1, arg2);
NdbDictionary::Dictionary * dict;
return_val = -1;
if(strlen(arg1)) {
arg0->ndb->setDatabaseName(arg1);
}
dict = arg0->ndb->getDictionary();
ndb_table = dict->getTable(arg2);
if(ndb_table) {
return_val = dict->listIndexes(idx_list, arg2);
}
if(return_val == 0) {
/* Fetch the indexes now. These calls may perform network IO, populating
the (connection) global and (Ndb) local dictionary caches. Later,
in the JavaScript main thread, we will call getIndex() again knowing
that the caches are populated.
*/
for(unsigned int i = 0 ; i < idx_list.count ; i++) {
const NdbDictionary::Index * idx = dict->getIndex(idx_list.elements[i].name, arg2);
/* It is possible to get an index for a recently dropped table rather
than the desired table. This is a known bug likely to be fixed later.
*/
if(ndb_table->getObjectVersion() !=
dict->getTable(idx->getTable())->getObjectVersion())
{
dict->invalidateIndex(idx);
idx = dict->getIndex(idx_list.elements[i].name, arg2);
}
}
}
}
Handle<Object> GetTableCall::buildDBIndex(const NdbDictionary::Index *idx) {
HandleScope scope;
Local<Object> obj = NdbDictIndexEnv.newWrapper();
wrapPointerInObject(idx, NdbDictIndexEnv, obj);
obj->Set(String::NewSymbol("name"), String::New(idx->getName()));
obj->Set(String::NewSymbol("isUnique"),
Boolean::New(idx->getType() == NdbDictionary::Index::UniqueHashIndex),
ReadOnly);
obj->Set(String::NewSymbol("isOrdered"),
Boolean::New(idx->getType() == NdbDictionary::Index::OrderedIndex),
ReadOnly);
/* Loop over the columns of the key.
Build the "columns" array and the "record" object, then set both.
*/
int ncol = idx->getNoOfColumns();
Local<Array> idx_columns = Array::New(ncol);
DEBUG_PRINT("Creating Index Record (%s)", idx->getName());
Record * idx_record = new Record(arg0->dict, ncol);
for(int i = 0 ; i < ncol ; i++) {
const char *colName = idx->getColumn(i)->getName();
const NdbDictionary::Column *col = ndb_table->getColumn(colName);
idx_columns->Set(i, v8::Int32::New(col->getColumnNo()));
idx_record->addColumn(col);
}
idx_record->completeIndexRecord(idx);
obj->Set(String::NewSymbol("record"), Record_Wrapper(idx_record), ReadOnly);
obj->Set(String::NewSymbol("columnNumbers"), idx_columns);
return scope.Close(obj);
}
Handle<Object> GetTableCall::buildDBIndex(const NdbDictionary::Index *idx) {
EscapableHandleScope scope(isolate);
Local<Object> obj = NdbDictIndexEnv.newWrapper();
wrapPointerInObject(idx, NdbDictIndexEnv, obj);
SET_RO_PROPERTY(obj, SYMBOL(isolate, "name"), String::NewFromUtf8(isolate, idx->getName()));
SET_RO_PROPERTY(obj, SYMBOL(isolate, "isPrimaryKey"), Boolean::New(isolate, false));
SET_RO_PROPERTY(obj, SYMBOL(isolate, "isUnique"),
Boolean::New(isolate, idx->getType() == NdbDictionary::Index::UniqueHashIndex));
SET_RO_PROPERTY(obj, SYMBOL(isolate, "isOrdered"),
Boolean::New(isolate, idx->getType() == NdbDictionary::Index::OrderedIndex));
/* Loop over the columns of the key.
Build the "columns" array and the "record" object, then set both.
*/
int ncol = idx->getNoOfColumns();
Local<Array> idx_columns = Array::New(isolate, ncol);
DEBUG_PRINT("Creating Index Record (%s)", idx->getName());
Record * idx_record = new Record(dict, ncol);
for(int i = 0 ; i < ncol ; i++) {
const char *colName = idx->getColumn(i)->getName();
const NdbDictionary::Column *col = ndb_table->getColumn(colName);
idx_columns->Set(i, v8::Int32::New(isolate, col->getColumnNo()));
idx_record->addColumn(col);
}
idx_record->completeIndexRecord(idx);
SET_RO_PROPERTY(obj, SYMBOL(isolate, "record"), Record_Wrapper(idx_record));
obj->Set(SYMBOL(isolate, "columnNumbers"), idx_columns);
return scope.Escape(obj);
}
static int
g_create_hook(Ndb* ndb, NdbDictionary::Table& tab, int when, void* arg)
{
if (when == 0) {
if (g_diskbased) {
for (int i = 0; i < tab.getNoOfColumns(); i++) {
NdbDictionary::Column* col = tab.getColumn(i);
if (! col->getPrimaryKey()) {
col->setStorageType(NdbDictionary::Column::StorageTypeDisk);
}
}
}
if (g_tsname != NULL) {
tab.setTablespaceName(g_tsname);
}
}
return 0;
}
int
create_table() {
NdbDictionary::Dictionary* dict = g_ndb->getDictionary();
assert(dict);
if(g_paramters[P_CREATE].value) {
const NdbDictionary::Table * pTab = NDBT_Tables::getTable(g_table);
assert(pTab);
NdbDictionary::Table copy = * pTab;
copy.setLogging(false);
if(dict->createTable(copy) != 0) {
g_err << "Failed to create table: " << g_table << endl;
return -1;
}
NdbDictionary::Index x(g_ordered);
x.setTable(g_table);
x.setType(NdbDictionary::Index::OrderedIndex);
x.setLogging(false);
for (unsigned k = 0; k < copy.getNoOfColumns(); k++) {
if(copy.getColumn(k)->getPrimaryKey()) {
x.addColumn(copy.getColumn(k)->getName());
}
}
if(dict->createIndex(x) != 0) {
g_err << "Failed to create index: " << endl;
return -1;
}
x.setName(g_unique);
x.setType(NdbDictionary::Index::UniqueHashIndex);
if(dict->createIndex(x) != 0) {
g_err << "Failed to create index: " << endl;
return -1;
}
}
g_tab = dict->getTable(g_table);
g_i_unique = dict->getIndex(g_unique, g_table);
g_i_ordered = dict->getIndex(g_ordered, g_table);
assert(g_tab);
assert(g_i_unique);
assert(g_i_ordered);
return 0;
}
NDBT_ResultRow::NDBT_ResultRow(const NdbDictionary::Table& tab,
char attrib_delimiter)
: cols(0), names(NULL), data(NULL), m_ownData(false), m_table(tab)
{
ad[0] = attrib_delimiter;
ad[1] = 0;
if (tab.getObjectStatus() == NdbDictionary::Object::Retrieved)
{
cols = tab.getNoOfColumns();
names = new char * [cols];
data = new NdbRecAttr * [cols];
for(int i = 0; i<cols; i++){
names[i] = new char[255];
strcpy(names[i], tab.getColumn(i)->getName());
}
}
}
int create100Tables(NDBT_Context* ctx, NDBT_Step* step)
{
Ndb* pNdb = GETNDB(step);
const NdbDictionary::Table* pTab= ctx->getTab();
/* Run as a 'T1' testcase - do nothing for other tables */
if (strcmp(pTab->getName(), "T1") != 0)
return NDBT_OK;
for (Uint32 t=0; t < 100; t++)
{
char tabnameBuff[10];
snprintf(tabnameBuff, sizeof(tabnameBuff), "TAB%u", t);
NdbDictionary::Table tab;
tab.setName(tabnameBuff);
NdbDictionary::Column pk;
pk.setName("PK");
pk.setType(NdbDictionary::Column::Varchar);
pk.setLength(20);
pk.setNullable(false);
pk.setPrimaryKey(true);
tab.addColumn(pk);
pNdb->getDictionary()->dropTable(tab.getName());
if(pNdb->getDictionary()->createTable(tab) != 0)
{
ndbout << "Create table failed with error : "
<< pNdb->getDictionary()->getNdbError().code
<< " "
<< pNdb->getDictionary()->getNdbError().message
<< endl;
return NDBT_FAILED;
}
ndbout << "Created table " << tabnameBuff << endl;
}
return NDBT_OK;
}
const NdbDictionary::Table*
NDBT_Tables::tableWithPkSize(const char* _nam, Uint32 pkSize){
NdbDictionary::Table* tab = new NdbDictionary::Table(_nam);
// Add one PK of the desired length
tab->addColumn(NDBT_Attribute("PK1",
NdbDictionary::Column::Char,
pkSize,
true));
// Add 4 attributes
tab->addColumn(NDBT_Attribute("ATTR1",
NdbDictionary::Column::Char,
21));
tab->addColumn(NDBT_Attribute("ATTR2",
NdbDictionary::Column::Char,
124));
tab->addColumn(NDBT_Attribute("ATTR3",
NdbDictionary::Column::Unsigned));
tab->addColumn(NDBT_Attribute("ATTR4",
NdbDictionary::Column::Unsigned));
return tab;
}
/*
* ForeignKeyMetadata = {
name : "" , // Constraint name
columnNames : null , // an ordered array of column numbers
targetTable : "" , // referenced table name
targetDatabase : "" , // referenced database name
targetColumnNames: null , // an ordered array of target column names
};
*/
Handle<Object> GetTableCall::buildDBForeignKey(const NdbDictionary::ForeignKey *fk) {
HandleScope scope;
DictionaryNameSplitter localSplitter;
Local<Object> js_fk = Object::New();
localSplitter.splitName(fk->getName()); // e.g. "12/20/fkname"
js_fk->Set(String::NewSymbol("name"), String::New(localSplitter.part3));
// get child column names
unsigned int childColumnCount = fk->getChildColumnCount();
Local<Array> fk_child_column_names = Array::New(childColumnCount);
for (unsigned i = 0; i < childColumnCount; ++i) {
int columnNumber = fk->getChildColumnNo(i);
const NdbDictionary::Column * column = ndb_table->getColumn(columnNumber);
fk_child_column_names->Set(i, String::New(column->getName()));
}
js_fk->Set(String::NewSymbol("columnNames"), fk_child_column_names);
// get parent table (which might be in a different database)
const char * fk_parent_name = fk->getParentTable();
localSplitter.splitName(fk_parent_name);
const char * parent_db_name = localSplitter.part1;
const char * parent_table_name = localSplitter.part3;
js_fk->Set(String::NewSymbol("targetTable"), String::New(parent_table_name));
js_fk->Set(String::NewSymbol("targetDatabase"), String::New(parent_db_name));
ndb->setDatabaseName(parent_db_name);
const NdbDictionary::Table * parent_table = dict->getTable(parent_table_name);
ndb->setDatabaseName(dbName);
// get parent column names
unsigned int parentColumnCount = fk->getParentColumnCount();
Local<Array> fk_parent_column_names = Array::New(parentColumnCount);
for (unsigned i = 0; i < parentColumnCount; ++i) {
int columnNumber = fk->getParentColumnNo(i);
const NdbDictionary::Column * column = parent_table->getColumn(columnNumber);
fk_parent_column_names->Set(i, String::New( column->getName()));
}
js_fk->Set(String::NewSymbol("targetColumnNames"), fk_parent_column_names);
return scope.Close(js_fk);
}
static
int
dropEvent(Ndb *pNdb, const NdbDictionary::Table &tab)
{
char eventName[1024];
sprintf(eventName,"%s_EVENT",tab.getName());
NdbDictionary::Dictionary *myDict = pNdb->getDictionary();
if (!myDict) {
g_err << "Dictionary not found "
<< pNdb->getNdbError().code << " "
<< pNdb->getNdbError().message << endl;
return NDBT_FAILED;
}
if (myDict->dropEvent(eventName)) {
g_err << "Failed to drop event: "
<< myDict->getNdbError().code << " : "
<< myDict->getNdbError().message << endl;
return NDBT_FAILED;
}
return NDBT_OK;
}
/* doAsyncCallback() runs in the main thread. We don't want it to block.
TODO: verify whether any IO is done
by checking WaitMetaRequestCount at the start and end.
*/
void GetTableCall::doAsyncCallback(Local<Object> ctx) {
const char *ndbTableName;
EscapableHandleScope scope(isolate);
DEBUG_PRINT("GetTableCall::doAsyncCallback: return_val %d", return_val);
/* User callback arguments */
Handle<Value> cb_args[2];
cb_args[0] = Null(isolate);
cb_args[1] = Null(isolate);
/* TableMetadata = {
database : "" , // Database name
name : "" , // Table Name
columns : [] , // ordered array of DBColumn objects
indexes : [] , // array of DBIndex objects
partitionKey : [] , // ordered array of column numbers in the partition key
sparseContainer : null // default column for sparse fields
};
*/
if(ndb_table && ! return_val) {
Local<Object> table = NdbDictTableEnv.wrap(ndb_table)->ToObject();
// database
table->Set(SYMBOL(isolate, "database"), String::NewFromUtf8(isolate, arg1));
// name
ndbTableName = ndb_table->getName();
table->Set(SYMBOL(isolate, "name"), String::NewFromUtf8(isolate, ndbTableName));
// partitionKey
int nPartitionKeys = 0;
Handle<Array> partitionKeys = Array::New(isolate);
table->Set(SYMBOL(isolate, "partitionKey"), partitionKeys);
// sparseContainer
table->Set(SYMBOL(isolate,"sparseContainer"), Null(isolate));
// columns
Local<Array> columns = Array::New(isolate, ndb_table->getNoOfColumns());
for(int i = 0 ; i < ndb_table->getNoOfColumns() ; i++) {
const NdbDictionary::Column *ndb_col = ndb_table->getColumn(i);
Handle<Object> col = buildDBColumn(ndb_col);
columns->Set(i, col);
if(ndb_col->getPartitionKey()) { /* partition key */
partitionKeys->Set(nPartitionKeys++, String::NewFromUtf8(isolate, ndb_col->getName()));
}
if( ! strcmp(ndb_col->getName(), "SPARSE_FIELDS")
&& ( (! strncmp(getColumnType(ndb_col), "VARCHAR", 7)
&& (getEncoderCharsetForColumn(ndb_col)->isUnicode))
|| ( ! strncmp(getColumnType(ndb_col), "VARBINARY", 9)
|| ! strncmp(getColumnType(ndb_col), "JSON", 4))))
{
table->Set(SYMBOL(isolate,"sparseContainer"),
String::NewFromUtf8(isolate, ndb_col->getName()));
}
}
table->Set(SYMBOL(isolate, "columns"), columns);
// indexes (primary key & secondary)
Local<Array> js_indexes = Array::New(isolate, idx_list.count + 1);
js_indexes->Set(0, buildDBIndex_PK()); // primary key
for(unsigned int i = 0 ; i < idx_list.count ; i++) { // secondary indexes
const NdbDictionary::Index * idx =
dict->getIndex(idx_list.elements[i].name, arg2);
js_indexes->Set(i+1, buildDBIndex(idx));
}
SET_RO_PROPERTY(table, SYMBOL(isolate, "indexes"), js_indexes);
// foreign keys (only foreign keys for which this table is the child)
// now create the javascript foreign key metadata objects for dictionary objects cached earlier
Local<Array> js_fks = Array::New(isolate, fk_count);
int fk_number = 0;
for(unsigned int i = 0 ; i < fk_list.count ; i++) {
NdbDictionary::ForeignKey fk;
if (fk_list.elements[i].type == NdbDictionary::Object::ForeignKey) {
const char * fk_name = fk_list.elements[i].name;
int fkGetCode = dict->getForeignKey(fk, fk_name);
DEBUG_PRINT("getForeignKey for %s returned %i", fk_name, fkGetCode);
// see if the foreign key child table is this table
if(splitNameMatchesDbAndTable(fk.getChildTable())) {
// the foreign key child table is this table; build the fk object
DEBUG_PRINT("Adding foreign key for %s at %i", fk.getName(), fk_number);
js_fks->Set(fk_number++, buildDBForeignKey(&fk));
}
}
}
SET_RO_PROPERTY(table, SYMBOL(isolate, "foreignKeys"), js_fks);
// Autoincrement Cache Impl (also not part of spec)
if(per_table_ndb) {
table->Set(SYMBOL(isolate, "per_table_ndb"), Ndb_Wrapper(per_table_ndb));
}
// User Callback
cb_args[1] = table;
}
else {
cb_args[0] = NdbError_Wrapper(* ndbError);
}
ToLocal(& callback)->Call(ctx, 2, cb_args);
}
static
int
createEvent(Ndb *pNdb,
const NdbDictionary::Table &tab,
bool merge_events = true,
bool report = true)
{
char eventName[1024];
sprintf(eventName,"%s_EVENT",tab.getName());
NdbDictionary::Dictionary *myDict = pNdb->getDictionary();
if (!myDict) {
g_err << "Dictionary not found "
<< pNdb->getNdbError().code << " "
<< pNdb->getNdbError().message << endl;
return NDBT_FAILED;
}
myDict->dropEvent(eventName);
NdbDictionary::Event myEvent(eventName);
myEvent.setTable(tab.getName());
myEvent.addTableEvent(NdbDictionary::Event::TE_ALL);
for(int a = 0; a < tab.getNoOfColumns(); a++) {
myEvent.addEventColumn(a);
}
myEvent.mergeEvents(merge_events);
if (report)
myEvent.setReport(NdbDictionary::Event::ER_SUBSCRIBE);
int res = myDict->createEvent(myEvent); // Add event to database
if (res == 0)
myEvent.print();
else if (myDict->getNdbError().classification ==
NdbError::SchemaObjectExists)
{
g_info << "Event creation failed event exists\n";
res = myDict->dropEvent(eventName);
if (res) {
g_err << "Failed to drop event: "
<< myDict->getNdbError().code << " : "
<< myDict->getNdbError().message << endl;
return NDBT_FAILED;
}
// try again
res = myDict->createEvent(myEvent); // Add event to database
if (res) {
g_err << "Failed to create event (1): "
<< myDict->getNdbError().code << " : "
<< myDict->getNdbError().message << endl;
return NDBT_FAILED;
}
}
else
{
g_err << "Failed to create event (2): "
<< myDict->getNdbError().code << " : "
<< myDict->getNdbError().message << endl;
return NDBT_FAILED;
}
return NDBT_OK;
}
int
create_table(){
NdbDictionary::Dictionary* dict = g_ndb->getDictionary();
assert(dict);
if(g_paramters[P_CREATE].value){
g_ndb->getDictionary()->dropTable(g_tablename);
const NdbDictionary::Table * pTab = NDBT_Tables::getTable(g_tablename);
assert(pTab);
NdbDictionary::Table copy = * pTab;
copy.setLogging(false);
if(dict->createTable(copy) != 0){
g_err << "Failed to create table: " << g_tablename << endl;
return -1;
}
NdbDictionary::Index x(g_indexname);
x.setTable(g_tablename);
x.setType(NdbDictionary::Index::OrderedIndex);
x.setLogging(false);
for (unsigned k = 0; k < (unsigned) copy.getNoOfColumns(); k++){
if(copy.getColumn(k)->getPrimaryKey()){
x.addColumnName(copy.getColumn(k)->getName());
}
}
if(dict->createIndex(x) != 0){
g_err << "Failed to create index: " << endl;
return -1;
}
}
g_table = dict->getTable(g_tablename);
g_index = dict->getIndex(g_indexname, g_tablename);
assert(g_table);
assert(g_index);
/* Obtain NdbRecord instances for the table and index */
{
NdbDictionary::RecordSpecification spec[ NDB_MAX_ATTRIBUTES_IN_TABLE ];
Uint32 offset=0;
Uint32 cols= g_table->getNoOfColumns();
for (Uint32 colNum=0; colNum<cols; colNum++)
{
const NdbDictionary::Column* col= g_table->getColumn(colNum);
Uint32 colLength= col->getLength();
spec[colNum].column= col;
spec[colNum].offset= offset;
offset+= colLength;
spec[colNum].nullbit_byte_offset= offset++;
spec[colNum].nullbit_bit_in_byte= 0;
}
g_table_record= dict->createRecord(g_table,
&spec[0],
cols,
sizeof(NdbDictionary::RecordSpecification));
assert(g_table_record);
}
{
NdbDictionary::RecordSpecification spec[ NDB_MAX_ATTRIBUTES_IN_TABLE ];
Uint32 offset=0;
Uint32 cols= g_index->getNoOfColumns();
for (Uint32 colNum=0; colNum<cols; colNum++)
{
/* Get column from the underlying table */
// TODO : Add this mechanism to dict->createRecord
// TODO : Add NdbRecord queryability methods so that an NdbRecord can
// be easily built and later used to read out data.
const NdbDictionary::Column* col=
g_table->getColumn(g_index->getColumn(colNum)->getName());
Uint32 colLength= col->getLength();
spec[colNum].column= col;
spec[colNum].offset= offset;
offset+= colLength;
spec[colNum].nullbit_byte_offset= offset++;
spec[colNum].nullbit_bit_in_byte= 0;
}
g_index_record= dict->createRecord(g_index,
&spec[0],
cols,
sizeof(NdbDictionary::RecordSpecification));
assert(g_index_record);
}
if(g_paramters[P_CREATE].value)
{
int rows = g_paramters[P_ROWS].value;
HugoTransactions hugoTrans(* g_table);
if (hugoTrans.loadTable(g_ndb, rows)){
g_err.println("Failed to load %s with %d rows",
g_table->getName(), rows);
return -1;
}
}
return 0;
}
int main(int argc, const char** argv){
ndb_init();
int _help = 0;
int _p = 0;
const char * db = "TEST_DB";
const char* _connectstr = NULL;
struct getargs args[] = {
{ "database", 'd', arg_string, &db, "database", 0 },
{ "connstr", 'c', arg_string, &_connectstr, "Connect string", "cs" },
{ "partitions", 'p', arg_integer, &_p, "New no of partitions", 0},
{ "usage", '?', arg_flag, &_help, "Print help", "" }
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0;
char desc[] =
"tabname\n" \
"This program will alter no of partitions of table in Ndb.\n";
if(getarg(args, num_args, argc, argv, &optind) || _help){
arg_printusage(args, num_args, argv[0], desc);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
if(argv[optind] == NULL)
{
arg_printusage(args, num_args, argv[0], desc);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
// Connect to Ndb
Ndb_cluster_connection con(_connectstr);
if(con.connect(12, 5, 1) != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, db );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
while(MyNdb.waitUntilReady() != 0)
ndbout << "Waiting for ndb to become ready..." << endl;
NdbDictionary::Dictionary* MyDic = MyNdb.getDictionary();
for (int i = optind; i<argc; i++)
{
printf("altering %s/%s...", db, argv[i]);
const NdbDictionary::Table* oldTable = MyDic->getTable(argv[i]);
if (oldTable == 0)
{
ndbout << "Failed to retrieve table " << argv[i]
<< ": " << MyDic->getNdbError() << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
NdbDictionary::Table newTable = *oldTable;
newTable.setFragmentCount(_p);
if (MyDic->beginSchemaTrans() != 0)
goto err;
if (MyDic->prepareHashMap(*oldTable, newTable) != 0)
goto err;
if (MyDic->alterTable(*oldTable, newTable) != 0)
goto err;
if (MyDic->endSchemaTrans())
goto err;
ndbout_c("done");
}
return NDBT_ProgramExit(NDBT_OK);
err:
NdbError err = MyDic->getNdbError();
if (MyDic->hasSchemaTrans())
MyDic->endSchemaTrans(NdbDictionary::Dictionary::SchemaTransAbort);
ndbout << "Failed! "
<< err << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
void GetTableCall::run() {
DEBUG_PRINT("GetTableCall::run() [%s.%s]", arg1, arg2);
return_val = -1;
/* dbName is optional; if not present, set it from ndb database name */
if(strlen(dbName)) {
ndb->setDatabaseName(dbName);
} else {
dbName = ndb->getDatabaseName();
}
dict = ndb->getDictionary();
ndb_table = dict->getTable(tableName);
if(ndb_table) {
/* Ndb object used to create NdbRecords and to cache auto-increment values */
per_table_ndb = new Ndb(& ndb->get_ndb_cluster_connection());
DEBUG_PRINT("per_table_ndb %s.%s %p\n", dbName, tableName, per_table_ndb);
per_table_ndb->init();
/* List the indexes */
return_val = dict->listIndexes(idx_list, tableName);
}
if(return_val == 0) {
/* Fetch the indexes now. These calls may perform network IO, populating
the (connection) global and (Ndb) local dictionary caches. Later,
in the JavaScript main thread, we will call getIndex() again knowing
that the caches are populated.
*/
for(unsigned int i = 0 ; i < idx_list.count ; i++) {
const NdbDictionary::Index * idx = dict->getIndex(idx_list.elements[i].name, tableName);
/* It is possible to get an index for a recently dropped table rather
than the desired table. This is a known bug likely to be fixed later.
*/
const char * idx_table_name = idx->getTable();
const NdbDictionary::Table * idx_table = dict->getTable(idx_table_name);
if(idx_table == 0 || idx_table->getObjectVersion() != ndb_table->getObjectVersion())
{
dict->invalidateIndex(idx);
idx = dict->getIndex(idx_list.elements[i].name, tableName);
}
}
}
else {
DEBUG_PRINT("listIndexes() returned %i", return_val);
ndbError = & dict->getNdbError();
return;
}
/* List the foreign keys and keep the list around for doAsyncCallback to create js objects
* Currently there is no listForeignKeys so we use the more generic listDependentObjects
* specifying the table metadata object.
*/
return_val = dict->listDependentObjects(fk_list, *ndb_table);
if (return_val == 0) {
/* Fetch the foreign keys and associated parent tables now.
* These calls may perform network IO, populating
* the (connection) global and (Ndb) local dictionary caches. Later,
* in the JavaScript main thread, we will call getForeignKey() again knowing
* that the caches are populated.
* We only care about foreign keys where this table is the child table, not the parent table.
*/
for(unsigned int i = 0 ; i < fk_list.count ; i++) {
NdbDictionary::ForeignKey fk;
if (fk_list.elements[i].type == NdbDictionary::Object::ForeignKey) {
const char * fk_name = fk_list.elements[i].name;
int fkGetCode = dict->getForeignKey(fk, fk_name);
DEBUG_PRINT("getForeignKey for %s returned %i", fk_name, fkGetCode);
// see if the foreign key child table is this table
if(splitNameMatchesDbAndTable(fk.getChildTable())) {
// the foreign key child table is this table; get the parent table
++fk_count;
DEBUG_PRINT("Getting ParentTable");
splitter.splitName(fk.getParentTable());
ndb->setDatabaseName(splitter.part1); // temp for next call
const NdbDictionary::Table * parent_table = dict->getTable(splitter.part3);
ndb->setDatabaseName(dbName); // back to expected value
DEBUG_PRINT("Parent table getTable returned %s", parent_table->getName());
}
}
}
}
else {
DEBUG_PRINT("listDependentObjects() returned %i", return_val);
ndbError = & dict->getNdbError();
}
}
/* doAsyncCallback() runs in the main thread. We don't want it to block.
TODO: verify whether any IO is done
by checking WaitMetaRequestCount at the start and end.
*/
void GetTableCall::doAsyncCallback(Local<Object> ctx) {
const char *tableName;
HandleScope scope;
DEBUG_PRINT("GetTableCall::doAsyncCallback: return_val %d", return_val);
/* User callback arguments */
Handle<Value> cb_args[2];
cb_args[0] = Null();
cb_args[1] = Null();
/* TableMetadata = {
database : "" , // Database name
name : "" , // Table Name
columns : [] , // ordered array of DBColumn objects
indexes : [] , // array of DBIndex objects
partitionKey : [] , // ordered array of column numbers in the partition key
};
*/
if(ndb_table && ! return_val) {
Local<Object> table = NdbDictTableEnv.newWrapper();
const NdbDictionary::Table * js_ndb_table = ndb_table;
wrapPointerInObject(js_ndb_table, NdbDictTableEnv, table);
// database
table->Set(String::NewSymbol("database"), String::New(arg1));
// name
tableName = ndb_table->getName();
table->Set(String::NewSymbol("name"), String::New(tableName));
// partitionKey
int nPartitionKeys = 0;
Handle<Array> partitionKeys = Array::New();
table->Set(String::NewSymbol("partitionKey"), partitionKeys);
// columns
Local<Array> columns = Array::New(ndb_table->getNoOfColumns());
for(int i = 0 ; i < ndb_table->getNoOfColumns() ; i++) {
const NdbDictionary::Column *ndb_col = ndb_table->getColumn(i);
Handle<Object> col = buildDBColumn(ndb_col);
columns->Set(i, col);
if(ndb_col->getPartitionKey()) { /* partition key */
partitionKeys->Set(nPartitionKeys++, String::New(ndb_col->getName()));
}
}
table->Set(String::NewSymbol("columns"), columns);
// indexes (primary key & secondary)
Local<Array> js_indexes = Array::New(idx_list.count + 1);
js_indexes->Set(0, buildDBIndex_PK()); // primary key
for(unsigned int i = 0 ; i < idx_list.count ; i++) { // secondary indexes
const NdbDictionary::Index * idx =
dict->getIndex(idx_list.elements[i].name, arg2);
js_indexes->Set(i+1, buildDBIndex(idx));
}
table->Set(String::NewSymbol("indexes"), js_indexes, ReadOnly);
// Table Record (implementation artifact; not part of spec)
DEBUG_PRINT("Creating Table Record");
Record * rec = new Record(dict, ndb_table->getNoOfColumns());
for(int i = 0 ; i < ndb_table->getNoOfColumns() ; i++) {
rec->addColumn(ndb_table->getColumn(i));
}
rec->completeTableRecord(ndb_table);
table->Set(String::NewSymbol("record"), Record_Wrapper(rec));
// foreign keys (only foreign keys for which this table is the child)
// now create the javascript foreign key metadata objects for dictionary objects cached earlier
Local<Array> js_fks = Array::New(fk_count);
int fk_number = 0;
for(unsigned int i = 0 ; i < fk_list.count ; i++) {
NdbDictionary::ForeignKey fk;
if (fk_list.elements[i].type == NdbDictionary::Object::ForeignKey) {
const char * fk_name = fk_list.elements[i].name;
int fkGetCode = dict->getForeignKey(fk, fk_name);
DEBUG_PRINT("getForeignKey for %s returned %i", fk_name, fkGetCode);
// see if the foreign key child table is this table
if(splitNameMatchesDbAndTable(fk.getChildTable())) {
// the foreign key child table is this table; build the fk object
DEBUG_PRINT("Adding foreign key for %s at %i", fk.getName(), fk_number);
js_fks->Set(fk_number++, buildDBForeignKey(&fk));
}
}
}
table->Set(String::NewSymbol("foreignKeys"), js_fks, ReadOnly);
// Autoincrement Cache Impl (also not part of spec)
if(per_table_ndb) {
table->Set(String::NewSymbol("per_table_ndb"), Ndb_Wrapper(per_table_ndb));
}
// User Callback
cb_args[1] = table;
}
else {
cb_args[0] = NdbError_Wrapper(* ndbError);
}
callback->Call(ctx, 2, cb_args);
}
/* doAsyncCallback() runs in the main thread. We don't want it to block.
TODO: verify whether any IO is done
by checking WaitMetaRequestCount at the start and end.
*/
void GetTableCall::doAsyncCallback(Local<Object> ctx) {
HandleScope scope;
DEBUG_PRINT("GetTableCall::doAsyncCallback: return_val %d", return_val);
/* User callback arguments */
Handle<Value> cb_args[2];
cb_args[0] = Null();
cb_args[1] = Null();
/* TableMetadata = {
database : "" , // Database name
name : "" , // Table Name
columns : [] , // ordered array of DBColumn objects
indexes : [] , // array of DBIndex objects
partitionKey : [] , // ordered array of column numbers in the partition key
};
*/
if(ndb_table && ! return_val) {
Local<Object> table = NdbDictTableEnv.newWrapper();
wrapPointerInObject(ndb_table, NdbDictTableEnv, table);
// database
table->Set(String::NewSymbol("database"), String::New(arg1));
// name
table->Set(String::NewSymbol("name"), String::New(ndb_table->getName()));
// columns
Local<Array> columns = Array::New(ndb_table->getNoOfColumns());
for(int i = 0 ; i < ndb_table->getNoOfColumns() ; i++) {
Handle<Object> col = buildDBColumn(ndb_table->getColumn(i));
columns->Set(i, col);
}
table->Set(String::NewSymbol("columns"), columns);
// indexes (primary key & secondary)
Local<Array> js_indexes = Array::New(idx_list.count + 1);
js_indexes->Set(0, buildDBIndex_PK()); // primary key
for(unsigned int i = 0 ; i < idx_list.count ; i++) { // secondary indexes
const NdbDictionary::Index * idx =
arg0->dict->getIndex(idx_list.elements[i].name, arg2);
js_indexes->Set(i+1, buildDBIndex(idx));
}
table->Set(String::NewSymbol("indexes"), js_indexes, ReadOnly);
// partitionKey
// Table Record (implementation artifact; not part of spec)
DEBUG_PRINT("Creating Table Record");
Record * rec = new Record(arg0->dict, ndb_table->getNoOfColumns());
for(int i = 0 ; i < ndb_table->getNoOfColumns() ; i++) {
rec->addColumn(ndb_table->getColumn(i));
}
rec->completeTableRecord(ndb_table);
table->Set(String::NewSymbol("record"), Record_Wrapper(rec));
// User Callback
cb_args[1] = table;
}
else {
cb_args[0] = String::New(arg0->dict->getNdbError().message);
}
callback->Call(ctx, 2, cb_args);
}
int
NdbDictionary::Dictionary::listIndexes(List& list,
const NdbDictionary::Table &table) const
{
return m_impl.listIndexes(list, table.getTableId());
}
