TupleSchema* TupleSchema::createKeySchema(const std::vector<ValueType>& columnTypes,
const std::vector<int32_t>& columnSizes,
const std::vector<bool>& columnInBytes)
{
std::vector<bool> allowNull(columnTypes.size(), true);
TupleSchema* schema = createTupleSchema(columnTypes, columnSizes, allowNull, columnInBytes);
schema->m_isHeaderless = true;
return schema;
}
TempTable* createTempTable() {
std::string tableName = "a_table";
int columns = 5;
TupleSchema* schema = createTupleSchema(columns);
std::vector<std::string> names;
for (int i = 0 ; i < columns; ++i) {
char buffer[5];
snprintf(buffer, 4, "C%02d", i);
std::string name(buffer);
names.push_back(name);
}
return TableFactory::buildTempTable(tableName, schema, names, NULL);
}
TupleSchema* TupleSchema::createTupleSchema(const TupleSchema *first,
const TupleSchema *second) {
assert(first);
assert(second);
std::vector<uint16_t> firstSet;
std::vector<uint16_t> secondSet;
for (uint16_t i = 0; i < first->columnCount(); i++) {
firstSet.push_back(i);
}
for (uint16_t i = 0; i < second->columnCount(); i++) {
secondSet.push_back(i);
}
return createTupleSchema(first, firstSet, second, secondSet);
}
TupleSchema* TupleSchema::createTupleSchema(const TupleSchema *schema,
const std::vector<uint16_t> set) {
return createTupleSchema(schema, set, NULL, std::vector<uint16_t>());
}
Table* TableCatalogDelegate::constructTableFromCatalog(catalog::Database const& catalogDatabase,
catalog::Table const& catalogTable,
bool isXDCR,
int tableAllocationTargetSize,
bool forceNoDR) {
// Create a persistent table for this table in our catalog
int32_t tableId = catalogTable.relativeIndex();
// get an array of table column names
const int numColumns = static_cast<int>(catalogTable.columns().size());
std::map<std::string, catalog::Column*>::const_iterator colIterator;
std::vector<std::string> columnNames(numColumns);
for (colIterator = catalogTable.columns().begin();
colIterator != catalogTable.columns().end();
colIterator++) {
auto catalogColumn = colIterator->second;
columnNames[catalogColumn->index()] = catalogColumn->name();
}
// get the schema for the table
TupleSchema* schema = createTupleSchema(catalogTable, isXDCR);
// Indexes
std::map<std::string, TableIndexScheme> index_map;
std::map<std::string, catalog::Index*>::const_iterator idxIterator;
for (idxIterator = catalogTable.indexes().begin();
idxIterator != catalogTable.indexes().end(); idxIterator++) {
auto catalogIndex = idxIterator->second;
TableIndexScheme index_scheme;
if (getIndexScheme(catalogTable, *catalogIndex, schema, &index_scheme)) {
index_map[catalogIndex->name()] = index_scheme;
}
}
// Constraints
std::string pkeyIndexId;
std::map<std::string, catalog::Constraint*>::const_iterator constraintIterator;
for (constraintIterator = catalogTable.constraints().begin();
constraintIterator != catalogTable.constraints().end();
constraintIterator++) {
auto catalogConstraint = constraintIterator->second;
// Constraint Type
ConstraintType type = (ConstraintType) catalogConstraint->type();
switch (type) {
case CONSTRAINT_TYPE_PRIMARY_KEY:
// Make sure we have an index to use
assert(catalogConstraint->index());
// Make sure they didn't declare more than one primary key index
assert(pkeyIndexId.empty());
pkeyIndexId = catalogConstraint->index()->name();
break;
case CONSTRAINT_TYPE_UNIQUE:
// Make sure we have an index to use
// TODO: In the future I would like bring back my Constraint
// object so that we can keep track of everything that a
// table has...
assert(catalogConstraint->index());
break;
// Unsupported
case CONSTRAINT_TYPE_CHECK:
case CONSTRAINT_TYPE_FOREIGN_KEY:
case CONSTRAINT_TYPE_MAIN:
VOLT_WARN("Unsupported type '%s' for constraint '%s'",
constraintutil::getTypeName(type).c_str(),
catalogConstraint->name().c_str());
break;
// Unknown
default:
VOLT_ERROR("Invalid constraint type '%s' for '%s'",
constraintutil::getTypeName(type).c_str(),
catalogConstraint->name().c_str());
assert(false);
return NULL;
}
}
// Build the index array
// Please note the index array should follow the order of primary key first,
// all unique indices afterwards, and all the non-unique indices at the end.
std::deque<TableIndexScheme> indexes;
TableIndexScheme pkeyIndex_scheme;
std::map<std::string, TableIndexScheme>::const_iterator indexIterator;
for (indexIterator = index_map.begin(); indexIterator != index_map.end();
indexIterator++) {
// Exclude the primary key
if (indexIterator->second.name.compare(pkeyIndexId) == 0) {
pkeyIndex_scheme = indexIterator->second;
// Just add it to the list
}
else {
if (indexIterator->second.unique) {
indexes.push_front(indexIterator->second);
}
else {
indexes.push_back(indexIterator->second);
}
}
}
// partition column:
catalog::Column const* partitionColumn = catalogTable.partitioncolumn();
int partitionColumnIndex = -1;
if (partitionColumn != NULL) {
partitionColumnIndex = partitionColumn->index();
}
bool exportEnabled = isExportEnabledForTable(catalogDatabase, tableId);
bool tableIsExportOnly = isTableExportOnly(catalogDatabase, tableId);
bool drEnabled = !forceNoDR && catalogTable.isDRed();
bool isReplicated = catalogTable.isreplicated();
m_materialized = isTableMaterialized(catalogTable);
std::string const& tableName = catalogTable.name();
int32_t databaseId = catalogDatabase.relativeIndex();
SHA1_CTX shaCTX;
SHA1Init(&shaCTX);
SHA1Update(&shaCTX, reinterpret_cast<const uint8_t*>(catalogTable.signature().c_str()), (uint32_t )::strlen(catalogTable.signature().c_str()));
SHA1Final(reinterpret_cast<unsigned char*>(m_signatureHash), &shaCTX);
// Persistent table will use default size (2MB) if tableAllocationTargetSize is zero.
if (m_materialized) {
catalog::MaterializedViewInfo* mvInfo = catalogTable.materializer()->views().get(catalogTable.name());
if (mvInfo && mvInfo->groupbycols().size() == 0) {
// ENG-8490: If the materialized view came with no group by, set table block size to 64KB
// to achieve better space efficiency.
// FYI: maximum column count = 1024, largest fixed length data type is short varchars (64 bytes)
tableAllocationTargetSize = 1024 * 64;
}
}
VOLT_DEBUG("Creating %s %s as %s", m_materialized?"VIEW":"TABLE", tableName.c_str(), isReplicated?"REPLICATED":"PARTITIONED");
Table* table = TableFactory::getPersistentTable(databaseId, tableName,
schema, columnNames, m_signatureHash,
m_materialized,
partitionColumnIndex, exportEnabled,
tableIsExportOnly,
tableAllocationTargetSize,
catalogTable.tuplelimit(),
m_compactionThreshold,
drEnabled,
isReplicated);
PersistentTable* persistentTable = dynamic_cast<PersistentTable*>(table);
if ( ! persistentTable) {
assert(pkeyIndexId.empty());
assert(indexes.empty());
return table;
}
// add a pkey index if one exists
if ( ! pkeyIndexId.empty()) {
TableIndex* pkeyIndex = TableIndexFactory::getInstance(pkeyIndex_scheme);
assert(pkeyIndex);
persistentTable->addIndex(pkeyIndex);
persistentTable->setPrimaryKeyIndex(pkeyIndex);
}
// add other indexes
BOOST_FOREACH(TableIndexScheme& scheme, indexes) {
TableIndex* index = TableIndexFactory::getInstance(scheme);
assert(index);
persistentTable->addIndex(index);
}