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;
}
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;
}
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
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;
}
/* 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);
}
/* 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);
}
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;
}
/* 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);
}
