static void createIndex(Ndb &myNdb, bool includePrimary, unsigned int noOfIndexes) { Uint64 before, after; NdbDictionary::Dictionary* dict = myNdb.getDictionary(); char indexName[] = "PNUMINDEX0000"; int res; for(unsigned int indexNum = 0; indexNum < noOfIndexes; indexNum++) { sprintf(indexName, "PNUMINDEX%.4u", indexNum); NdbDictionary::Index index(indexName); index.setTable("PERSON"); index.setType(NdbDictionary::Index::UniqueHashIndex); if (includePrimary) { const char* attr_arr[] = {"NAME", "PNUM1", "PNUM3"}; index.addIndexColumns(3, attr_arr); } else { const char* attr_arr[] = {"PNUM1", "PNUM3"}; index.addIndexColumns(2, attr_arr); } before = NdbTick_CurrentMillisecond(); if ((res = dict->createIndex(index)) == -1) { error_handler(dict->getNdbError()); } after = NdbTick_CurrentMillisecond(); ndbout << "Created index " << indexName << ", " << after - before << " msec" << endl; } }
int runCreateIndexT1(NDBT_Context* ctx, NDBT_Step* step) { Ndb* pNdb = GETNDB(step); NdbDictionary::Dictionary* pDict = pNdb->getDictionary(); const NdbDictionary::Table* pTab = pDict->getTable("T1"); if (pTab == 0) { g_err << "getTable(T1) error: " << pDict->getNdbError() << endl; return NDBT_FAILED; } NdbDictionary::Index ind; ind.setName("T1X1"); ind.setTable("T1"); ind.setType(NdbDictionary::Index::OrderedIndex); ind.setLogging(false); ind.addColumn("KOL2"); ind.addColumn("KOL3"); ind.addColumn("KOL4"); if (pDict->createIndex(ind, *pTab) != 0) { g_err << "createIndex(T1X1) error: " << pDict->getNdbError() << endl; return NDBT_FAILED; } return NDBT_OK; }
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; }
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; }
bool BackupRestore::endOfTables(){ if(!m_restore_meta) return true; NdbDictionary::Dictionary* dict = m_ndb->getDictionary(); for(size_t i = 0; i<m_indexes.size(); i++){ NdbTableImpl & indtab = NdbTableImpl::getImpl(* m_indexes[i]); Vector<BaseString> split; { BaseString tmp(indtab.m_primaryTable.c_str()); if (tmp.split(split, "/") != 3) { err << "Invalid table name format `" << indtab.m_primaryTable.c_str() << "`" << endl; return false; } } m_ndb->setDatabaseName(split[0].c_str()); m_ndb->setSchemaName(split[1].c_str()); const NdbDictionary::Table * prim = dict->getTable(split[2].c_str()); if(prim == 0){ err << "Unable to find base table `" << split[2].c_str() << "` for index `" << indtab.getName() << "`" << endl; return false; } NdbTableImpl& base = NdbTableImpl::getImpl(*prim); NdbIndexImpl* idx; Vector<BaseString> split_idx; { BaseString tmp(indtab.getName()); if (tmp.split(split_idx, "/") != 4) { err << "Invalid index name format `" << indtab.getName() << "`" << endl; return false; } } if(NdbDictInterface::create_index_obj_from_table(&idx, &indtab, &base)) { err << "Failed to create index `" << split_idx[3] << "` on " << split[2].c_str() << endl; return false; } idx->setName(split_idx[3].c_str()); if(dict->createIndex(* idx) != 0) { delete idx; err << "Failed to create index `" << split_idx[3].c_str() << "` on `" << split[2].c_str() << "`" << endl << dict->getNdbError() << endl; return false; } delete idx; info << "Successfully created index `" << split_idx[3].c_str() << "` on `" << split[2].c_str() << "`" << endl; } return true; }
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; }