diff --git a/src/binder/bind_node_visitor.cpp b/src/binder/bind_node_visitor.cpp index eec8a03c091..2ccd85dcdb2 100644 --- a/src/binder/bind_node_visitor.cpp +++ b/src/binder/bind_node_visitor.cpp @@ -208,7 +208,7 @@ void BindNodeVisitor::Visit(parser::AnalyzeStatement *node) { void BindNodeVisitor::Visit(expression::TupleValueExpression *expr) { if (!expr->GetIsBound()) { std::tuple col_pos_tuple; - std::shared_ptr table_obj = nullptr; + std::shared_ptr table_obj = nullptr; type::TypeId value_type; int depth = -1; diff --git a/src/binder/binder_context.cpp b/src/binder/binder_context.cpp index 0413b488c37..4c518f5fa8d 100644 --- a/src/binder/binder_context.cpp +++ b/src/binder/binder_context.cpp @@ -38,8 +38,10 @@ void BinderContext::AddRegularTable(const std::string db_name, const std::string table_alias, concurrency::TransactionContext *txn) { // using catalog object to retrieve meta-data - auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - db_name, schema_name, table_name, txn); + auto table_object = catalog::Catalog::GetInstance()->GetTableCatalogEntry(txn, + db_name, + schema_name, + table_name); if (regular_table_alias_map_.find(table_alias) != regular_table_alias_map_.end() || @@ -79,9 +81,9 @@ void BinderContext::AddNestedTable( bool BinderContext::GetColumnPosTuple( const std::string &col_name, - std::shared_ptr table_obj, + std::shared_ptr table_obj, std::tuple &col_pos_tuple, type::TypeId &value_type) { - auto column_object = table_obj->GetColumnObject(col_name); + auto column_object = table_obj->GetColumnCatalogEntry(col_name); if (column_object == nullptr) { return false; } @@ -138,7 +140,7 @@ bool BinderContext::GetColumnPosTuple( bool BinderContext::GetRegularTableObj( std::shared_ptr current_context, std::string &alias, - std::shared_ptr &table_obj, int &depth) { + std::shared_ptr &table_obj, int &depth) { while (current_context != nullptr) { auto iter = current_context->regular_table_alias_map_.find(alias); if (iter != current_context->regular_table_alias_map_.end()) { @@ -174,9 +176,9 @@ void BinderContext::GenerateAllColumnExpressions( std::vector> &exprs) { for (auto &entry : regular_table_alias_map_) { auto &table_obj = entry.second; - auto col_cnt = table_obj->GetColumnObjects().size(); + auto col_cnt = table_obj->GetColumnCatalogEntries().size(); for (size_t i = 0; i < col_cnt; i++) { - auto col_obj = table_obj->GetColumnObject(i); + auto col_obj = table_obj->GetColumnCatalogEntry(i); auto tv_expr = new expression::TupleValueExpression( std::string(col_obj->GetColumnName()), std::string(entry.first)); tv_expr->SetValueType(col_obj->GetColumnType()); diff --git a/src/brain/query_logger.cpp b/src/brain/query_logger.cpp index 6aa512e8e95..9d35d5e8cf0 100644 --- a/src/brain/query_logger.cpp +++ b/src/brain/query_logger.cpp @@ -41,8 +41,11 @@ void QueryLogger::LogQuery(std::string query_string, uint64_t timestamp) { // Log query + fingerprint auto &query_history_catalog = catalog::QueryHistoryCatalog::GetInstance(); - query_history_catalog.InsertQueryHistory( - query_string, fingerprint.GetFingerprint(), timestamp, nullptr, txn); + query_history_catalog.InsertQueryHistory(txn, + query_string, + fingerprint.GetFingerprint(), + timestamp, + nullptr); // We're done txn_manager.CommitTransaction(txn); diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 9d9934a7c61..5ce2bceaedc 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -44,22 +44,22 @@ namespace peloton { namespace catalog { -AbstractCatalog::AbstractCatalog(oid_t catalog_table_oid, - std::string catalog_table_name, +AbstractCatalog::AbstractCatalog(storage::Database *pg_catalog, catalog::Schema *catalog_table_schema, - storage::Database *pg_catalog) { + oid_t catalog_table_oid, + std::string catalog_table_name) { // set database_oid - database_oid = pg_catalog->GetOid(); + database_oid_ = pg_catalog->GetOid(); // Create catalog_table_ catalog_table_ = storage::TableFactory::GetDataTable( - database_oid, catalog_table_oid, catalog_table_schema, catalog_table_name, + database_oid_, catalog_table_oid, catalog_table_schema, catalog_table_name, DEFAULT_TUPLES_PER_TILEGROUP, true, false, true); // Add catalog_table_ into pg_catalog database pg_catalog->AddTable(catalog_table_, true); } -AbstractCatalog::AbstractCatalog(const std::string &catalog_table_ddl, - concurrency::TransactionContext *txn) { +AbstractCatalog::AbstractCatalog(concurrency::TransactionContext *txn, + const std::string &catalog_table_ddl) { // get catalog table schema auto &peloton_parser = parser::PostgresParser::GetInstance(); auto create_plan = std::dynamic_pointer_cast( @@ -71,13 +71,19 @@ AbstractCatalog::AbstractCatalog(const std::string &catalog_table_ddl, auto catalog_database_name = create_plan->GetDatabaseName(); PELOTON_ASSERT(catalog_schema_name == std::string(CATALOG_SCHEMA_NAME)); // create catalog table - Catalog::GetInstance()->CreateTable( - catalog_database_name, catalog_schema_name, catalog_table_name, - std::unique_ptr(catalog_table_schema), txn, true); + Catalog::GetInstance()->CreateTable(txn, + catalog_database_name, + catalog_schema_name, + std::unique_ptr( + catalog_table_schema), + catalog_table_name, + true); // get catalog table oid - auto catalog_table_object = Catalog::GetInstance()->GetTableObject( - catalog_database_name, catalog_schema_name, catalog_table_name, txn); + auto catalog_table_object = Catalog::GetInstance()->GetTableCatalogEntry(txn, + catalog_database_name, + catalog_schema_name, + catalog_table_name); // set catalog_table_ try { @@ -85,7 +91,7 @@ AbstractCatalog::AbstractCatalog(const std::string &catalog_table_ddl, catalog_table_object->GetDatabaseOid(), catalog_table_object->GetTableOid()); // set database_oid - database_oid = catalog_table_object->GetDatabaseOid(); + database_oid_ = catalog_table_object->GetDatabaseOid(); } catch (CatalogException &e) { LOG_TRACE("Can't find table %d! Return false", catalog_table_object->GetTableOid()); @@ -97,8 +103,8 @@ AbstractCatalog::AbstractCatalog(const std::string &catalog_table_ddl, * @param txn TransactionContext * @return Whether insertion is Successful */ -bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, - concurrency::TransactionContext *txn) { +bool AbstractCatalog::InsertTuple(concurrency::TransactionContext *txn, + std::unique_ptr tuple) { if (txn == nullptr) throw CatalogException("Insert tuple requires transaction"); @@ -137,9 +143,9 @@ bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, * @param txn TransactionContext * @return Whether deletion is Successful */ -bool AbstractCatalog::DeleteWithIndexScan( - oid_t index_offset, std::vector values, - concurrency::TransactionContext *txn) { +bool AbstractCatalog::DeleteWithIndexScan(concurrency::TransactionContext *txn, + oid_t index_offset, + std::vector values) { if (txn == nullptr) throw CatalogException("Delete tuple requires transaction"); @@ -189,9 +195,10 @@ bool AbstractCatalog::DeleteWithIndexScan( */ std::unique_ptr>> AbstractCatalog::GetResultWithIndexScan( - std::vector column_offsets, oid_t index_offset, - std::vector values, - concurrency::TransactionContext *txn) const { + concurrency::TransactionContext *txn, + std::vector column_offsets, + oid_t index_offset, + std::vector values) const { if (txn == nullptr) throw CatalogException("Scan table requires transaction"); // Index scan @@ -238,9 +245,10 @@ AbstractCatalog::GetResultWithIndexScan( * @return Unique pointer of vector of logical tiles */ std::unique_ptr>> -AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, - expression::AbstractExpression *predicate, - concurrency::TransactionContext *txn) { +AbstractCatalog::GetResultWithSeqScan( + concurrency::TransactionContext *txn, + expression::AbstractExpression *predicate, + std::vector column_offsets) { if (txn == nullptr) throw CatalogException("Scan table requires transaction"); // Sequential scan @@ -272,8 +280,9 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, * Note: Use catalog::Catalog::CreateIndex() if you can, only ColumnCatalog and * IndexCatalog should need this */ -void AbstractCatalog::AddIndex(const std::vector &key_attrs, - oid_t index_oid, const std::string &index_name, +void AbstractCatalog::AddIndex(const std::string &index_name, + oid_t index_oid, + const std::vector &key_attrs, IndexConstraintType index_constraint) { auto schema = catalog_table_->GetSchema(); auto key_schema = catalog::Schema::CopySchema(schema, key_attrs); @@ -307,10 +316,11 @@ void AbstractCatalog::AddIndex(const std::vector &key_attrs, * @param index_offset Offset of index for scan * @return true if successfully executes */ -bool AbstractCatalog::UpdateWithIndexScan( - std::vector update_columns, std::vector update_values, - std::vector scan_values, oid_t index_offset, - concurrency::TransactionContext *txn) { +bool AbstractCatalog::UpdateWithIndexScan(concurrency::TransactionContext *txn, + oid_t index_offset, + std::vector scan_values, + std::vector update_columns, + std::vector update_values) { if (txn == nullptr) throw CatalogException("Scan table requires transaction"); std::unique_ptr context( diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index f2d30dd5ecf..b3dcd815ac3 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -65,12 +65,14 @@ Catalog::Catalog() : pool_(new type::EphemeralPool()) { storage_manager->AddDatabaseToStorageManager(peloton); // Create catalog tables - DatabaseCatalog::GetInstance(peloton, pool_.get(), txn); - BootstrapSystemCatalogs(peloton, txn); + DatabaseCatalog::GetInstance(txn, peloton, pool_.get()); + BootstrapSystemCatalogs(txn, peloton); // Insert peloton database into pg_database - DatabaseCatalog::GetInstance()->InsertDatabase( - CATALOG_DATABASE_OID, CATALOG_DATABASE_NAME, pool_.get(), txn); + DatabaseCatalog::GetInstance(txn)->InsertDatabase(txn, + CATALOG_DATABASE_OID, + CATALOG_DATABASE_NAME, + pool_.get()); // Commit transaction txn_manager.CommitTransaction(txn); @@ -83,115 +85,214 @@ Catalog::Catalog() : pool_(new type::EphemeralPool()) { * @param database database which this system catalogs belong to * @param txn transaction context */ -void Catalog::BootstrapSystemCatalogs(storage::Database *database, - concurrency::TransactionContext *txn) { +void Catalog::BootstrapSystemCatalogs(concurrency::TransactionContext *txn, + storage::Database *database) { oid_t database_oid = database->GetOid(); catalog_map_.emplace(database_oid, std::shared_ptr( - new SystemCatalogs(database, pool_.get(), txn))); + new SystemCatalogs(txn, database, pool_.get()))); auto system_catalogs = catalog_map_[database_oid]; // Create indexes on catalog tables, insert them into pg_index // actual index already added in - system_catalogs->GetIndexCatalog()->InsertIndex( - COLUMN_CATALOG_PKEY_OID, COLUMN_CATALOG_NAME "_pkey", COLUMN_CATALOG_OID, - CATALOG_SCHEMA_NAME, IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, - true, - {ColumnCatalog::ColumnId::TABLE_OID, - ColumnCatalog::ColumnId::COLUMN_NAME}, - pool_.get(), txn); - system_catalogs->GetIndexCatalog()->InsertIndex( - COLUMN_CATALOG_SKEY0_OID, COLUMN_CATALOG_NAME "_skey0", - COLUMN_CATALOG_OID, CATALOG_SCHEMA_NAME, IndexType::BWTREE, - IndexConstraintType::UNIQUE, true, - {ColumnCatalog::ColumnId::TABLE_OID, ColumnCatalog::ColumnId::COLUMN_ID}, - pool_.get(), txn); - system_catalogs->GetIndexCatalog()->InsertIndex( - COLUMN_CATALOG_SKEY1_OID, COLUMN_CATALOG_NAME "_skey1", - COLUMN_CATALOG_OID, CATALOG_SCHEMA_NAME, IndexType::BWTREE, - IndexConstraintType::DEFAULT, false, {ColumnCatalog::ColumnId::TABLE_OID}, - pool_.get(), txn); - - system_catalogs->GetIndexCatalog()->InsertIndex( - INDEX_CATALOG_PKEY_OID, INDEX_CATALOG_NAME "_pkey", INDEX_CATALOG_OID, - CATALOG_SCHEMA_NAME, IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, - true, {IndexCatalog::ColumnId::INDEX_OID}, pool_.get(), txn); - system_catalogs->GetIndexCatalog()->InsertIndex( - INDEX_CATALOG_SKEY0_OID, INDEX_CATALOG_NAME "_skey0", INDEX_CATALOG_OID, - CATALOG_SCHEMA_NAME, IndexType::BWTREE, IndexConstraintType::UNIQUE, true, - {IndexCatalog::ColumnId::INDEX_NAME}, pool_.get(), txn); - system_catalogs->GetIndexCatalog()->InsertIndex( - INDEX_CATALOG_SKEY1_OID, INDEX_CATALOG_NAME "_skey1", INDEX_CATALOG_OID, - CATALOG_SCHEMA_NAME, IndexType::BWTREE, IndexConstraintType::DEFAULT, - false, {IndexCatalog::ColumnId::TABLE_OID}, pool_.get(), txn); - - system_catalogs->GetIndexCatalog()->InsertIndex( - DATABASE_CATALOG_PKEY_OID, DATABASE_CATALOG_NAME "_pkey", - DATABASE_CATALOG_OID, CATALOG_SCHEMA_NAME, IndexType::BWTREE, - IndexConstraintType::PRIMARY_KEY, true, - {DatabaseCatalog::ColumnId::DATABASE_OID}, pool_.get(), txn); - system_catalogs->GetIndexCatalog()->InsertIndex( - DATABASE_CATALOG_SKEY0_OID, DATABASE_CATALOG_NAME "_skey0", - DATABASE_CATALOG_OID, CATALOG_SCHEMA_NAME, IndexType::BWTREE, - IndexConstraintType::UNIQUE, true, - {DatabaseCatalog::ColumnId::DATABASE_NAME}, pool_.get(), txn); - - system_catalogs->GetIndexCatalog()->InsertIndex( - SCHEMA_CATALOG_PKEY_OID, SCHEMA_CATALOG_NAME "_pkey", SCHEMA_CATALOG_OID, - CATALOG_SCHEMA_NAME, IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, - true, {SchemaCatalog::ColumnId::SCHEMA_OID}, pool_.get(), txn); - system_catalogs->GetIndexCatalog()->InsertIndex( - SCHEMA_CATALOG_SKEY0_OID, SCHEMA_CATALOG_NAME "_skey0", - SCHEMA_CATALOG_OID, CATALOG_SCHEMA_NAME, IndexType::BWTREE, - IndexConstraintType::UNIQUE, true, {SchemaCatalog::ColumnId::SCHEMA_NAME}, - pool_.get(), txn); - - system_catalogs->GetIndexCatalog()->InsertIndex( - TABLE_CATALOG_PKEY_OID, TABLE_CATALOG_NAME "_pkey", TABLE_CATALOG_OID, - CATALOG_SCHEMA_NAME, IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, - true, {TableCatalog::ColumnId::TABLE_OID}, pool_.get(), txn); - system_catalogs->GetIndexCatalog()->InsertIndex( - TABLE_CATALOG_SKEY0_OID, TABLE_CATALOG_NAME "_skey0", TABLE_CATALOG_OID, - CATALOG_SCHEMA_NAME, IndexType::BWTREE, IndexConstraintType::UNIQUE, true, - {TableCatalog::ColumnId::TABLE_NAME}, pool_.get(), txn); - system_catalogs->GetIndexCatalog()->InsertIndex( - TABLE_CATALOG_SKEY1_OID, TABLE_CATALOG_NAME "_skey1", TABLE_CATALOG_OID, - CATALOG_SCHEMA_NAME, IndexType::BWTREE, IndexConstraintType::DEFAULT, - false, {TableCatalog::ColumnId::DATABASE_OID}, pool_.get(), txn); + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + COLUMN_CATALOG_OID, + COLUMN_CATALOG_PKEY_OID, + COLUMN_CATALOG_NAME "_pkey", + IndexType::BWTREE, + IndexConstraintType::PRIMARY_KEY, + true, + {ColumnCatalog::ColumnId::TABLE_OID, + ColumnCatalog::ColumnId::COLUMN_NAME}, + pool_.get()); + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + COLUMN_CATALOG_OID, + COLUMN_CATALOG_SKEY0_OID, + COLUMN_CATALOG_NAME "_skey0", + IndexType::BWTREE, + IndexConstraintType::UNIQUE, + true, + {ColumnCatalog::ColumnId::TABLE_OID, + ColumnCatalog::ColumnId::COLUMN_ID}, + pool_.get()); + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + COLUMN_CATALOG_OID, + COLUMN_CATALOG_SKEY1_OID, + COLUMN_CATALOG_NAME "_skey1", + IndexType::BWTREE, + IndexConstraintType::DEFAULT, + false, + {ColumnCatalog::ColumnId::TABLE_OID}, + pool_.get()); + + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + INDEX_CATALOG_OID, + INDEX_CATALOG_PKEY_OID, + INDEX_CATALOG_NAME "_pkey", + IndexType::BWTREE, + IndexConstraintType::PRIMARY_KEY, + true, + {IndexCatalog::ColumnId::INDEX_OID}, + pool_.get()); + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + INDEX_CATALOG_OID, + INDEX_CATALOG_SKEY0_OID, + INDEX_CATALOG_NAME "_skey0", + IndexType::BWTREE, + IndexConstraintType::UNIQUE, + true, + {IndexCatalog::ColumnId::INDEX_NAME}, + pool_.get()); + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + INDEX_CATALOG_OID, + INDEX_CATALOG_SKEY1_OID, + INDEX_CATALOG_NAME "_skey1", + IndexType::BWTREE, + IndexConstraintType::DEFAULT, + false, + {IndexCatalog::ColumnId::TABLE_OID}, + pool_.get()); + + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + DATABASE_CATALOG_OID, + DATABASE_CATALOG_PKEY_OID, + DATABASE_CATALOG_NAME "_pkey", + IndexType::BWTREE, + IndexConstraintType::PRIMARY_KEY, + true, + {DatabaseCatalog::ColumnId::DATABASE_OID}, + pool_.get()); + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + DATABASE_CATALOG_OID, + DATABASE_CATALOG_SKEY0_OID, + DATABASE_CATALOG_NAME "_skey0", + IndexType::BWTREE, + IndexConstraintType::UNIQUE, + true, + {DatabaseCatalog::ColumnId::DATABASE_NAME}, + pool_.get()); + + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + SCHEMA_CATALOG_OID, + SCHEMA_CATALOG_PKEY_OID, + SCHEMA_CATALOG_NAME "_pkey", + IndexType::BWTREE, + IndexConstraintType::PRIMARY_KEY, + true, + {SchemaCatalog::ColumnId::SCHEMA_OID}, + pool_.get()); + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + SCHEMA_CATALOG_OID, + SCHEMA_CATALOG_SKEY0_OID, + SCHEMA_CATALOG_NAME "_skey0", + IndexType::BWTREE, + IndexConstraintType::UNIQUE, + true, + {SchemaCatalog::ColumnId::SCHEMA_NAME}, + pool_.get()); + + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + TABLE_CATALOG_OID, + TABLE_CATALOG_PKEY_OID, + TABLE_CATALOG_NAME "_pkey", + IndexType::BWTREE, + IndexConstraintType::PRIMARY_KEY, + true, + {TableCatalog::ColumnId::TABLE_OID}, + pool_.get()); + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + TABLE_CATALOG_OID, + TABLE_CATALOG_SKEY0_OID, + TABLE_CATALOG_NAME "_skey0", + IndexType::BWTREE, + IndexConstraintType::UNIQUE, + true, + {TableCatalog::ColumnId::TABLE_NAME}, + pool_.get()); + system_catalogs->GetIndexCatalog()->InsertIndex(txn, + CATALOG_SCHEMA_NAME, + TABLE_CATALOG_OID, + TABLE_CATALOG_SKEY1_OID, + TABLE_CATALOG_NAME "_skey1", + IndexType::BWTREE, + IndexConstraintType::DEFAULT, + false, + {TableCatalog::ColumnId::DATABASE_OID}, + pool_.get()); // Insert records(default + pg_catalog namespace) into pg_namespace - system_catalogs->GetSchemaCatalog()->InsertSchema( - CATALOG_SCHEMA_OID, CATALOG_SCHEMA_NAME, pool_.get(), txn); - system_catalogs->GetSchemaCatalog()->InsertSchema( - DEFAULT_SCHEMA_OID, DEFAULT_SCHEMA_NAME, pool_.get(), txn); + system_catalogs->GetSchemaCatalog()->InsertSchema(txn, + CATALOG_SCHEMA_OID, + CATALOG_SCHEMA_NAME, + pool_.get()); + system_catalogs->GetSchemaCatalog()->InsertSchema(txn, + DEFAULT_SCHEMA_OID, + DEFAULT_SCHEMA_NAME, + pool_.get()); // Insert catalog tables into pg_table // pg_database record is shared across different databases - system_catalogs->GetTableCatalog()->InsertTable( - DATABASE_CATALOG_OID, DATABASE_CATALOG_NAME, CATALOG_SCHEMA_NAME, - CATALOG_DATABASE_OID, ROW_STORE_LAYOUT_OID, pool_.get(), txn); - system_catalogs->GetTableCatalog()->InsertTable( - SCHEMA_CATALOG_OID, SCHEMA_CATALOG_NAME, CATALOG_SCHEMA_NAME, - database_oid, ROW_STORE_LAYOUT_OID, pool_.get(), txn); - system_catalogs->GetTableCatalog()->InsertTable( - TABLE_CATALOG_OID, TABLE_CATALOG_NAME, CATALOG_SCHEMA_NAME, database_oid, - ROW_STORE_LAYOUT_OID, pool_.get(), txn); - system_catalogs->GetTableCatalog()->InsertTable( - INDEX_CATALOG_OID, INDEX_CATALOG_NAME, CATALOG_SCHEMA_NAME, database_oid, - ROW_STORE_LAYOUT_OID, pool_.get(), txn); - system_catalogs->GetTableCatalog()->InsertTable( - COLUMN_CATALOG_OID, COLUMN_CATALOG_NAME, CATALOG_SCHEMA_NAME, - database_oid, ROW_STORE_LAYOUT_OID, pool_.get(), txn); - system_catalogs->GetTableCatalog()->InsertTable( - LAYOUT_CATALOG_OID, LAYOUT_CATALOG_NAME, CATALOG_SCHEMA_NAME, - database_oid, ROW_STORE_LAYOUT_OID, pool_.get(), txn); + system_catalogs->GetTableCatalog()->InsertTable(txn, + CATALOG_DATABASE_OID, + CATALOG_SCHEMA_NAME, + DATABASE_CATALOG_OID, + DATABASE_CATALOG_NAME, + ROW_STORE_LAYOUT_OID, + pool_.get()); + system_catalogs->GetTableCatalog()->InsertTable(txn, + database_oid, + CATALOG_SCHEMA_NAME, + SCHEMA_CATALOG_OID, + SCHEMA_CATALOG_NAME, + ROW_STORE_LAYOUT_OID, + pool_.get()); + system_catalogs->GetTableCatalog()->InsertTable(txn, + database_oid, + CATALOG_SCHEMA_NAME, + TABLE_CATALOG_OID, + TABLE_CATALOG_NAME, + ROW_STORE_LAYOUT_OID, + pool_.get()); + system_catalogs->GetTableCatalog()->InsertTable(txn, + database_oid, + CATALOG_SCHEMA_NAME, + INDEX_CATALOG_OID, + INDEX_CATALOG_NAME, + ROW_STORE_LAYOUT_OID, + pool_.get()); + system_catalogs->GetTableCatalog()->InsertTable(txn, + database_oid, + CATALOG_SCHEMA_NAME, + COLUMN_CATALOG_OID, + COLUMN_CATALOG_NAME, + ROW_STORE_LAYOUT_OID, + pool_.get()); + system_catalogs->GetTableCatalog()->InsertTable(txn, + database_oid, + CATALOG_SCHEMA_NAME, + LAYOUT_CATALOG_OID, + LAYOUT_CATALOG_NAME, + ROW_STORE_LAYOUT_OID, + pool_.get()); } void Catalog::Bootstrap() { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); // bootstrap pg_catalog database - catalog_map_[CATALOG_DATABASE_OID]->Bootstrap(CATALOG_DATABASE_NAME, txn); + catalog_map_[CATALOG_DATABASE_OID]->Bootstrap(txn, CATALOG_DATABASE_NAME); // bootstrap other global catalog tables DatabaseMetricsCatalog::GetInstance(txn); SettingsCatalog::GetInstance(txn); @@ -211,7 +312,9 @@ void Catalog::Bootstrap() { // Reset oid of each catalog to avoid collisions between catalog // values added by system and users when checkpoint recovery. - DatabaseCatalog::GetInstance()->UpdateOid(OID_FOR_USER_OFFSET); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->UpdateOid(OID_FOR_USER_OFFSET); LanguageCatalog::GetInstance().UpdateOid(OID_FOR_USER_OFFSET); ProcCatalog::GetInstance().UpdateOid(OID_FOR_USER_OFFSET); } @@ -220,16 +323,17 @@ void Catalog::Bootstrap() { // CREATE FUNCTIONS //===----------------------------------------------------------------------===// -ResultType Catalog::CreateDatabase(const std::string &database_name, - concurrency::TransactionContext *txn) { +ResultType Catalog::CreateDatabase(concurrency::TransactionContext *txn, + const std::string &database_name) { if (txn == nullptr) throw CatalogException("Do not have transaction to create database " + - database_name); + database_name); - auto pg_database = DatabaseCatalog::GetInstance(); + auto pg_database = DatabaseCatalog::GetInstance(nullptr, nullptr, nullptr); auto storage_manager = storage::StorageManager::GetInstance(); // Check if a database with the same name exists - auto database_object = pg_database->GetDatabaseObject(database_name, txn); + auto database_object = + pg_database->GetDatabaseCatalogEntry(txn, database_name); if (database_object != nullptr) throw CatalogException("Database " + database_name + " already exists"); @@ -247,11 +351,11 @@ ResultType Catalog::CreateDatabase(const std::string &database_name, // put database object into rw_object_set txn->RecordCreate(database_oid, INVALID_OID, INVALID_OID); // Insert database record into pg_db - pg_database->InsertDatabase(database_oid, database_name, pool_.get(), txn); + pg_database->InsertDatabase(txn, database_oid, database_name, pool_.get()); // add core & non-core system catalog tables into database - BootstrapSystemCatalogs(database, txn); - catalog_map_[database_oid]->Bootstrap(database_name, txn); + BootstrapSystemCatalogs(txn, database); + catalog_map_[database_oid]->Bootstrap(txn, database_name); LOG_TRACE("Database %s created. Returning RESULT_SUCCESS.", database_name.c_str()); return ResultType::SUCCESS; @@ -263,30 +367,35 @@ ResultType Catalog::CreateDatabase(const std::string &database_name, * @param txn TransactionContext * @return TransactionContext ResultType(SUCCESS or FAILURE) */ -ResultType Catalog::CreateSchema(const std::string &database_name, - const std::string &schema_name, - concurrency::TransactionContext *txn) { +ResultType Catalog::CreateSchema(concurrency::TransactionContext *txn, + const std::string &database_name, + const std::string &schema_name) { if (txn == nullptr) throw CatalogException( "Do not have transaction to create schema(namespace) " + database_name); // check whether database exists from pg_database auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_name); if (database_object == nullptr) throw CatalogException("Can't find Database " + database_name + - " to create schema"); + " to create schema"); // check whether namespace exists from pg_namespace auto pg_namespace = catalog_map_[database_object->GetDatabaseOid()]->GetSchemaCatalog(); - auto schema_object = pg_namespace->GetSchemaObject(schema_name, txn); + auto schema_object = pg_namespace->GetSchemaCatalogEntry(txn, schema_name); if (schema_object != nullptr) throw CatalogException("Schema(namespace) " + schema_name + - " already exists"); + " already exists"); // Since there isn't physical class corresponds to schema(namespace), the only // thing needs to be done is inserting record into pg_namespace - pg_namespace->InsertSchema(pg_namespace->GetNextOid(), schema_name, - pool_.get(), txn); + pg_namespace->InsertSchema(txn, + pg_namespace->GetNextOid(), + schema_name, + pool_.get()); LOG_TRACE("Schema(namespace) %s created. Returning RESULT_SUCCESS.", schema_name.c_str()); @@ -301,38 +410,43 @@ ResultType Catalog::CreateSchema(const std::string &database_name, * @param txn TransactionContext * @return TransactionContext ResultType(SUCCESS or FAILURE) */ -ResultType Catalog::CreateTable(const std::string &database_name, +ResultType Catalog::CreateTable(concurrency::TransactionContext *txn, + const std::string &database_name, const std::string &schema_name, - const std::string &table_name, std::unique_ptr schema, - concurrency::TransactionContext *txn, - bool is_catalog, uint32_t tuples_per_tilegroup, - peloton::LayoutType layout_type) { + const std::string &table_name, + bool is_catalog, + uint32_t tuples_per_tilegroup, + LayoutType layout_type) { if (txn == nullptr) throw CatalogException("Do not have transaction to create table " + - table_name); + table_name); LOG_TRACE("Creating table %s in database %s", table_name.c_str(), database_name.c_str()); // check whether database exists from pg_database auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_name); if (database_object == nullptr) throw CatalogException("Can't find Database " + database_name + - " to create table"); + " to create table"); // check whether namespace exists from pg_namespace auto schema_object = catalog_map_[database_object->GetDatabaseOid()] - ->GetSchemaCatalog() - ->GetSchemaObject(schema_name, txn); + ->GetSchemaCatalog() + ->GetSchemaCatalogEntry(txn, schema_name); if (schema_object == nullptr) throw CatalogException("Can't find namespace " + schema_name + - " to create table"); + " to create table"); // get table oid from pg_table - auto table_object = database_object->GetTableObject(table_name, schema_name); + auto table_object = + database_object->GetTableCatalogEntry(table_name, schema_name); if (table_object != nullptr) throw CatalogException("Table: " + schema_name + "." + table_name + - " already exists"); + " already exists"); auto storage_manager = storage::StorageManager::GetInstance(); auto database = @@ -346,7 +460,7 @@ ResultType Catalog::CreateTable(const std::string &database_name, auto column_name = column.GetName(); if (column_names.count(column_name) == 1) throw CatalogException("Can't create table " + table_name + - " with duplicate column name"); + " with duplicate column name"); column_names.insert(column_name); } @@ -367,37 +481,55 @@ ResultType Catalog::CreateTable(const std::string &database_name, txn->RecordCreate(database_object->GetDatabaseOid(), table_oid, INVALID_OID); // Update pg_table with table info - pg_table->InsertTable(table_oid, table_name, schema_name, + pg_table->InsertTable(txn, database_object->GetDatabaseOid(), - table->GetDefaultLayout()->GetOid(), pool_.get(), txn); + schema_name, + table_oid, + table_name, + table->GetDefaultLayout()->GetOid(), + pool_.get()); oid_t column_id = 0; for (const auto &column : table->GetSchema()->GetColumns()) { - pg_attribute->InsertColumn(table_oid, column.GetName(), column_id, - column.GetOffset(), column.GetType(), - column.GetLength(), column.IsInlined(), - column.GetConstraints(), pool_.get(), txn); + pg_attribute->InsertColumn(txn, + table_oid, + column_id, + column.GetName(), + column.GetOffset(), + column.GetType(), + column.GetLength(), + column.GetConstraints(), + column.IsInlined(), + pool_.get()); // Create index on unique single column if (column.IsUnique()) { std::string col_name = column.GetName(); std::string index_name = table->GetName() + "_" + col_name + "_UNIQ"; - CreateIndex(database_name, schema_name, table_name, {column_id}, - index_name, true, IndexType::BWTREE, txn); + CreateIndex(txn, + database_name, + schema_name, + table_name, + index_name, + {column_id}, + true, + IndexType::BWTREE); LOG_DEBUG("Added a UNIQUE index on %s in %s.", col_name.c_str(), table_name.c_str()); } column_id++; } - CreatePrimaryIndex(database_object->GetDatabaseOid(), table_oid, schema_name, - txn); + CreatePrimaryIndex(txn, + database_object->GetDatabaseOid(), + schema_name, + table_oid); // Create layout as default layout auto pg_layout = catalog_map_[database_object->GetDatabaseOid()]->GetLayoutCatalog(); auto default_layout = table->GetDefaultLayout(); - if (!pg_layout->InsertLayout(table_oid, default_layout, pool_.get(), txn)) + if (!pg_layout->InsertLayout(txn, table_oid, default_layout, pool_.get())) throw CatalogException("Failed to create a new layout for table " - + table_name); + + table_name); return ResultType::SUCCESS; } @@ -411,9 +543,10 @@ ResultType Catalog::CreateTable(const std::string &database_name, * @param txn TransactionContext * @return TransactionContext ResultType(SUCCESS or FAILURE) */ -ResultType Catalog::CreatePrimaryIndex(oid_t database_oid, oid_t table_oid, +ResultType Catalog::CreatePrimaryIndex(concurrency::TransactionContext *txn, + oid_t database_oid, const std::string &schema_name, - concurrency::TransactionContext *txn) { + oid_t table_oid) { LOG_TRACE("Trying to create primary index for table %d", table_oid); auto storage_manager = storage::StorageManager::GetInstance(); @@ -460,9 +593,16 @@ ResultType Catalog::CreatePrimaryIndex(oid_t database_oid, oid_t table_oid, // put index object into rw_object_set txn->RecordCreate(database_oid, table_oid, index_oid); // insert index record into index_catalog(pg_index) table - pg_index->InsertIndex(index_oid, index_name, table_oid, schema_name, - IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, - unique_keys, key_attrs, pool_.get(), txn); + pg_index->InsertIndex(txn, + schema_name, + table_oid, + index_oid, + index_name, + IndexType::BWTREE, + IndexConstraintType::PRIMARY_KEY, + unique_keys, + key_attrs, + pool_.get()); LOG_TRACE("Successfully created primary key index '%s' for table '%s'", index_name.c_str(), table->GetName().c_str()); @@ -483,51 +623,68 @@ ResultType Catalog::CreatePrimaryIndex(oid_t database_oid, oid_t table_oid, * catalog table Initialization) * @return TransactionContext ResultType(SUCCESS or FAILURE) */ -ResultType Catalog::CreateIndex(const std::string &database_name, +ResultType Catalog::CreateIndex(concurrency::TransactionContext *txn, + const std::string &database_name, const std::string &schema_name, const std::string &table_name, + const std::string &index_name, const std::vector &key_attrs, - const std::string &index_name, bool unique_keys, - IndexType index_type, - concurrency::TransactionContext *txn) { + bool unique_keys, + IndexType index_type) { if (txn == nullptr) throw CatalogException("Do not have transaction to create database " + - index_name); + index_name); LOG_TRACE("Trying to create index %s for table %s", index_name.c_str(), table_name.c_str()); // check if database exists auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_name); if (database_object == nullptr) throw CatalogException("Can't find Database " + database_name + - " to create index"); + " to create index"); // check if table exists - auto table_object = database_object->GetTableObject(table_name, schema_name); + auto table_object = + database_object->GetTableCatalogEntry(table_name, schema_name); if (table_object == nullptr) throw CatalogException("Can't find table " + schema_name + "." + - table_name + " to create index"); + table_name + " to create index"); IndexConstraintType index_constraint = unique_keys ? IndexConstraintType::UNIQUE : IndexConstraintType::DEFAULT; - ResultType success = CreateIndex( - database_object->GetDatabaseOid(), table_object->GetTableOid(), key_attrs, - schema_name, index_name, index_type, index_constraint, unique_keys, txn); + ResultType success = CreateIndex(txn, + database_object->GetDatabaseOid(), + schema_name, + table_object->GetTableOid(), + false, + index_name, + key_attrs, + unique_keys, + index_type, + index_constraint); return success; } -ResultType Catalog::CreateIndex( - oid_t database_oid, oid_t table_oid, const std::vector &key_attrs, - const std::string &schema_name, const std::string &index_name, - IndexType index_type, IndexConstraintType index_constraint, - bool unique_keys, concurrency::TransactionContext *txn, bool is_catalog) { +ResultType Catalog::CreateIndex(concurrency::TransactionContext *txn, + oid_t database_oid, + const std::string &schema_name, + oid_t table_oid, + bool is_catalog, + const std::string &index_name, + const std::vector &key_attrs, + bool unique_keys, + IndexType index_type, + IndexConstraintType index_constraint) { if (txn == nullptr) throw CatalogException("Do not have transaction to create index " + - index_name); + index_name); LOG_TRACE("Trying to create index for table %d", table_oid); @@ -535,13 +692,16 @@ ResultType Catalog::CreateIndex( // check if table already has index with same name // only check when is_catalog flag == false auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); - auto table_object = database_object->GetTableObject(table_oid); - auto index_object = table_object->GetIndexObject(index_name); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_oid); + auto table_object = database_object->GetTableCatalogEntry(table_oid); + auto index_object = table_object->GetIndexCatalogEntry(index_name); if (index_object != nullptr) throw CatalogException("Index " + index_name + " already exists in" + - database_object->GetDatabaseName()); + database_object->GetDatabaseName()); } auto storage_manager = storage::StorageManager::GetInstance(); auto database = storage_manager->GetDatabaseWithOid(database_oid); @@ -569,18 +729,26 @@ ResultType Catalog::CreateIndex( // Put index object into rw_object_set txn->RecordCreate(database_oid, table_oid, index_oid); // Insert index record into pg_index - pg_index->InsertIndex(index_oid, index_name, table_oid, schema_name, - index_type, index_constraint, unique_keys, key_attrs, - pool_.get(), txn); + pg_index->InsertIndex(txn, + schema_name, + table_oid, + index_oid, + index_name, + index_type, + index_constraint, + unique_keys, + key_attrs, + pool_.get()); LOG_TRACE("Successfully add index for table %s contains %d indexes", - table->GetName().c_str(), (int)table->GetValidIndexCount()); + table->GetName().c_str(), (int) table->GetValidIndexCount()); return ResultType::SUCCESS; } -std::shared_ptr Catalog::CreateLayout( - oid_t database_oid, oid_t table_oid, const column_map_type &column_map, - concurrency::TransactionContext *txn) { +std::shared_ptr Catalog::CreateLayout(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t table_oid, + const column_map_type &column_map) { auto storage_manager = storage::StorageManager::GetInstance(); auto database = storage_manager->GetDatabaseWithOid(database_oid); auto table = database->GetTableWithOid(table_oid); @@ -593,19 +761,20 @@ std::shared_ptr Catalog::CreateLayout( // Add the layout the pg_layout table auto pg_layout = catalog_map_[database_oid]->GetLayoutCatalog(); - if (pg_layout->GetLayoutWithOid(table_oid, new_layout->GetOid(), txn) + if (pg_layout->GetLayoutWithOid(txn, table_oid, new_layout->GetOid()) == nullptr && - !pg_layout->InsertLayout(table_oid, new_layout, pool_.get(), txn)) { - LOG_ERROR("Failed to create a new layout for table %u", table_oid); - return nullptr; + !pg_layout->InsertLayout(txn, table_oid, new_layout, pool_.get())) { + LOG_ERROR("Failed to create a new layout for table %u", table_oid); + return nullptr; } return new_layout; } -std::shared_ptr Catalog::CreateDefaultLayout( - oid_t database_oid, oid_t table_oid, const column_map_type &column_map, - concurrency::TransactionContext *txn) { - auto new_layout = CreateLayout(database_oid, table_oid, column_map, txn); +std::shared_ptr Catalog::CreateDefaultLayout(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t table_oid, + const column_map_type &column_map) { + auto new_layout = CreateLayout(txn, database_oid, table_oid, column_map); // If the layout creation was successful, set it as the default if (new_layout != nullptr) { auto storage_manager = storage::StorageManager::GetInstance(); @@ -615,7 +784,7 @@ std::shared_ptr Catalog::CreateDefaultLayout( // update table catalog catalog_map_[database_oid]->GetTableCatalog() - ->UpdateDefaultLayoutOid(new_layout->GetOid(), table_oid, txn); + ->UpdateDefaultLayoutOid(txn, table_oid, new_layout->GetOid()); } return new_layout; } @@ -624,39 +793,47 @@ std::shared_ptr Catalog::CreateDefaultLayout( // DROP FUNCTIONS //===----------------------------------------------------------------------===// -ResultType Catalog::DropDatabaseWithName(const std::string &database_name, - concurrency::TransactionContext *txn) { +ResultType Catalog::DropDatabaseWithName(concurrency::TransactionContext *txn, + const std::string &database_name) { if (txn == nullptr) throw CatalogException("Do not have transaction to drop database " + - database_name); + database_name); auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_name); if (database_object == nullptr) throw CatalogException("Drop Database: " + database_name + - " does not exist"); + " does not exist"); - return DropDatabaseWithOid(database_object->GetDatabaseOid(), txn); + return DropDatabaseWithOid(txn, database_object->GetDatabaseOid()); } -ResultType Catalog::DropDatabaseWithOid(oid_t database_oid, - concurrency::TransactionContext *txn) { +ResultType Catalog::DropDatabaseWithOid(concurrency::TransactionContext *txn, + oid_t database_oid) { if (txn == nullptr) throw CatalogException("Do not have transaction to drop database " + - std::to_string(database_oid)); + std::to_string(database_oid)); auto storage_manager = storage::StorageManager::GetInstance(); // Drop actual tables in the database auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); - auto table_objects = database_object->GetTableObjects(); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_oid); + auto table_objects = database_object->GetTableCatalogEntries(); for (auto it : table_objects) { - DropTable(database_oid, it.second->GetTableOid(), txn); + DropTable(txn, database_oid, it.second->GetTableOid()); } // Drop database record in catalog - if (!DatabaseCatalog::GetInstance()->DeleteDatabase(database_oid, txn)) + if (!DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->DeleteDatabase(txn, database_oid)) throw CatalogException("Database record: " + std::to_string(database_oid) + - " does not exist in pg_database"); + " does not exist in pg_database"); catalog_map_.erase(database_oid); // put database object into rw_object_set @@ -674,33 +851,34 @@ ResultType Catalog::DropDatabaseWithOid(oid_t database_oid, * @param txn TransactionContext * @return TransactionContext ResultType(SUCCESS or FAILURE) */ -ResultType Catalog::DropSchema(const std::string &database_name, - const std::string &schema_name, - concurrency::TransactionContext *txn) { +ResultType Catalog::DropSchema(concurrency::TransactionContext *txn, + const std::string &database_name, + const std::string &schema_name) { if (txn == nullptr) throw CatalogException("Do not have transaction to drop schema " + - schema_name); + schema_name); auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); + DatabaseCatalog::GetInstance(txn)->GetDatabaseCatalogEntry(txn, + database_name); if (database_object == nullptr) throw CatalogException("Drop Schema: database " + database_name + - " does not exist"); + " does not exist"); // check whether namespace exists from pg_namespace auto pg_namespace = catalog_map_[database_object->GetDatabaseOid()]->GetSchemaCatalog(); - auto schema_object = pg_namespace->GetSchemaObject(schema_name, txn); + auto schema_object = pg_namespace->GetSchemaCatalogEntry(txn, schema_name); if (schema_object == nullptr) throw CatalogException("Can't find namespace " + schema_name + " to drop"); - auto table_objects = database_object->GetTableObjects(schema_name); + auto table_objects = database_object->GetTableCatalogEntries(schema_name); for (auto it : table_objects) { - DropTable(it->GetDatabaseOid(), it->GetTableOid(), txn); + DropTable(txn, it->GetDatabaseOid(), it->GetTableOid()); } // remove record within pg_namespace - pg_namespace->DeleteSchema(schema_name, txn); + pg_namespace->DeleteSchema(txn, schema_name); return ResultType::SUCCESS; } @@ -718,29 +896,34 @@ ResultType Catalog::DropSchema(const std::string &database_name, * @param txn TransactionContext * @return TransactionContext ResultType(SUCCESS or FAILURE) */ -ResultType Catalog::DropTable(const std::string &database_name, +ResultType Catalog::DropTable(concurrency::TransactionContext *txn, + const std::string &database_name, const std::string &schema_name, - const std::string &table_name, - concurrency::TransactionContext *txn) { + const std::string &table_name) { if (txn == nullptr) throw CatalogException("Do not have transaction to drop table " + - table_name); + table_name); // Checking if statement is valid auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_name); if (database_object == nullptr) throw CatalogException("Drop Table: database " + database_name + - " does not exist"); + " does not exist"); // check if table exists - auto table_object = database_object->GetTableObject(table_name, schema_name); + auto table_object = + database_object->GetTableCatalogEntry(table_name, schema_name); if (table_object == nullptr) throw CatalogException("Drop Table: table " + schema_name + "." + - table_name + " does not exist"); + table_name + " does not exist"); - ResultType result = DropTable(database_object->GetDatabaseOid(), - table_object->GetTableOid(), txn); + ResultType result = DropTable(txn, + database_object->GetDatabaseOid(), + table_object->GetTableOid()); return result; } @@ -755,43 +938,49 @@ ResultType Catalog::DropTable(const std::string &database_name, * @param txn TransactionContext * @return TransactionContext ResultType(SUCCESS or FAILURE) */ -ResultType Catalog::DropTable(oid_t database_oid, oid_t table_oid, - concurrency::TransactionContext *txn) { +ResultType Catalog::DropTable(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t table_oid) { LOG_TRACE("Dropping table %d from database %d", database_oid, table_oid); auto storage_manager = storage::StorageManager::GetInstance(); auto database = storage_manager->GetDatabaseWithOid(database_oid); auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); - auto table_object = database_object->GetTableObject(table_oid); - auto index_objects = table_object->GetIndexObjects(); - LOG_TRACE("dropping #%d indexes", (int)index_objects.size()); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_oid); + auto table_object = database_object->GetTableCatalogEntry(table_oid); + auto index_objects = table_object->GetIndexCatalogEntries(); + LOG_TRACE("dropping #%d indexes", (int) index_objects.size()); // delete trigger and records in pg_trigger auto pg_trigger = catalog_map_[database_object->GetDatabaseOid()]->GetTriggerCatalog(); std::unique_ptr trigger_lists = - pg_trigger->GetTriggers(table_oid, txn); + pg_trigger->GetTriggers(txn, table_oid); for (int i = 0; i < trigger_lists->GetTriggerListSize(); i++) - pg_trigger->DropTrigger(database_oid, table_oid, - trigger_lists->Get(i)->GetTriggerName(), txn); + pg_trigger->DropTrigger(txn, + database_oid, + table_oid, + trigger_lists->Get(i)->GetTriggerName()); // delete index and records pg_index for (auto it : index_objects) - DropIndex(database_oid, it.second->GetIndexOid(), txn); + DropIndex(txn, database_oid, it.second->GetIndexOid()); // delete record in pg_attribute auto pg_attribute = catalog_map_[database_object->GetDatabaseOid()]->GetColumnCatalog(); - pg_attribute->DeleteColumns(table_oid, txn); + pg_attribute->DeleteColumns(txn, table_oid); // delete record in pg_layout auto pg_layout = catalog_map_[database_object->GetDatabaseOid()]->GetLayoutCatalog(); - pg_layout->DeleteLayouts(table_oid, txn); + pg_layout->DeleteLayouts(txn, table_oid); // delete record in pg_table auto pg_table = catalog_map_[database_object->GetDatabaseOid()]->GetTableCatalog(); - pg_table->DeleteTable(table_oid, txn); + pg_table->DeleteTable(txn, table_oid); database->GetTableWithOid(table_oid); txn->RecordDrop(database_oid, table_oid, INVALID_OID); @@ -803,25 +992,27 @@ ResultType Catalog::DropTable(oid_t database_oid, oid_t table_oid, * @param txn TransactionContext * @return TransactionContext ResultType(SUCCESS or FAILURE) */ -ResultType Catalog::DropIndex(oid_t database_oid, oid_t index_oid, - concurrency::TransactionContext *txn) { +ResultType Catalog::DropIndex(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t index_oid) { if (txn == nullptr) throw CatalogException("Do not have transaction to drop index " + - std::to_string(index_oid)); + std::to_string(index_oid)); // find index catalog object by looking up pg_index or read from cache using // index_oid auto pg_index = catalog_map_[database_oid]->GetIndexCatalog(); - auto index_object = pg_index->GetIndexObject(database_oid, index_oid, txn); + auto index_object = + pg_index->GetIndexCatalogEntry(txn, database_oid, index_oid); if (index_object == nullptr) { throw CatalogException("Can't find index " + std::to_string(index_oid) + - " to drop"); + " to drop"); } auto storage_manager = storage::StorageManager::GetInstance(); auto table = storage_manager->GetTableWithOid(database_oid, index_object->GetTableOid()); // drop record in pg_index - pg_index->DeleteIndex(database_oid, index_oid, txn); + pg_index->DeleteIndex(txn, database_oid, index_oid); LOG_TRACE("Successfully drop index %d for table %s", index_oid, table->GetName().c_str()); @@ -832,9 +1023,10 @@ ResultType Catalog::DropIndex(oid_t database_oid, oid_t index_oid, return ResultType::SUCCESS; } -ResultType Catalog::DropLayout(oid_t database_oid, oid_t table_oid, - oid_t layout_oid, - concurrency::TransactionContext *txn) { +ResultType Catalog::DropLayout(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t table_oid, + oid_t layout_oid) { // Check if the default_layout of the table is the same. // If true reset it to a row store. auto storage_manager = storage::StorageManager::GetInstance(); @@ -843,7 +1035,7 @@ ResultType Catalog::DropLayout(oid_t database_oid, oid_t table_oid, auto default_layout = table->GetDefaultLayout(); auto pg_layout = catalog_map_[database_oid]->GetLayoutCatalog(); - if (!pg_layout->DeleteLayout(table_oid, layout_oid, txn)) { + if (!pg_layout->DeleteLayout(txn, table_oid, layout_oid)) { auto layout = table->GetDefaultLayout(); LOG_DEBUG("Layout delete failed. Default layout id: %u", layout->GetOid()); return ResultType::FAILURE; @@ -852,17 +1044,20 @@ ResultType Catalog::DropLayout(oid_t database_oid, oid_t table_oid, if (default_layout->GetOid() == layout_oid) { table->ResetDefaultLayout(); auto new_default_layout = table->GetDefaultLayout(); - if (pg_layout->GetLayoutWithOid(table_oid, new_default_layout->GetOid(), - txn) == nullptr && - !pg_layout->InsertLayout(table_oid, new_default_layout, - pool_.get(), txn)) { + if (pg_layout->GetLayoutWithOid(txn, + table_oid, + new_default_layout->GetOid()) == nullptr && + !pg_layout->InsertLayout(txn, + table_oid, + new_default_layout, + pool_.get())) { LOG_DEBUG("Failed to create a new layout for table %d", table_oid); return ResultType::FAILURE; } // update table catalog catalog_map_[database_oid]->GetTableCatalog() - ->UpdateDefaultLayoutOid(new_default_layout->GetOid(), table_oid, txn); + ->UpdateDefaultLayoutOid(txn, table_oid, new_default_layout->GetOid()); } return ResultType::SUCCESS; @@ -876,14 +1071,16 @@ ResultType Catalog::DropLayout(oid_t database_oid, oid_t table_oid, * get it from storage layer using database_oid, * throw exception and abort txn if not exists/invisible * */ -storage::Database *Catalog::GetDatabaseWithName( - const std::string &database_name, - concurrency::TransactionContext *txn) const { +storage::Database *Catalog::GetDatabaseWithName(concurrency::TransactionContext *txn, + const std::string &database_name) const { PELOTON_ASSERT(txn != nullptr); // Check in pg_database using txn auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_name); if (database_object == nullptr) { throw CatalogException("Database " + database_name + " is not found"); @@ -897,16 +1094,17 @@ storage::Database *Catalog::GetDatabaseWithName( * get it from storage layer using table_oid, * throw exception and abort txn if not exists/invisible * */ -storage::DataTable *Catalog::GetTableWithName( - const std::string &database_name, const std::string &schema_name, - const std::string &table_name, concurrency::TransactionContext *txn) { +storage::DataTable *Catalog::GetTableWithName(concurrency::TransactionContext *txn, + const std::string &database_name, + const std::string &schema_name, + const std::string &table_name) { PELOTON_ASSERT(txn != nullptr); LOG_TRACE("Looking for table %s in database %s", table_name.c_str(), database_name.c_str()); // Check in pg_table, throw exception and abort txn if not exists auto table_object = - GetTableObject(database_name, schema_name, table_name, txn); + GetTableCatalogEntry(txn, database_name, schema_name, table_name); // Get table from storage manager auto storage_manager = storage::StorageManager::GetInstance(); @@ -918,18 +1116,22 @@ storage::DataTable *Catalog::GetTableWithName( * get it from storage layer using table_oid, * throw exception and abort txn if not exists/invisible * */ -std::shared_ptr Catalog::GetDatabaseObject( - const std::string &database_name, concurrency::TransactionContext *txn) { +std::shared_ptr Catalog::GetDatabaseCatalogEntry( + concurrency::TransactionContext *txn, + const std::string &database_name) { if (txn == nullptr) { throw CatalogException("Do not have transaction to get table object " + - database_name); + database_name); } LOG_TRACE("Looking for database %s", database_name.c_str()); // Check in pg_database, throw exception and abort txn if not exists auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_name); if (!database_object || database_object->GetDatabaseOid() == INVALID_OID) { throw CatalogException("Database " + database_name + " is not found"); @@ -938,22 +1140,26 @@ std::shared_ptr Catalog::GetDatabaseObject( return database_object; } -std::shared_ptr Catalog::GetDatabaseObject( - oid_t database_oid, concurrency::TransactionContext *txn) { +std::shared_ptr Catalog::GetDatabaseCatalogEntry( + concurrency::TransactionContext *txn, + oid_t database_oid) { if (txn == nullptr) { throw CatalogException("Do not have transaction to get database object " + - std::to_string(database_oid)); + std::to_string(database_oid)); } LOG_TRACE("Looking for database %u", database_oid); // Check in pg_database, throw exception and abort txn if not exists auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_oid); if (!database_object || database_object->GetDatabaseOid() == INVALID_OID) { throw CatalogException("Database " + std::to_string(database_oid) + - " is not found"); + " is not found"); } return database_object; @@ -963,12 +1169,13 @@ std::shared_ptr Catalog::GetDatabaseObject( * get it from storage layer using table_oid, * throw exception and abort txn if not exists/invisible * */ -std::shared_ptr Catalog::GetTableObject( - const std::string &database_name, const std::string &schema_name, - const std::string &table_name, concurrency::TransactionContext *txn) { +std::shared_ptr Catalog::GetTableCatalogEntry(concurrency::TransactionContext *txn, + const std::string &database_name, + const std::string &schema_name, + const std::string &table_name) { if (txn == nullptr) { throw CatalogException("Do not have transaction to get table object " + - database_name + "." + table_name); + database_name + "." + table_name); } LOG_TRACE("Looking for table %s in database %s", table_name.c_str(), @@ -976,50 +1183,58 @@ std::shared_ptr Catalog::GetTableObject( // Check in pg_database, throw exception and abort txn if not exists auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_name); if (!database_object || database_object->GetDatabaseOid() == INVALID_OID) { throw CatalogException("Database " + database_name + " is not found"); } // Check in pg_table using txn - auto table_object = database_object->GetTableObject(table_name, schema_name); + auto table_object = + database_object->GetTableCatalogEntry(table_name, schema_name); if (!table_object || table_object->GetTableOid() == INVALID_OID) { // throw table not found exception and explicitly abort txn throw CatalogException("Table " + schema_name + "." + table_name + - " is not found"); + " is not found"); } return table_object; } -std::shared_ptr Catalog::GetTableObject( - oid_t database_oid, oid_t table_oid, concurrency::TransactionContext *txn) { +std::shared_ptr Catalog::GetTableCatalogEntry(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t table_oid) { if (txn == nullptr) { throw CatalogException("Do not have transaction to get table object " + - std::to_string(database_oid) + "." + - std::to_string(table_oid)); + std::to_string(database_oid) + "." + + std::to_string(table_oid)); } LOG_TRACE("Looking for table %u in database %u", table_oid, database_oid); // Check in pg_database, throw exception and abort txn if not exists auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_oid); if (!database_object || database_object->GetDatabaseOid() == INVALID_OID) { throw CatalogException("Database " + std::to_string(database_oid) + - " is not found"); + " is not found"); } // Check in pg_table using txn - auto table_object = database_object->GetTableObject(table_oid); + auto table_object = database_object->GetTableCatalogEntry(table_oid); if (!table_object || table_object->GetTableOid() == INVALID_OID) { // throw table not found exception and explicitly abort txn throw CatalogException("Table " + std::to_string(table_oid) + - " is not found"); + " is not found"); } return table_object; @@ -1029,7 +1244,7 @@ std::shared_ptr Catalog::GetSystemCatalogs( const oid_t database_oid) { if (catalog_map_.find(database_oid) == catalog_map_.end()) { throw CatalogException("Failed to find SystemCatalog for database_oid = " + - std::to_string(database_oid)); + std::to_string(database_oid)); } return catalog_map_[database_oid]; } @@ -1045,10 +1260,11 @@ void Catalog::AddDatabase(storage::Database *database) { storage_manager->AddDatabaseToStorageManager(database); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - BootstrapSystemCatalogs(database, txn); - DatabaseCatalog::GetInstance()->InsertDatabase( - database->GetOid(), database->GetDBName(), pool_.get(), - txn); // I guess this can pass tests + BootstrapSystemCatalogs(txn, database); + DatabaseCatalog::GetInstance(nullptr, nullptr, nullptr)->InsertDatabase(txn, + database->GetOid(), + database->GetDBName(), + pool_.get()); // I guess this can pass tests txn_manager.CommitTransaction(txn); } @@ -1074,13 +1290,20 @@ Catalog::~Catalog() { * @param func_name the function name in C++ source (should be unique) * @param func_ptr the pointer to the function */ -void Catalog::AddBuiltinFunction( - const std::string &name, const std::vector &argument_types, - const type::TypeId return_type, oid_t prolang, const std::string &func_name, - function::BuiltInFuncType func, concurrency::TransactionContext *txn) { - if (!ProcCatalog::GetInstance().InsertProc(name, return_type, argument_types, - prolang, func_name, pool_.get(), - txn)) { +void Catalog::AddBuiltinFunction(concurrency::TransactionContext *txn, + const std::string &name, + function::BuiltInFuncType func, + const std::string &func_name, + type::TypeId return_type, + const std::vector &argument_types, + oid_t prolang) { + if (!ProcCatalog::GetInstance().InsertProc(txn, + name, + return_type, + argument_types, + prolang, + func_name, + pool_.get())) { throw CatalogException("Failed to add function " + func_name); } function::BuiltInFunctions::AddFunction(func_name, func); @@ -1099,23 +1322,29 @@ void Catalog::AddBuiltinFunction( * @param code_context the code_context that holds the generated LLVM * query code */ -void Catalog::AddPlpgsqlFunction( - const std::string &name, const std::vector &argument_types, - const type::TypeId return_type, oid_t prolang, const std::string &func_src, - std::shared_ptr code_context, - concurrency::TransactionContext *txn) { +void Catalog::AddProcedure(concurrency::TransactionContext *txn, + const std::string &name, + type::TypeId return_type, + const std::vector &argument_types, + oid_t prolang, + std::shared_ptr code_context, + const std::string &func_src) { // Check if UDF already exists auto proc_catalog_obj = - ProcCatalog::GetInstance().GetProcByName(name, argument_types, txn); + ProcCatalog::GetInstance().GetProcByName(txn, name, argument_types); if (proc_catalog_obj == nullptr) { - if (!ProcCatalog::GetInstance().InsertProc(name, return_type, - argument_types, prolang, - func_src, pool_.get(), txn)) { + if (!ProcCatalog::GetInstance().InsertProc(txn, + name, + return_type, + argument_types, + prolang, + func_src, + pool_.get())) { throw CatalogException("Failed to add function " + name); } proc_catalog_obj = - ProcCatalog::GetInstance().GetProcByName(name, argument_types, txn); + ProcCatalog::GetInstance().GetProcByName(txn, name, argument_types); // Insert UDF into Catalog function::PlpgsqlFunctions::AddFunction(proc_catalog_obj->GetOid(), code_context); @@ -1129,7 +1358,7 @@ const FunctionData Catalog::GetFunction( // Lookup the function in pg_proc auto &proc_catalog = ProcCatalog::GetInstance(); - auto proc_catalog_obj = proc_catalog.GetProcByName(name, argument_types, txn); + auto proc_catalog_obj = proc_catalog.GetProcByName(txn, name, argument_types); if (proc_catalog_obj == nullptr) { txn_manager.AbortTransaction(txn); throw CatalogException("Failed to find function " + name); @@ -1139,12 +1368,12 @@ const FunctionData Catalog::GetFunction( auto lang_catalog_obj = proc_catalog_obj->GetLanguage(); if (lang_catalog_obj == nullptr || (lang_catalog_obj->GetName() != "internal" && - lang_catalog_obj->GetName() != "plpgsql")) { + lang_catalog_obj->GetName() != "plpgsql")) { txn_manager.AbortTransaction(txn); throw CatalogException( "Peloton currently only supports internal functions and plpgsql UDFs. \ Function " + - name + " has language '" + lang_catalog_obj->GetName() + "'"); + name + " has language '" + lang_catalog_obj->GetName() + "'"); } FunctionData result; @@ -1160,7 +1389,7 @@ const FunctionData Catalog::GetFunction( txn_manager.AbortTransaction(txn); throw CatalogException( "Function " + name + - " is internal, but doesn't have a function address"); + " is internal, but doesn't have a function address"); } } else if (lang_catalog_obj->GetName() == "plpgsql") { // If the function is a "plpgsql" udf, perform the lookup in the plpgsql @@ -1174,7 +1403,7 @@ const FunctionData Catalog::GetFunction( txn_manager.AbortTransaction(txn); throw CatalogException( "Function " + name + - " is plpgsql, but doesn't have a function address"); + " is plpgsql, but doesn't have a function address"); } } @@ -1188,14 +1417,16 @@ void Catalog::InitializeLanguages() { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); // add "internal" language - if (!LanguageCatalog::GetInstance().InsertLanguage("internal", pool_.get(), - txn)) { + if (!LanguageCatalog::GetInstance().InsertLanguage(txn, + "internal", + pool_.get())) { txn_manager.AbortTransaction(txn); throw CatalogException("Failed to add language 'internal'"); } // Add "plpgsql" language - if (!LanguageCatalog::GetInstance().InsertLanguage("plpgsql", pool_.get(), - txn)) { + if (!LanguageCatalog::GetInstance().InsertLanguage(txn, + "plpgsql", + pool_.get())) { txn_manager.AbortTransaction(txn); throw CatalogException("Failed to add language 'plpgsql'"); } @@ -1211,7 +1442,7 @@ void Catalog::InitializeFunctions() { auto txn = txn_manager.BeginTransaction(); auto lang_object = - LanguageCatalog::GetInstance().GetLanguageByName("internal", txn); + LanguageCatalog::GetInstance().GetLanguageByName(txn, "internal"); if (lang_object == nullptr) { throw CatalogException("Language 'internal' does not exist"); } @@ -1221,290 +1452,385 @@ void Catalog::InitializeFunctions() { /** * string functions */ - AddBuiltinFunction( - "ascii", {type::TypeId::VARCHAR}, type::TypeId::INTEGER, - internal_lang, "Ascii", - function::BuiltInFuncType{OperatorId::Ascii, - function::OldEngineStringFunctions::Ascii}, - txn); - AddBuiltinFunction( - "chr", {type::TypeId::INTEGER}, type::TypeId::VARCHAR, internal_lang, - "Chr", - function::BuiltInFuncType{OperatorId::Chr, - function::OldEngineStringFunctions::Chr}, - txn); - AddBuiltinFunction( - "concat", {type::TypeId::VARCHAR, type::TypeId::VARCHAR}, - type::TypeId::VARCHAR, internal_lang, "Concat", - function::BuiltInFuncType{OperatorId::Concat, - function::OldEngineStringFunctions::Concat}, - txn); - AddBuiltinFunction( - "substr", - {type::TypeId::VARCHAR, type::TypeId::INTEGER, type::TypeId::INTEGER}, - type::TypeId::VARCHAR, internal_lang, "Substr", - function::BuiltInFuncType{OperatorId::Substr, - function::OldEngineStringFunctions::Substr}, - txn); - AddBuiltinFunction("char_length", {type::TypeId::VARCHAR}, - type::TypeId::INTEGER, internal_lang, "CharLength", + AddBuiltinFunction(txn, + "ascii", + function::BuiltInFuncType{OperatorId::Ascii, + function::OldEngineStringFunctions::Ascii}, + "Ascii", + type::TypeId::INTEGER, + {type::TypeId::VARCHAR}, + internal_lang); + AddBuiltinFunction(txn, + "chr", + function::BuiltInFuncType{OperatorId::Chr, + function::OldEngineStringFunctions::Chr}, + "Chr", + type::TypeId::VARCHAR, + {type::TypeId::INTEGER}, + internal_lang); + AddBuiltinFunction(txn, + "concat", + function::BuiltInFuncType{OperatorId::Concat, + function::OldEngineStringFunctions::Concat}, + "Concat", + type::TypeId::VARCHAR, + {type::TypeId::VARCHAR, type::TypeId::VARCHAR}, + internal_lang); + AddBuiltinFunction(txn, + "substr", + function::BuiltInFuncType{OperatorId::Substr, + function::OldEngineStringFunctions::Substr}, + "Substr", + type::TypeId::VARCHAR, + {type::TypeId::VARCHAR, type::TypeId::INTEGER, + type::TypeId::INTEGER}, + internal_lang); + AddBuiltinFunction(txn, + "char_length", function::BuiltInFuncType{ OperatorId::CharLength, function::OldEngineStringFunctions::CharLength}, - txn); - AddBuiltinFunction("octet_length", {type::TypeId::VARCHAR}, - type::TypeId::INTEGER, internal_lang, "OctetLength", + "CharLength", + type::TypeId::INTEGER, + {type::TypeId::VARCHAR}, + internal_lang); + AddBuiltinFunction(txn, + "octet_length", function::BuiltInFuncType{ OperatorId::OctetLength, function::OldEngineStringFunctions::OctetLength}, - txn); - AddBuiltinFunction( - "length", {type::TypeId::VARCHAR}, type::TypeId::INTEGER, - internal_lang, "Length", - function::BuiltInFuncType{OperatorId::Length, - function::OldEngineStringFunctions::Length}, - txn); - AddBuiltinFunction( - "repeat", {type::TypeId::VARCHAR, type::TypeId::INTEGER}, - type::TypeId::VARCHAR, internal_lang, "Repeat", - function::BuiltInFuncType{OperatorId::Repeat, - function::OldEngineStringFunctions::Repeat}, - txn); - AddBuiltinFunction( - "replace", - {type::TypeId::VARCHAR, type::TypeId::VARCHAR, type::TypeId::VARCHAR}, - type::TypeId::VARCHAR, internal_lang, "Replace", - function::BuiltInFuncType{ - OperatorId::Replace, function::OldEngineStringFunctions::Replace}, - txn); - AddBuiltinFunction( - "ltrim", {type::TypeId::VARCHAR, type::TypeId::VARCHAR}, - type::TypeId::VARCHAR, internal_lang, "LTrim", - function::BuiltInFuncType{OperatorId::LTrim, - function::OldEngineStringFunctions::LTrim}, - txn); - AddBuiltinFunction( - "rtrim", {type::TypeId::VARCHAR, type::TypeId::VARCHAR}, - type::TypeId::VARCHAR, internal_lang, "RTrim", - function::BuiltInFuncType{OperatorId::RTrim, - function::OldEngineStringFunctions::RTrim}, - txn); - AddBuiltinFunction( - "btrim", {type::TypeId::VARCHAR, type::TypeId::VARCHAR}, - type::TypeId::VARCHAR, internal_lang, "btrim", - function::BuiltInFuncType{OperatorId::BTrim, - function::OldEngineStringFunctions::BTrim}, - txn); + "OctetLength", + type::TypeId::INTEGER, + {type::TypeId::VARCHAR}, + internal_lang); + AddBuiltinFunction(txn, + "length", + function::BuiltInFuncType{OperatorId::Length, + function::OldEngineStringFunctions::Length}, + "Length", + type::TypeId::INTEGER, + {type::TypeId::VARCHAR}, + internal_lang); + AddBuiltinFunction(txn, + "repeat", + function::BuiltInFuncType{OperatorId::Repeat, + function::OldEngineStringFunctions::Repeat}, + "Repeat", + type::TypeId::VARCHAR, + {type::TypeId::VARCHAR, type::TypeId::INTEGER}, + internal_lang); + AddBuiltinFunction(txn, + "replace", + function::BuiltInFuncType{ + OperatorId::Replace, + function::OldEngineStringFunctions::Replace}, + "Replace", + type::TypeId::VARCHAR, + {type::TypeId::VARCHAR, type::TypeId::VARCHAR, + type::TypeId::VARCHAR}, + internal_lang); + AddBuiltinFunction(txn, + "ltrim", + function::BuiltInFuncType{OperatorId::LTrim, + function::OldEngineStringFunctions::LTrim}, + "LTrim", + type::TypeId::VARCHAR, + {type::TypeId::VARCHAR, type::TypeId::VARCHAR}, + internal_lang); + AddBuiltinFunction(txn, + "rtrim", + function::BuiltInFuncType{OperatorId::RTrim, + function::OldEngineStringFunctions::RTrim}, + "RTrim", + type::TypeId::VARCHAR, + {type::TypeId::VARCHAR, type::TypeId::VARCHAR}, + internal_lang); + AddBuiltinFunction(txn, + "btrim", + function::BuiltInFuncType{OperatorId::BTrim, + function::OldEngineStringFunctions::BTrim}, + "btrim", + type::TypeId::VARCHAR, + {type::TypeId::VARCHAR, type::TypeId::VARCHAR}, + internal_lang); // Trim - AddBuiltinFunction( - "btrim", {type::TypeId::VARCHAR}, type::TypeId::VARCHAR, - internal_lang, "trim", - function::BuiltInFuncType{OperatorId::Trim, - function::OldEngineStringFunctions::Trim}, - txn); - AddBuiltinFunction( - "like", {type::TypeId::VARCHAR, type::TypeId::VARCHAR}, - type::TypeId::VARCHAR, internal_lang, "like", - function::BuiltInFuncType{OperatorId::Like, - function::OldEngineStringFunctions::Like}, - txn); + AddBuiltinFunction(txn, + "btrim", + function::BuiltInFuncType{OperatorId::Trim, + function::OldEngineStringFunctions::Trim}, + "trim", + type::TypeId::VARCHAR, + {type::TypeId::VARCHAR}, + internal_lang); + AddBuiltinFunction(txn, + "like", + function::BuiltInFuncType{OperatorId::Like, + function::OldEngineStringFunctions::Like}, + "like", + type::TypeId::VARCHAR, + {type::TypeId::VARCHAR, type::TypeId::VARCHAR}, + internal_lang); /** * decimal functions */ - AddBuiltinFunction("abs", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, - internal_lang, "Abs", + AddBuiltinFunction(txn, + "abs", function::BuiltInFuncType{ OperatorId::Abs, function::NumericFunctions::_Abs}, - txn); - AddBuiltinFunction( - "sqrt", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::NumericFunctions::Sqrt}, - txn); - AddBuiltinFunction( - "sqrt", {type::TypeId::SMALLINT}, type::TypeId::DECIMAL, - internal_lang, "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::NumericFunctions::Sqrt}, - txn); - AddBuiltinFunction( - "sqrt", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::NumericFunctions::Sqrt}, - txn); - AddBuiltinFunction( - "sqrt", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::NumericFunctions::Sqrt}, - txn); - AddBuiltinFunction( - "sqrt", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::NumericFunctions::Sqrt}, - txn); - AddBuiltinFunction( - "floor", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, - internal_lang, "Floor", - function::BuiltInFuncType{OperatorId::Floor, - function::NumericFunctions::_Floor}, - txn); + "Abs", + type::TypeId::DECIMAL, + {type::TypeId::DECIMAL}, + internal_lang); + AddBuiltinFunction(txn, + "sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::NumericFunctions::Sqrt}, + "Sqrt", + type::TypeId::DECIMAL, + {type::TypeId::TINYINT}, + internal_lang); + AddBuiltinFunction(txn, + "sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::NumericFunctions::Sqrt}, + "Sqrt", + type::TypeId::DECIMAL, + {type::TypeId::SMALLINT}, + internal_lang); + AddBuiltinFunction(txn, + "sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::NumericFunctions::Sqrt}, + "Sqrt", + type::TypeId::DECIMAL, + {type::TypeId::INTEGER}, + internal_lang); + AddBuiltinFunction(txn, + "sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::NumericFunctions::Sqrt}, + "Sqrt", + type::TypeId::DECIMAL, + {type::TypeId::BIGINT}, + internal_lang); + AddBuiltinFunction(txn, + "sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::NumericFunctions::Sqrt}, + "Sqrt", + type::TypeId::DECIMAL, + {type::TypeId::DECIMAL}, + internal_lang); + AddBuiltinFunction(txn, + "floor", + function::BuiltInFuncType{OperatorId::Floor, + function::NumericFunctions::_Floor}, + "Floor", + type::TypeId::DECIMAL, + {type::TypeId::DECIMAL}, + internal_lang); /** * integer functions */ - AddBuiltinFunction("abs", {type::TypeId::TINYINT}, type::TypeId::TINYINT, - internal_lang, "Abs", + AddBuiltinFunction(txn, + "abs", function::BuiltInFuncType{ OperatorId::Abs, function::NumericFunctions::_Abs}, - txn); + "Abs", + type::TypeId::TINYINT, + {type::TypeId::TINYINT}, + internal_lang); - AddBuiltinFunction("abs", {type::TypeId::SMALLINT}, - type::TypeId::SMALLINT, internal_lang, "Abs", + AddBuiltinFunction(txn, + "abs", function::BuiltInFuncType{ OperatorId::Abs, function::NumericFunctions::_Abs}, - txn); + "Abs", + type::TypeId::SMALLINT, + {type::TypeId::SMALLINT}, + internal_lang); - AddBuiltinFunction("abs", {type::TypeId::INTEGER}, type::TypeId::INTEGER, - internal_lang, "Abs", + AddBuiltinFunction(txn, + "abs", function::BuiltInFuncType{ OperatorId::Abs, function::NumericFunctions::_Abs}, - txn); + "Abs", + type::TypeId::INTEGER, + {type::TypeId::INTEGER}, + internal_lang); - AddBuiltinFunction("abs", {type::TypeId::BIGINT}, type::TypeId::BIGINT, - internal_lang, "Abs", + AddBuiltinFunction(txn, + "abs", function::BuiltInFuncType{ OperatorId::Abs, function::NumericFunctions::_Abs}, - txn); - - AddBuiltinFunction( - "floor", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, - internal_lang, "Floor", - function::BuiltInFuncType{OperatorId::Floor, - function::NumericFunctions::_Floor}, - txn); - AddBuiltinFunction( - "floor", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Floor", - function::BuiltInFuncType{OperatorId::Floor, - function::NumericFunctions::_Floor}, - txn); - AddBuiltinFunction( - "floor", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, - internal_lang, "Floor", - function::BuiltInFuncType{OperatorId::Floor, - function::NumericFunctions::_Floor}, - txn); - AddBuiltinFunction( - "floor", {type::TypeId::SMALLINT}, type::TypeId::DECIMAL, - internal_lang, "Floor", - function::BuiltInFuncType{OperatorId::Floor, - function::NumericFunctions::_Floor}, - txn); - AddBuiltinFunction( - "round", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, - internal_lang, "Round", - function::BuiltInFuncType{OperatorId::Round, - function::NumericFunctions::_Round}, - txn); - - AddBuiltinFunction( - "ceil", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::NumericFunctions::_Ceil}, - txn); - - AddBuiltinFunction( - "ceil", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang, - "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::NumericFunctions::_Ceil}, - txn); - - AddBuiltinFunction( - "ceil", {type::TypeId::SMALLINT}, type::TypeId::DECIMAL, - internal_lang, "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::NumericFunctions::_Ceil}, - txn); - - AddBuiltinFunction( - "ceil", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, internal_lang, - "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::NumericFunctions::_Ceil}, - txn); - - AddBuiltinFunction( - "ceil", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::NumericFunctions::_Ceil}, - txn); - - AddBuiltinFunction( - "ceiling", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, - internal_lang, "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::NumericFunctions::_Ceil}, - txn); - - AddBuiltinFunction( - "ceiling", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, - internal_lang, "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::NumericFunctions::_Ceil}, - txn); - - AddBuiltinFunction( - "ceiling", {type::TypeId::SMALLINT}, type::TypeId::DECIMAL, - internal_lang, "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::NumericFunctions::_Ceil}, - txn); - - AddBuiltinFunction( - "ceiling", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, - internal_lang, "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::NumericFunctions::_Ceil}, - txn); - - AddBuiltinFunction( - "ceiling", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, - internal_lang, "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::NumericFunctions::_Ceil}, - txn); + "Abs", + type::TypeId::BIGINT, + {type::TypeId::BIGINT}, + internal_lang); + + AddBuiltinFunction(txn, + "floor", + function::BuiltInFuncType{OperatorId::Floor, + function::NumericFunctions::_Floor}, + "Floor", + type::TypeId::DECIMAL, + {type::TypeId::INTEGER}, + internal_lang); + AddBuiltinFunction(txn, + "floor", + function::BuiltInFuncType{OperatorId::Floor, + function::NumericFunctions::_Floor}, + "Floor", + type::TypeId::DECIMAL, + {type::TypeId::BIGINT}, + internal_lang); + AddBuiltinFunction(txn, + "floor", + function::BuiltInFuncType{OperatorId::Floor, + function::NumericFunctions::_Floor}, + "Floor", + type::TypeId::DECIMAL, + {type::TypeId::TINYINT}, + internal_lang); + AddBuiltinFunction(txn, + "floor", + function::BuiltInFuncType{OperatorId::Floor, + function::NumericFunctions::_Floor}, + "Floor", + type::TypeId::DECIMAL, + {type::TypeId::SMALLINT}, + internal_lang); + AddBuiltinFunction(txn, + "round", + function::BuiltInFuncType{OperatorId::Round, + function::NumericFunctions::_Round}, + "Round", + type::TypeId::DECIMAL, + {type::TypeId::DECIMAL}, + internal_lang); + + AddBuiltinFunction(txn, + "ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::NumericFunctions::_Ceil}, + "Ceil", + type::TypeId::DECIMAL, + {type::TypeId::DECIMAL}, + internal_lang); + + AddBuiltinFunction(txn, + "ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::NumericFunctions::_Ceil}, + "Ceil", + type::TypeId::DECIMAL, + {type::TypeId::TINYINT}, + internal_lang); + + AddBuiltinFunction(txn, + "ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::NumericFunctions::_Ceil}, + "Ceil", + type::TypeId::DECIMAL, + {type::TypeId::SMALLINT}, + internal_lang); + + AddBuiltinFunction(txn, + "ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::NumericFunctions::_Ceil}, + "Ceil", + type::TypeId::DECIMAL, + {type::TypeId::INTEGER}, + internal_lang); + + AddBuiltinFunction(txn, + "ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::NumericFunctions::_Ceil}, + "Ceil", + type::TypeId::DECIMAL, + {type::TypeId::BIGINT}, + internal_lang); + + AddBuiltinFunction(txn, + "ceiling", + function::BuiltInFuncType{OperatorId::Ceil, + function::NumericFunctions::_Ceil}, + "Ceil", + type::TypeId::DECIMAL, + {type::TypeId::DECIMAL}, + internal_lang); + + AddBuiltinFunction(txn, + "ceiling", + function::BuiltInFuncType{OperatorId::Ceil, + function::NumericFunctions::_Ceil}, + "Ceil", + type::TypeId::DECIMAL, + {type::TypeId::TINYINT}, + internal_lang); + + AddBuiltinFunction(txn, + "ceiling", + function::BuiltInFuncType{OperatorId::Ceil, + function::NumericFunctions::_Ceil}, + "Ceil", + type::TypeId::DECIMAL, + {type::TypeId::SMALLINT}, + internal_lang); + + AddBuiltinFunction(txn, + "ceiling", + function::BuiltInFuncType{OperatorId::Ceil, + function::NumericFunctions::_Ceil}, + "Ceil", + type::TypeId::DECIMAL, + {type::TypeId::INTEGER}, + internal_lang); + + AddBuiltinFunction(txn, + "ceiling", + function::BuiltInFuncType{OperatorId::Ceil, + function::NumericFunctions::_Ceil}, + "Ceil", + type::TypeId::DECIMAL, + {type::TypeId::BIGINT}, + internal_lang); /** * date functions */ - AddBuiltinFunction( - "date_part", {type::TypeId::VARCHAR, type::TypeId::TIMESTAMP}, - type::TypeId::DECIMAL, internal_lang, "DatePart", - function::BuiltInFuncType{OperatorId::DatePart, - function::TimestampFunctions::_DatePart}, - txn); - - AddBuiltinFunction( - "date_trunc", {type::TypeId::VARCHAR, type::TypeId::TIMESTAMP}, - type::TypeId::TIMESTAMP, internal_lang, "DateTrunc", - function::BuiltInFuncType{OperatorId::DateTrunc, - function::TimestampFunctions::_DateTrunc}, - txn); + AddBuiltinFunction(txn, + "date_part", + function::BuiltInFuncType{OperatorId::DatePart, + function::TimestampFunctions::_DatePart}, + "DatePart", + type::TypeId::DECIMAL, + {type::TypeId::VARCHAR, type::TypeId::TIMESTAMP}, + internal_lang); + + AddBuiltinFunction(txn, + "date_trunc", + function::BuiltInFuncType{OperatorId::DateTrunc, + function::TimestampFunctions::_DateTrunc}, + "DateTrunc", + type::TypeId::TIMESTAMP, + {type::TypeId::VARCHAR, type::TypeId::TIMESTAMP}, + internal_lang); // add now() - AddBuiltinFunction("now", {}, type::TypeId::TIMESTAMP, internal_lang, - "Now", + AddBuiltinFunction(txn, + "now", function::BuiltInFuncType{ OperatorId::Now, function::DateFunctions::_Now}, - txn); + "Now", + type::TypeId::TIMESTAMP, + {}, + internal_lang); } catch (CatalogException &e) { txn_manager.AbortTransaction(txn); diff --git a/src/catalog/catalog_cache.cpp b/src/catalog/catalog_cache.cpp index b97a55b975a..69fdcbc486e 100644 --- a/src/catalog/catalog_cache.cpp +++ b/src/catalog/catalog_cache.cpp @@ -25,28 +25,28 @@ namespace catalog { * @return false only if database_oid already exists in cache */ bool CatalogCache::InsertDatabaseObject( - std::shared_ptr database_object) { + std::shared_ptr database_object) { if (!database_object || database_object->GetDatabaseOid() == INVALID_OID) { return false; // invalid object } // check if already in cache - if (database_objects_cache.find(database_object->GetDatabaseOid()) != - database_objects_cache.end()) { + if (database_objects_cache_.find(database_object->GetDatabaseOid()) != + database_objects_cache_.end()) { LOG_DEBUG("Database %u already exists in cache!", database_object->GetDatabaseOid()); return false; } - if (database_name_cache.find(database_object->GetDatabaseName()) != - database_name_cache.end()) { + if (database_name_cache_.find(database_object->GetDatabaseName()) != + database_name_cache_.end()) { LOG_DEBUG("Database %s already exists in cache!", database_object->GetDatabaseName().c_str()); return false; } - database_objects_cache.insert( + database_objects_cache_.insert( std::make_pair(database_object->GetDatabaseOid(), database_object)); - database_name_cache.insert( + database_name_cache_.insert( std::make_pair(database_object->GetDatabaseName(), database_object)); return true; } @@ -56,15 +56,15 @@ bool CatalogCache::InsertDatabaseObject( * @return true if database_oid is found and evicted; false if not found */ bool CatalogCache::EvictDatabaseObject(oid_t database_oid) { - auto it = database_objects_cache.find(database_oid); - if (it == database_objects_cache.end()) { + auto it = database_objects_cache_.find(database_oid); + if (it == database_objects_cache_.end()) { return false; // database oid not found in cache } auto database_object = it->second; PELOTON_ASSERT(database_object); - database_objects_cache.erase(it); - database_name_cache.erase(database_object->GetDatabaseName()); + database_objects_cache_.erase(it); + database_name_cache_.erase(database_object->GetDatabaseName()); return true; } @@ -73,15 +73,15 @@ bool CatalogCache::EvictDatabaseObject(oid_t database_oid) { * @return true if database_name is found and evicted; false if not found */ bool CatalogCache::EvictDatabaseObject(const std::string &database_name) { - auto it = database_name_cache.find(database_name); - if (it == database_name_cache.end()) { + auto it = database_name_cache_.find(database_name); + if (it == database_name_cache_.end()) { return false; // database name not found in cache } auto database_object = it->second; PELOTON_ASSERT(database_object); - database_name_cache.erase(it); - database_objects_cache.erase(database_object->GetDatabaseOid()); + database_name_cache_.erase(it); + database_objects_cache_.erase(database_object->GetDatabaseOid()); return true; } @@ -89,10 +89,10 @@ bool CatalogCache::EvictDatabaseObject(const std::string &database_name) { * @param database_oid * @return database catalog object; if not found return object with invalid oid */ -std::shared_ptr CatalogCache::GetDatabaseObject( +std::shared_ptr CatalogCache::GetDatabaseObject( oid_t database_oid) { - auto it = database_objects_cache.find(database_oid); - if (it == database_objects_cache.end()) { + auto it = database_objects_cache_.find(database_oid); + if (it == database_objects_cache_.end()) { return nullptr; } return it->second; @@ -102,10 +102,10 @@ std::shared_ptr CatalogCache::GetDatabaseObject( * @param database_name * @return database catalog object; if not found return null */ -std::shared_ptr CatalogCache::GetDatabaseObject( +std::shared_ptr CatalogCache::GetDatabaseObject( const std::string &database_name) { - auto it = database_name_cache.find(database_name); - if (it == database_name_cache.end()) { + auto it = database_name_cache_.find(database_name); + if (it == database_name_cache_.end()) { return nullptr; } return it->second; @@ -115,11 +115,11 @@ std::shared_ptr CatalogCache::GetDatabaseObject( * @param table_oid * @return table catalog object; if not found return null */ -std::shared_ptr CatalogCache::GetCachedTableObject( +std::shared_ptr CatalogCache::GetCachedTableObject( oid_t database_oid, oid_t table_oid) { auto database_object = GetDatabaseObject(database_oid); if (database_object == nullptr) return nullptr; - auto table_object = database_object->GetTableObject(table_oid, true); + auto table_object = database_object->GetTableCatalogEntry(table_oid, true); if (table_object) return table_object; return nullptr; } @@ -128,11 +128,11 @@ std::shared_ptr CatalogCache::GetCachedTableObject( * @param index_oid * @return index catalog object; if not found return null */ -std::shared_ptr CatalogCache::GetCachedIndexObject( +std::shared_ptr CatalogCache::GetCachedIndexObject( oid_t database_oid, oid_t index_oid) { auto database_object = GetDatabaseObject(database_oid); if (database_object == nullptr) return nullptr; - auto index_object = database_object->GetCachedIndexObject(index_oid); + auto index_object = database_object->GetCachedIndexCatalogEntry(index_oid); if (index_object) return index_object; return nullptr; } @@ -141,13 +141,13 @@ std::shared_ptr CatalogCache::GetCachedIndexObject( * @param index_name * @return index catalog object; if not found return null */ -std::shared_ptr CatalogCache::GetCachedIndexObject( - const std::string &database_name, const std::string &index_name, - const std::string &schema_name) { +std::shared_ptr CatalogCache::GetCachedIndexObject(const std::string &database_name, + const std::string &schema_name, + const std::string &index_name) { auto database_object = GetDatabaseObject(database_name); if (database_object == nullptr) return nullptr; auto index_object = - database_object->GetCachedIndexObject(index_name, schema_name); + database_object->GetCachedIndexCatalogEntry(index_name, schema_name); if (index_object) return index_object; return nullptr; } diff --git a/src/catalog/column.cpp b/src/catalog/column.cpp index 50406bef954..3195de231d4 100644 --- a/src/catalog/column.cpp +++ b/src/catalog/column.cpp @@ -21,23 +21,23 @@ namespace catalog { void Column::SetLength(size_t column_length) { // Set the column length based on whether it is inlined - if (is_inlined) { - fixed_length = column_length; - variable_length = 0; + if (is_inlined_) { + fixed_length_ = column_length; + variable_length_ = 0; } else { - fixed_length = sizeof(uintptr_t); - variable_length = column_length; + fixed_length_ = sizeof(uintptr_t); + variable_length_ = column_length; } } void Column::SetInlined() { - switch (column_type) { + switch (column_type_) { case type::TypeId::VARCHAR: case type::TypeId::VARBINARY: break; // No change of inlined setting default: - is_inlined = true; + is_inlined_ = true; break; } } @@ -45,19 +45,19 @@ void Column::SetInlined() { const std::string Column::GetInfo() const { std::ostringstream os; - os << "Column[" << column_name << ", " << TypeIdToString(column_type) << ", " - << "Offset:" << column_offset << ", "; + os << "Column[" << column_name << ", " << TypeIdToString(column_type_) << ", " + << "Offset:" << column_offset_ << ", "; - if (is_inlined) { - os << "FixedLength:" << fixed_length; + if (is_inlined_) { + os << "FixedLength:" << fixed_length_; } else { - os << "VarLength:" << variable_length; + os << "VarLength:" << variable_length_; } - if (constraints.empty() == false) { + if (constraints_.empty() == false) { os << ", {"; bool first = true; - for (auto constraint : constraints) { + for (auto constraint : constraints_) { if (first) { first = false; } else { diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index c28492696fd..6d4e7b717c1 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -23,50 +23,64 @@ namespace peloton { namespace catalog { -ColumnCatalogObject::ColumnCatalogObject(executor::LogicalTile *tile, +ColumnCatalogEntry::ColumnCatalogEntry(executor::LogicalTile *tile, int tupleId) - : table_oid(tile->GetValue(tupleId, ColumnCatalog::ColumnId::TABLE_OID) + : table_oid_(tile->GetValue(tupleId, ColumnCatalog::ColumnId::TABLE_OID) .GetAs()), - column_name(tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_NAME) + column_name_(tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_NAME) .ToString()), - column_id(tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_ID) + column_id_(tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_ID) .GetAs()), - column_offset( + column_offset_( tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_OFFSET) .GetAs()), - column_type(StringToTypeId( + column_type_(StringToTypeId( tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_TYPE) .ToString())), - column_length( + column_length_( tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_LENGTH) .GetAs()), - is_inlined(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_INLINED) + is_inlined_(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_INLINED) .GetAs()), - is_primary(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_PRIMARY) + is_primary_(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_PRIMARY) .GetAs()), - is_not_null(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_NOT_NULL) + is_not_null_(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_NOT_NULL) .GetAs()) {} -ColumnCatalog::ColumnCatalog(storage::Database *pg_catalog, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) - : AbstractCatalog(COLUMN_CATALOG_OID, COLUMN_CATALOG_NAME, - InitializeSchema().release(), pg_catalog) { +ColumnCatalog::ColumnCatalog(concurrency::TransactionContext *txn, + storage::Database *pg_catalog, + type::AbstractPool *pool) + : AbstractCatalog(pg_catalog, + InitializeSchema().release(), + COLUMN_CATALOG_OID, + COLUMN_CATALOG_NAME) { // Add indexes for pg_attribute - AddIndex({ColumnId::TABLE_OID, ColumnId::COLUMN_NAME}, - COLUMN_CATALOG_PKEY_OID, COLUMN_CATALOG_NAME "_pkey", + AddIndex(COLUMN_CATALOG_NAME "_pkey", + COLUMN_CATALOG_PKEY_OID, + {ColumnId::TABLE_OID, ColumnId::COLUMN_NAME}, IndexConstraintType::PRIMARY_KEY); - AddIndex({ColumnId::TABLE_OID, ColumnId::COLUMN_ID}, COLUMN_CATALOG_SKEY0_OID, - COLUMN_CATALOG_NAME "_skey0", IndexConstraintType::UNIQUE); - AddIndex({ColumnId::TABLE_OID}, COLUMN_CATALOG_SKEY1_OID, - COLUMN_CATALOG_NAME "_skey1", IndexConstraintType::DEFAULT); + AddIndex(COLUMN_CATALOG_NAME "_skey0", + COLUMN_CATALOG_SKEY0_OID, + {ColumnId::TABLE_OID, ColumnId::COLUMN_ID}, + IndexConstraintType::UNIQUE); + AddIndex(COLUMN_CATALOG_NAME "_skey1", + COLUMN_CATALOG_SKEY1_OID, + {ColumnId::TABLE_OID}, + IndexConstraintType::DEFAULT); // Insert columns of pg_attribute table into pg_attribute itself uint32_t column_id = 0; for (auto column : catalog_table_->GetSchema()->GetColumns()) { - InsertColumn(COLUMN_CATALOG_OID, column.GetName(), column_id, - column.GetOffset(), column.GetType(), column.GetLength(), - column.IsInlined(), column.GetConstraints(), pool, txn); + InsertColumn(txn, + COLUMN_CATALOG_OID, + column_id, + column.GetName(), + column.GetOffset(), + column.GetType(), + column.GetLength(), + column.GetConstraints(), + column.IsInlined(), + pool); column_id++; } } @@ -89,7 +103,7 @@ std::unique_ptr ColumnCatalog::InitializeSchema() { catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); auto column_name_column = catalog::Column( - type::TypeId::VARCHAR, max_name_size, "column_name", false); + type::TypeId::VARCHAR, max_name_size_, "column_name", false); column_name_column.AddConstraint(catalog::Constraint( ConstraintType::PRIMARY, primary_key_constraint_name)); column_name_column.AddConstraint( @@ -108,7 +122,7 @@ std::unique_ptr ColumnCatalog::InitializeSchema() { catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); auto column_type_column = catalog::Column( - type::TypeId::VARCHAR, max_name_size, "column_type", false); + type::TypeId::VARCHAR, max_name_size_, "column_type", false); column_type_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); @@ -144,14 +158,16 @@ std::unique_ptr ColumnCatalog::InitializeSchema() { return column_catalog_schema; } -bool ColumnCatalog::InsertColumn(oid_t table_oid, +bool ColumnCatalog::InsertColumn(concurrency::TransactionContext *txn, + oid_t table_oid, + oid_t column_id, const std::string &column_name, - oid_t column_id, oid_t column_offset, - type::TypeId column_type, size_t column_length, - bool is_inlined, + oid_t column_offset, + type::TypeId column_type, + size_t column_length, const std::vector &constraints, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { + bool is_inlined, + type::AbstractPool *pool) { // Create the tuple first std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -187,12 +203,12 @@ bool ColumnCatalog::InsertColumn(oid_t table_oid, tuple->SetValue(ColumnId::IS_NOT_NULL, val8, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } -bool ColumnCatalog::DeleteColumn(oid_t table_oid, - const std::string &column_name, - concurrency::TransactionContext *txn) { +bool ColumnCatalog::DeleteColumn(concurrency::TransactionContext *txn, + oid_t table_oid, + const std::string &column_name) { oid_t index_offset = IndexId::PRIMARY_KEY; // Index of table_oid & column_name std::vector values; @@ -202,12 +218,12 @@ bool ColumnCatalog::DeleteColumn(oid_t table_oid, // delete column from cache auto pg_table = Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) + ->GetSystemCatalogs(database_oid_) ->GetTableCatalog(); - auto table_object = pg_table->GetTableObject(table_oid, txn); - table_object->EvictColumnObject(column_name); + auto table_object = pg_table->GetTableCatalogEntry(txn, table_oid); + table_object->EvictColumnCatalogEntry(column_name); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } /* @brief delete all column records from the same table @@ -216,52 +232,56 @@ bool ColumnCatalog::DeleteColumn(oid_t table_oid, * @param txn TransactionContext * @return a vector of table oid */ -bool ColumnCatalog::DeleteColumns(oid_t table_oid, - concurrency::TransactionContext *txn) { +bool ColumnCatalog::DeleteColumns(concurrency::TransactionContext *txn, oid_t table_oid) { oid_t index_offset = IndexId::SKEY_TABLE_OID; // Index of table_oid std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); // delete columns from cache auto pg_table = Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) + ->GetSystemCatalogs(database_oid_) ->GetTableCatalog(); - auto table_object = pg_table->GetTableObject(table_oid, txn); - table_object->EvictAllColumnObjects(); + auto table_object = pg_table->GetTableCatalogEntry(txn, table_oid); + table_object->EvictAllColumnCatalogEntries(); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } -const std::unordered_map> -ColumnCatalog::GetColumnObjects(oid_t table_oid, - concurrency::TransactionContext *txn) { +const std::unordered_map> +ColumnCatalog::GetColumnCatalogEntries( + concurrency::TransactionContext *txn, + oid_t table_oid) { // try get from cache auto pg_table = Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) + ->GetSystemCatalogs(database_oid_) ->GetTableCatalog(); - auto table_object = pg_table->GetTableObject(table_oid, txn); + auto table_object = pg_table->GetTableCatalogEntry(txn, table_oid); PELOTON_ASSERT(table_object && table_object->GetTableOid() == table_oid); - auto column_objects = table_object->GetColumnObjects(true); + auto column_objects = table_object->GetColumnCatalogEntries(true); if (column_objects.size() != 0) return column_objects; // cache miss, get from pg_attribute - std::vector column_ids(all_column_ids); + std::vector column_ids(all_column_ids_); oid_t index_offset = IndexId::SKEY_TABLE_OID; // Index of table_oid std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); for (auto &tile : (*result_tiles)) { for (auto tuple_id : *tile) { auto column_object = - std::make_shared(tile.get(), tuple_id); - table_object->InsertColumnObject(column_object); + std::make_shared(tile.get(), tuple_id); + table_object->InsertColumnCatalogEntry(column_object); } } - return table_object->GetColumnObjects(); + return table_object->GetColumnCatalogEntries(); } } // namespace catalog diff --git a/src/catalog/column_stats_catalog.cpp b/src/catalog/column_stats_catalog.cpp index bbe94340cdb..9aafff3bfb1 100644 --- a/src/catalog/column_stats_catalog.cpp +++ b/src/catalog/column_stats_catalog.cpp @@ -28,41 +28,55 @@ ColumnStatsCatalog *ColumnStatsCatalog::GetInstance( } ColumnStatsCatalog::ColumnStatsCatalog(concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." CATALOG_SCHEMA_NAME "." COLUMN_STATS_CATALOG_NAME - " (" - "database_id INT NOT NULL, " - "table_id INT NOT NULL, " - "column_id INT NOT NULL, " - "num_rows INT NOT NULL, " - "cardinality DECIMAL NOT NULL, " - "frac_null DECIMAL NOT NULL, " - "most_common_vals VARCHAR, " - "most_common_freqs VARCHAR, " - "histogram_bounds VARCHAR, " - "column_name VARCHAR, " - "has_index BOOLEAN);", - txn) { + : AbstractCatalog(txn, "CREATE TABLE " CATALOG_DATABASE_NAME + "." CATALOG_SCHEMA_NAME "." COLUMN_STATS_CATALOG_NAME + " (" + "database_id INT NOT NULL, " + "table_id INT NOT NULL, " + "column_id INT NOT NULL, " + "num_rows INT NOT NULL, " + "cardinality DECIMAL NOT NULL, " + "frac_null DECIMAL NOT NULL, " + "most_common_vals VARCHAR, " + "most_common_freqs VARCHAR, " + "histogram_bounds VARCHAR, " + "column_name VARCHAR, " + "has_index BOOLEAN);") { // unique key: (database_id, table_id, column_id) - Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, COLUMN_STATS_CATALOG_NAME, - {0, 1, 2}, COLUMN_STATS_CATALOG_NAME "_skey0", true, IndexType::BWTREE, - txn); + Catalog::GetInstance()->CreateIndex(txn, + CATALOG_DATABASE_NAME, + CATALOG_SCHEMA_NAME, + COLUMN_STATS_CATALOG_NAME, + COLUMN_STATS_CATALOG_NAME "_skey0", + {0, 1, 2}, + true, + IndexType::BWTREE); // non-unique key: (database_id, table_id) - Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, COLUMN_STATS_CATALOG_NAME, - {0, 1}, COLUMN_STATS_CATALOG_NAME "_skey1", false, IndexType::BWTREE, - txn); + Catalog::GetInstance()->CreateIndex(txn, + CATALOG_DATABASE_NAME, + CATALOG_SCHEMA_NAME, + COLUMN_STATS_CATALOG_NAME, + COLUMN_STATS_CATALOG_NAME "_skey1", + {0, 1}, + false, + IndexType::BWTREE); } ColumnStatsCatalog::~ColumnStatsCatalog() {} -bool ColumnStatsCatalog::InsertColumnStats( - oid_t database_id, oid_t table_id, oid_t column_id, int num_rows, - double cardinality, double frac_null, std::string most_common_vals, - std::string most_common_freqs, std::string histogram_bounds, - std::string column_name, bool has_index, type::AbstractPool *pool, - concurrency::TransactionContext *txn) { +bool ColumnStatsCatalog::InsertColumnStats(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + oid_t column_id, + std::string column_name, + int num_rows, + double frac_null, + std::string most_common_vals, + std::string most_common_freqs, + std::string histogram_bounds, + double cardinality, + bool has_index, + type::AbstractPool *pool) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -109,12 +123,13 @@ bool ColumnStatsCatalog::InsertColumnStats( tuple->SetValue(ColumnId::HAS_INDEX, val_has_index, nullptr); // Insert the tuple into catalog table - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } -bool ColumnStatsCatalog::DeleteColumnStats( - oid_t database_id, oid_t table_id, oid_t column_id, - concurrency::TransactionContext *txn) { +bool ColumnStatsCatalog::DeleteColumnStats(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + oid_t column_id) { oid_t index_offset = IndexId::SECONDARY_KEY_0; // Secondary key index std::vector values; @@ -122,12 +137,13 @@ bool ColumnStatsCatalog::DeleteColumnStats( values.push_back(type::ValueFactory::GetIntegerValue(table_id).Copy()); values.push_back(type::ValueFactory::GetIntegerValue(column_id).Copy()); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } -std::unique_ptr> ColumnStatsCatalog::GetColumnStats( - oid_t database_id, oid_t table_id, oid_t column_id, - concurrency::TransactionContext *txn) { +std::unique_ptr> ColumnStatsCatalog::GetColumnStats(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + oid_t column_id) { std::vector column_ids( {ColumnId::NUM_ROWS, ColumnId::CARDINALITY, ColumnId::FRAC_NULL, ColumnId::MOST_COMMON_VALS, ColumnId::MOST_COMMON_FREQS, @@ -140,7 +156,10 @@ std::unique_ptr> ColumnStatsCatalog::GetColumnStats( values.push_back(type::ValueFactory::GetIntegerValue(column_id).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); PELOTON_ASSERT(result_tiles->size() <= 1); // unique if (result_tiles->size() == 0) { @@ -174,10 +193,11 @@ std::unique_ptr> ColumnStatsCatalog::GetColumnStats( } // Return value: number of column stats -size_t ColumnStatsCatalog::GetTableStats( - oid_t database_id, oid_t table_id, concurrency::TransactionContext *txn, - std::map>> - &column_stats_map) { +size_t ColumnStatsCatalog::GetTableStats(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + std::map>> &column_stats_map) { std::vector column_ids( {ColumnId::COLUMN_ID, ColumnId::NUM_ROWS, ColumnId::CARDINALITY, ColumnId::FRAC_NULL, ColumnId::MOST_COMMON_VALS, @@ -190,7 +210,10 @@ size_t ColumnStatsCatalog::GetTableStats( values.push_back(type::ValueFactory::GetIntegerValue(table_id).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); PELOTON_ASSERT(result_tiles->size() <= 1); // unique if (result_tiles->size() == 0) { diff --git a/src/catalog/constraint.cpp b/src/catalog/constraint.cpp index 01359e7f309..f9c2e025a9e 100644 --- a/src/catalog/constraint.cpp +++ b/src/catalog/constraint.cpp @@ -20,10 +20,10 @@ namespace catalog { const std::string Constraint::GetInfo() const { std::ostringstream os; os << "Constraint[" << GetName() << ", " - << ConstraintTypeToString(constraint_type); + << ConstraintTypeToString(constraint_type_); if (GetType() == ConstraintType::CHECK) { - os << ", " << exp.first << " " << exp.second.GetInfo(); + os << ", " << exp_.first << " " << exp_.second.GetInfo(); } os << "]"; return os.str(); diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index fc0b81c64d0..555e8c9d7d6 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -25,45 +25,45 @@ namespace peloton { namespace catalog { -DatabaseCatalogObject::DatabaseCatalogObject( - executor::LogicalTile *tile, concurrency::TransactionContext *txn) - : database_oid(tile->GetValue(0, DatabaseCatalog::ColumnId::DATABASE_OID) +DatabaseCatalogEntry::DatabaseCatalogEntry(concurrency::TransactionContext *txn, + executor::LogicalTile *tile) + : database_oid_(tile->GetValue(0, DatabaseCatalog::ColumnId::DATABASE_OID) .GetAs()), - database_name(tile->GetValue(0, DatabaseCatalog::ColumnId::DATABASE_NAME) + database_name_(tile->GetValue(0, DatabaseCatalog::ColumnId::DATABASE_NAME) .ToString()), - table_objects_cache(), - table_name_cache(), - valid_table_objects(false), - txn(txn) {} + table_catalog_entries_cache_(), + table_catalog_entries_cache_by_name(), + valid_table_catalog_entries(false), + txn_(txn) {} /* @brief insert table catalog object into cache * @param table_object * @return false if table_name already exists in cache */ -bool DatabaseCatalogObject::InsertTableObject( - std::shared_ptr table_object) { - if (!table_object || table_object->GetTableOid() == INVALID_OID) { +bool DatabaseCatalogEntry::InsertTableCatalogEntry( + std::shared_ptr table_catalog_entry) { + if (!table_catalog_entry || table_catalog_entry->GetTableOid() == INVALID_OID) { return false; // invalid object } // check if already in cache - if (table_objects_cache.find(table_object->GetTableOid()) != - table_objects_cache.end()) { - LOG_DEBUG("Table %u already exists in cache!", table_object->GetTableOid()); + if (table_catalog_entries_cache_.find(table_catalog_entry->GetTableOid()) != + table_catalog_entries_cache_.end()) { + LOG_DEBUG("Table %u already exists in cache!", table_catalog_entry->GetTableOid()); return false; } std::string key = - table_object->GetSchemaName() + "." + table_object->GetTableName(); - if (table_name_cache.find(key) != table_name_cache.end()) { + table_catalog_entry->GetSchemaName() + "." + table_catalog_entry->GetTableName(); + if (table_catalog_entries_cache_by_name.find(key) != table_catalog_entries_cache_by_name.end()) { LOG_DEBUG("Table %s already exists in cache!", - table_object->GetTableName().c_str()); + table_catalog_entry->GetTableName().c_str()); return false; } - table_objects_cache.insert( - std::make_pair(table_object->GetTableOid(), table_object)); - table_name_cache.insert(std::make_pair(key, table_object)); + table_catalog_entries_cache_.insert( + std::make_pair(table_catalog_entry->GetTableOid(), table_catalog_entry)); + table_catalog_entries_cache_by_name.insert(std::make_pair(key, table_catalog_entry)); return true; } @@ -71,20 +71,20 @@ bool DatabaseCatalogObject::InsertTableObject( * @param table_oid * @return true if table_oid is found and evicted; false if not found */ -bool DatabaseCatalogObject::EvictTableObject(oid_t table_oid) { +bool DatabaseCatalogEntry::EvictTableCatalogEntry(oid_t table_oid) { // find table name from table name cache - auto it = table_objects_cache.find(table_oid); - if (it == table_objects_cache.end()) { + auto it = table_catalog_entries_cache_.find(table_oid); + if (it == table_catalog_entries_cache_.end()) { return false; // table oid not found in cache } auto table_object = it->second; PELOTON_ASSERT(table_object); - table_objects_cache.erase(it); + table_catalog_entries_cache_.erase(it); // erase from table name cache std::string key = table_object->GetSchemaName() + "." + table_object->GetTableName(); - table_name_cache.erase(key); + table_catalog_entries_cache_by_name.erase(key); return true; } @@ -92,27 +92,27 @@ bool DatabaseCatalogObject::EvictTableObject(oid_t table_oid) { * @param table_name * @return true if table_name is found and evicted; false if not found */ -bool DatabaseCatalogObject::EvictTableObject(const std::string &table_name, - const std::string &schema_name) { +bool DatabaseCatalogEntry::EvictTableCatalogEntry(const std::string &table_name, + const std::string &schema_name) { std::string key = schema_name + "." + table_name; // find table name from table name cache - auto it = table_name_cache.find(key); - if (it == table_name_cache.end()) { + auto it = table_catalog_entries_cache_by_name.find(key); + if (it == table_catalog_entries_cache_by_name.end()) { return false; // table name not found in cache } auto table_object = it->second; PELOTON_ASSERT(table_object); - table_name_cache.erase(it); - table_objects_cache.erase(table_object->GetTableOid()); + table_catalog_entries_cache_by_name.erase(it); + table_catalog_entries_cache_.erase(table_object->GetTableOid()); return true; } /*@brief evict all table catalog objects in this database from cache */ -void DatabaseCatalogObject::EvictAllTableObjects() { - table_objects_cache.clear(); - table_name_cache.clear(); +void DatabaseCatalogEntry::EvictAllTableCatalogEntries() { + table_catalog_entries_cache_.clear(); + table_catalog_entries_cache_by_name.clear(); } /* @brief Get table catalog object from cache or all the way from storage @@ -120,10 +120,10 @@ void DatabaseCatalogObject::EvictAllTableObjects() { * @param cached_only if cached only, return nullptr on a cache miss * @return Shared pointer to the requested table catalog object */ -std::shared_ptr DatabaseCatalogObject::GetTableObject( +std::shared_ptr DatabaseCatalogEntry::GetTableCatalogEntry( oid_t table_oid, bool cached_only) { - auto it = table_objects_cache.find(table_oid); - if (it != table_objects_cache.end()) return it->second; + auto it = table_catalog_entries_cache_.find(table_oid); + if (it != table_catalog_entries_cache_.end()) return it->second; if (cached_only) { // cache miss return empty object @@ -131,9 +131,9 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( } else { // cache miss get from pg_table auto pg_table = Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) + ->GetSystemCatalogs(database_oid_) ->GetTableCatalog(); - return pg_table->GetTableObject(table_oid, txn); + return pg_table->GetTableCatalogEntry(txn_, table_oid); } } @@ -144,12 +144,12 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( * @param cached_only if cached only, return nullptr on a cache miss * @return Shared pointer to the requested table catalog object */ -std::shared_ptr DatabaseCatalogObject::GetTableObject( +std::shared_ptr DatabaseCatalogEntry::GetTableCatalogEntry( const std::string &table_name, const std::string &schema_name, bool cached_only) { std::string key = schema_name + "." + table_name; - auto it = table_name_cache.find(key); - if (it != table_name_cache.end()) { + auto it = table_catalog_entries_cache_by_name.find(key); + if (it != table_catalog_entries_cache_by_name.end()) { return it->second; } @@ -159,9 +159,9 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( } else { // cache miss get from pg_table auto pg_table = Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) + ->GetSystemCatalogs(database_oid_) ->GetTableCatalog(); - return pg_table->GetTableObject(table_name, schema_name, txn); + return pg_table->GetTableCatalogEntry(txn_, schema_name, table_name); } } @@ -170,20 +170,20 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( * @param schema_name * @return table catalog objects */ -std::vector> -DatabaseCatalogObject::GetTableObjects(const std::string &schema_name) { +std::vector> +DatabaseCatalogEntry::GetTableCatalogEntries(const std::string &schema_name) { // read directly from pg_table - if (!valid_table_objects) { + if (!valid_table_catalog_entries) { auto pg_table = Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) + ->GetSystemCatalogs(database_oid_) ->GetTableCatalog(); // insert every table object into cache - pg_table->GetTableObjects(txn); + pg_table->GetTableCatalogEntries(txn_); } // make sure to check IsValidTableObjects() before getting table objects - PELOTON_ASSERT(valid_table_objects); - std::vector> result; - for (auto it : table_objects_cache) { + PELOTON_ASSERT(valid_table_catalog_entries); + std::vector> result; + for (auto it : table_catalog_entries_cache_) { if (it.second->GetSchemaName() == schema_name) { result.push_back(it.second); } @@ -197,30 +197,30 @@ DatabaseCatalogObject::GetTableObjects(const std::string &schema_name) { * @param cached_only if cached only, return nullptr on a cache miss * @return Shared pointer to the requested table catalog object */ -std::unordered_map> -DatabaseCatalogObject::GetTableObjects(bool cached_only) { - if (!cached_only && !valid_table_objects) { +std::unordered_map> +DatabaseCatalogEntry::GetTableCatalogEntries(bool cached_only) { + if (!cached_only && !valid_table_catalog_entries) { // cache miss get from pg_table auto pg_table = Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) + ->GetSystemCatalogs(database_oid_) ->GetTableCatalog(); - return pg_table->GetTableObjects(txn); + return pg_table->GetTableCatalogEntries(txn_); } // make sure to check IsValidTableObjects() before getting table objects - PELOTON_ASSERT(valid_table_objects); - return table_objects_cache; + PELOTON_ASSERT(valid_table_catalog_entries); + return table_catalog_entries_cache_; } /*@brief search index catalog object from all cached database objects * @param index_oid * @return index catalog object; if not found return null */ -std::shared_ptr DatabaseCatalogObject::GetCachedIndexObject( +std::shared_ptr DatabaseCatalogEntry::GetCachedIndexCatalogEntry( oid_t index_oid) { - for (auto it = table_objects_cache.begin(); it != table_objects_cache.end(); + for (auto it = table_catalog_entries_cache_.begin(); it != table_catalog_entries_cache_.end(); ++it) { auto table_object = it->second; - auto index_object = table_object->GetIndexObject(index_oid, true); + auto index_object = table_object->GetIndexCatalogEntries(index_oid, true); if (index_object) return index_object; } return nullptr; @@ -230,37 +230,44 @@ std::shared_ptr DatabaseCatalogObject::GetCachedIndexObject( * @param index_name * @return index catalog object; if not found return null */ -std::shared_ptr DatabaseCatalogObject::GetCachedIndexObject( +std::shared_ptr DatabaseCatalogEntry::GetCachedIndexCatalogEntry( const std::string &index_name, const std::string &schema_name) { - for (auto it = table_objects_cache.begin(); it != table_objects_cache.end(); + for (auto it = table_catalog_entries_cache_.begin(); it != table_catalog_entries_cache_.end(); ++it) { auto table_object = it->second; if (table_object != nullptr && table_object->GetSchemaName() == schema_name) { - auto index_object = table_object->GetIndexObject(index_name, true); + auto index_object = table_object->GetIndexCatalogEntry(index_name, true); if (index_object) return index_object; } } return nullptr; } -DatabaseCatalog *DatabaseCatalog::GetInstance( - storage::Database *pg_catalog, type::AbstractPool *pool, - concurrency::TransactionContext *txn) { - static DatabaseCatalog database_catalog{pg_catalog, pool, txn}; +DatabaseCatalog *DatabaseCatalog::GetInstance(concurrency::TransactionContext *txn, + storage::Database *pg_catalog, + type::AbstractPool *pool) { + static DatabaseCatalog + database_catalog{txn, pg_catalog, pool}; return &database_catalog; } -DatabaseCatalog::DatabaseCatalog( - storage::Database *pg_catalog, UNUSED_ATTRIBUTE type::AbstractPool *pool, - UNUSED_ATTRIBUTE concurrency::TransactionContext *txn) - : AbstractCatalog(DATABASE_CATALOG_OID, DATABASE_CATALOG_NAME, - InitializeSchema().release(), pg_catalog) { +DatabaseCatalog::DatabaseCatalog(concurrency::TransactionContext *, + storage::Database *pg_catalog, + type::AbstractPool *) + : AbstractCatalog(pg_catalog, + InitializeSchema().release(), + DATABASE_CATALOG_OID, + DATABASE_CATALOG_NAME) { // Add indexes for pg_database - AddIndex({ColumnId::DATABASE_OID}, DATABASE_CATALOG_PKEY_OID, - DATABASE_CATALOG_NAME "_pkey", IndexConstraintType::PRIMARY_KEY); - AddIndex({ColumnId::DATABASE_NAME}, DATABASE_CATALOG_SKEY0_OID, - DATABASE_CATALOG_NAME "_skey0", IndexConstraintType::UNIQUE); + AddIndex(DATABASE_CATALOG_NAME "_pkey", + DATABASE_CATALOG_PKEY_OID, + {ColumnId::DATABASE_OID}, + IndexConstraintType::PRIMARY_KEY); + AddIndex(DATABASE_CATALOG_NAME "_skey0", + DATABASE_CATALOG_SKEY0_OID, + {ColumnId::DATABASE_NAME}, + IndexConstraintType::UNIQUE); } DatabaseCatalog::~DatabaseCatalog() {} @@ -281,7 +288,7 @@ std::unique_ptr DatabaseCatalog::InitializeSchema() { catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); auto database_name_column = catalog::Column( - type::TypeId::VARCHAR, max_name_size, "database_name", false); + type::TypeId::VARCHAR, max_name_size_, "database_name", false); database_name_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); @@ -290,10 +297,10 @@ std::unique_ptr DatabaseCatalog::InitializeSchema() { return database_catalog_schema; } -bool DatabaseCatalog::InsertDatabase(oid_t database_oid, +bool DatabaseCatalog::InsertDatabase(concurrency::TransactionContext *txn, + oid_t database_oid, const std::string &database_name, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { + type::AbstractPool *pool) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -304,11 +311,10 @@ bool DatabaseCatalog::InsertDatabase(oid_t database_oid, tuple->SetValue(ColumnId::DATABASE_NAME, val1, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } -bool DatabaseCatalog::DeleteDatabase(oid_t database_oid, - concurrency::TransactionContext *txn) { +bool DatabaseCatalog::DeleteDatabase(concurrency::TransactionContext *txn, oid_t database_oid) { oid_t index_offset = IndexId::PRIMARY_KEY; // Index of database_oid std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); @@ -316,11 +322,12 @@ bool DatabaseCatalog::DeleteDatabase(oid_t database_oid, // evict cache txn->catalog_cache.EvictDatabaseObject(database_oid); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } -std::shared_ptr DatabaseCatalog::GetDatabaseObject( - oid_t database_oid, concurrency::TransactionContext *txn) { +std::shared_ptr DatabaseCatalog::GetDatabaseCatalogEntry( + concurrency::TransactionContext *txn, + oid_t database_oid) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } @@ -329,17 +336,20 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( if (database_object) return database_object; // cache miss, get from pg_database - std::vector column_ids(all_column_ids); + std::vector column_ids(all_column_ids_); oid_t index_offset = IndexId::PRIMARY_KEY; // Index of database_oid std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { auto database_object = - std::make_shared((*result_tiles)[0].get(), txn); + std::make_shared(txn, (*result_tiles)[0].get()); // insert into cache bool success = txn->catalog_cache.InsertDatabaseObject(database_object); PELOTON_ASSERT(success == true); @@ -358,8 +368,9 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( * construct database object from pg_database, and insert into the * cache. */ -std::shared_ptr DatabaseCatalog::GetDatabaseObject( - const std::string &database_name, concurrency::TransactionContext *txn) { +std::shared_ptr DatabaseCatalog::GetDatabaseCatalogEntry( + concurrency::TransactionContext *txn, + const std::string &database_name) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } @@ -368,18 +379,21 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( if (database_object) return database_object; // cache miss, get from pg_database - std::vector column_ids(all_column_ids); + std::vector column_ids(all_column_ids_); oid_t index_offset = IndexId::SKEY_DATABASE_NAME; // Index of database_name std::vector values; values.push_back( type::ValueFactory::GetVarcharValue(database_name, nullptr).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { auto database_object = - std::make_shared((*result_tiles)[0].get(), txn); + std::make_shared(txn, (*result_tiles)[0].get()); if (database_object) { // insert into cache bool success = txn->catalog_cache.InsertDatabaseObject(database_object); diff --git a/src/catalog/database_metrics_catalog.cpp b/src/catalog/database_metrics_catalog.cpp index 4fb04fbbb88..83ce60bedbf 100644 --- a/src/catalog/database_metrics_catalog.cpp +++ b/src/catalog/database_metrics_catalog.cpp @@ -27,23 +27,24 @@ DatabaseMetricsCatalog *DatabaseMetricsCatalog::GetInstance( DatabaseMetricsCatalog::DatabaseMetricsCatalog( concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." CATALOG_SCHEMA_NAME "." DATABASE_METRICS_CATALOG_NAME - " (" - "database_oid INT NOT NULL, " - "txn_committed INT NOT NULL, " - "txn_aborted INT NOT NULL, " - "time_stamp INT NOT NULL);", - txn) { + : AbstractCatalog(txn, "CREATE TABLE " CATALOG_DATABASE_NAME + "." CATALOG_SCHEMA_NAME "." DATABASE_METRICS_CATALOG_NAME + " (" + "database_oid INT NOT NULL, " + "txn_committed INT NOT NULL, " + "txn_aborted INT NOT NULL, " + "time_stamp INT NOT NULL);") { // Add secondary index here if necessary } DatabaseMetricsCatalog::~DatabaseMetricsCatalog() {} -bool DatabaseMetricsCatalog::InsertDatabaseMetrics( - oid_t database_oid, oid_t txn_committed, oid_t txn_aborted, - oid_t time_stamp, type::AbstractPool *pool, - concurrency::TransactionContext *txn) { +bool DatabaseMetricsCatalog::InsertDatabaseMetrics(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t txn_committed, + oid_t txn_aborted, + oid_t time_stamp, + type::AbstractPool *pool) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -58,17 +59,17 @@ bool DatabaseMetricsCatalog::InsertDatabaseMetrics( tuple->SetValue(ColumnId::TIME_STAMP, val3, pool); // Insert the tuple into catalog table - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } -bool DatabaseMetricsCatalog::DeleteDatabaseMetrics( - oid_t database_oid, concurrency::TransactionContext *txn) { +bool DatabaseMetricsCatalog::DeleteDatabaseMetrics(concurrency::TransactionContext *txn, + oid_t database_oid) { oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } } // namespace catalog diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index 066590ac4d1..eaab5f3cfa7 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -26,21 +26,21 @@ namespace peloton { namespace catalog { -IndexCatalogObject::IndexCatalogObject(executor::LogicalTile *tile, int tupleId) - : index_oid(tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEX_OID) +IndexCatalogEntry::IndexCatalogEntry(executor::LogicalTile *tile, int tupleId) + : index_oid_(tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEX_OID) .GetAs()), - index_name(tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEX_NAME) + index_name_(tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEX_NAME) .ToString()), - table_oid(tile->GetValue(tupleId, IndexCatalog::ColumnId::TABLE_OID) + table_oid_(tile->GetValue(tupleId, IndexCatalog::ColumnId::TABLE_OID) .GetAs()), - schema_name(tile->GetValue(tupleId, IndexCatalog::ColumnId::SCHEMA_NAME) + schema_name_(tile->GetValue(tupleId, IndexCatalog::ColumnId::SCHEMA_NAME) .ToString()), - index_type(tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEX_TYPE) + index_type_(tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEX_TYPE) .GetAs()), - index_constraint( + index_constraint_( tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEX_CONSTRAINT) .GetAs()), - unique_keys(tile->GetValue(tupleId, IndexCatalog::ColumnId::UNIQUE_KEYS) + unique_keys_(tile->GetValue(tupleId, IndexCatalog::ColumnId::UNIQUE_KEYS) .GetAs()) { std::string attr_str = tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEXED_ATTRIBUTES) @@ -49,22 +49,30 @@ IndexCatalogObject::IndexCatalogObject(executor::LogicalTile *tile, int tupleId) std::string tok; while (std::getline(ss, tok, ' ')) { - key_attrs.push_back(std::stoi(tok)); + key_attrs_.push_back(std::stoi(tok)); } - LOG_TRACE("the size for indexed key is %lu", key_attrs.size()); + LOG_TRACE("the size for indexed key is %lu", key_attrs_.size()); } -IndexCatalog::IndexCatalog( - storage::Database *pg_catalog, UNUSED_ATTRIBUTE type::AbstractPool *pool, - UNUSED_ATTRIBUTE concurrency::TransactionContext *txn) - : AbstractCatalog(INDEX_CATALOG_OID, INDEX_CATALOG_NAME, - InitializeSchema().release(), pg_catalog) { +IndexCatalog::IndexCatalog(concurrency::TransactionContext *, + storage::Database *pg_catalog, + type::AbstractPool *) + : AbstractCatalog(pg_catalog, + InitializeSchema().release(), + INDEX_CATALOG_OID, + INDEX_CATALOG_NAME) { // Add indexes for pg_index - AddIndex({0}, INDEX_CATALOG_PKEY_OID, INDEX_CATALOG_NAME "_pkey", + AddIndex(INDEX_CATALOG_NAME "_pkey", + INDEX_CATALOG_PKEY_OID, + {0}, IndexConstraintType::PRIMARY_KEY); - AddIndex({1, 3}, INDEX_CATALOG_SKEY0_OID, INDEX_CATALOG_NAME "_skey0", + AddIndex(INDEX_CATALOG_NAME "_skey0", + INDEX_CATALOG_SKEY0_OID, + {1, 3}, IndexConstraintType::UNIQUE); - AddIndex({2}, INDEX_CATALOG_SKEY1_OID, INDEX_CATALOG_NAME "_skey1", + AddIndex(INDEX_CATALOG_NAME "_skey1", + INDEX_CATALOG_SKEY1_OID, + {2}, IndexConstraintType::DEFAULT); } @@ -85,7 +93,7 @@ std::unique_ptr IndexCatalog::InitializeSchema() { index_id_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); - auto index_name_column = catalog::Column(type::TypeId::VARCHAR, max_name_size, + auto index_name_column = catalog::Column(type::TypeId::VARCHAR, max_name_size_, "index_name", false); index_name_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); @@ -97,7 +105,7 @@ std::unique_ptr IndexCatalog::InitializeSchema() { catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); auto schema_name_column = catalog::Column( - type::TypeId::VARCHAR, max_name_size, "schema_name", false); + type::TypeId::VARCHAR, max_name_size_, "schema_name", false); schema_name_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); @@ -120,7 +128,7 @@ std::unique_ptr IndexCatalog::InitializeSchema() { catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); auto indexed_attributes_column = catalog::Column( - type::TypeId::VARCHAR, max_name_size, "indexed_attributes", false); + type::TypeId::VARCHAR, max_name_size_, "indexed_attributes", false); indexed_attributes_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); std::unique_ptr index_schema(new catalog::Schema( @@ -130,13 +138,16 @@ std::unique_ptr IndexCatalog::InitializeSchema() { return index_schema; } -bool IndexCatalog::InsertIndex(oid_t index_oid, const std::string &index_name, - oid_t table_oid, const std::string &schema_name, +bool IndexCatalog::InsertIndex(concurrency::TransactionContext *txn, + const std::string &schema_name, + oid_t table_oid, + oid_t index_oid, + const std::string &index_name, IndexType index_type, IndexConstraintType index_constraint, - bool unique_keys, std::vector indekeys, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { + bool unique_keys, + std::vector index_keys, + type::AbstractPool *pool) { // Create the tuple first std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -151,7 +162,7 @@ bool IndexCatalog::InsertIndex(oid_t index_oid, const std::string &index_name, auto val6 = type::ValueFactory::GetBooleanValue(unique_keys); std::stringstream os; - for (oid_t indkey : indekeys) os << std::to_string(indkey) << " "; + for (oid_t indkey : index_keys) os << std::to_string(indkey) << " "; auto val7 = type::ValueFactory::GetVarcharValue(os.str(), nullptr); tuple->SetValue(IndexCatalog::ColumnId::INDEX_OID, val0, pool); @@ -164,11 +175,12 @@ bool IndexCatalog::InsertIndex(oid_t index_oid, const std::string &index_name, tuple->SetValue(IndexCatalog::ColumnId::INDEXED_ATTRIBUTES, val7, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } -bool IndexCatalog::DeleteIndex(oid_t database_oid, oid_t index_oid, - concurrency::TransactionContext *txn) { +bool IndexCatalog::DeleteIndex(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t index_oid) { oid_t index_offset = IndexId::PRIMARY_KEY; // Index of index_oid std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(index_oid).Copy()); @@ -179,14 +191,16 @@ bool IndexCatalog::DeleteIndex(oid_t database_oid, oid_t index_oid, auto table_object = txn->catalog_cache.GetCachedTableObject(database_oid, index_object->GetTableOid()); - table_object->EvictAllIndexObjects(); + table_object->EvictAllIndexCatalogEntries(); } - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } -std::shared_ptr IndexCatalog::GetIndexObject( - oid_t database_oid, oid_t index_oid, concurrency::TransactionContext *txn) { +std::shared_ptr IndexCatalog::GetIndexCatalogEntry( + concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t index_oid) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } @@ -204,20 +218,23 @@ std::shared_ptr IndexCatalog::GetIndexObject( values.push_back(type::ValueFactory::GetIntegerValue(index_oid).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { auto index_object = - std::make_shared((*result_tiles)[0].get()); + std::make_shared((*result_tiles)[0].get()); // fetch all indexes into table object (cannot use the above index object) auto pg_table = Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); auto table_object = - pg_table->GetTableObject(index_object->GetTableOid(), txn); + pg_table->GetTableCatalogEntry(txn, index_object->GetTableOid()); PELOTON_ASSERT(table_object && table_object->GetTableOid() == index_object->GetTableOid()); - return table_object->GetIndexObject(index_oid); + return table_object->GetIndexCatalogEntries(index_oid); } else { LOG_DEBUG("Found %lu index with oid %u", result_tiles->size(), index_oid); } @@ -226,16 +243,19 @@ std::shared_ptr IndexCatalog::GetIndexObject( return nullptr; } -std::shared_ptr IndexCatalog::GetIndexObject( - const std::string &database_name, const std::string &index_name, - const std::string &schema_name, concurrency::TransactionContext *txn) { +std::shared_ptr IndexCatalog::GetIndexCatalogEntry( + concurrency::TransactionContext *txn, + const std::string &database_name, + const std::string &schema_name, + const std::string &index_name) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } // try get from cache auto index_object = - txn->catalog_cache.GetCachedIndexObject(database_name, index_name, - schema_name); + txn->catalog_cache.GetCachedIndexObject(database_name, + schema_name, + index_name); if (index_object) { return index_object; } @@ -251,20 +271,23 @@ std::shared_ptr IndexCatalog::GetIndexObject( type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { auto index_object = - std::make_shared((*result_tiles)[0].get()); + std::make_shared((*result_tiles)[0].get()); // fetch all indexes into table object (cannot use the above index object) auto pg_table = Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) + ->GetSystemCatalogs(database_oid_) ->GetTableCatalog(); auto table_object = - pg_table->GetTableObject(index_object->GetTableOid(), txn); + pg_table->GetTableCatalogEntry(txn, index_object->GetTableOid()); PELOTON_ASSERT(table_object && table_object->GetTableOid() == index_object->GetTableOid()); - return table_object->GetIndexObject(index_name); + return table_object->GetIndexCatalogEntry(index_name); } else { LOG_DEBUG("Found %lu index with name %s", result_tiles->size(), index_name.c_str()); @@ -280,19 +303,21 @@ std::shared_ptr IndexCatalog::GetIndexObject( * @param txn TransactionContext * @return a vector of index catalog objects */ -const std::unordered_map> -IndexCatalog::GetIndexObjects(oid_t table_oid, - concurrency::TransactionContext *txn) { +const std::unordered_map> +IndexCatalog::GetIndexCatalogEntries( + concurrency::TransactionContext *txn, + oid_t table_oid) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } // try get from cache auto pg_table = Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) + ->GetSystemCatalogs(database_oid_) ->GetTableCatalog(); - auto table_object = pg_table->GetTableObject(table_oid, txn); + auto table_object = pg_table->GetTableCatalogEntry(txn, table_oid); PELOTON_ASSERT(table_object && table_object->GetTableOid() == table_oid); - auto index_objects = table_object->GetIndexObjects(true); + auto index_objects = table_object->GetIndexCatalogEntries(true); if (index_objects.empty() == false) return index_objects; // cache miss, get from pg_index @@ -302,17 +327,20 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); for (auto &tile : (*result_tiles)) { for (auto tuple_id : *tile) { auto index_object = - std::make_shared(tile.get(), tuple_id); - table_object->InsertIndexObject(index_object); + std::make_shared(tile.get(), tuple_id); + table_object->InsertIndexCatalogEntry(index_object); } } - return table_object->GetIndexObjects(); + return table_object->GetIndexCatalogEntries(); } } // namespace catalog diff --git a/src/catalog/index_metrics_catalog.cpp b/src/catalog/index_metrics_catalog.cpp index e744765ef96..3d7c730f31e 100644 --- a/src/catalog/index_metrics_catalog.cpp +++ b/src/catalog/index_metrics_catalog.cpp @@ -19,27 +19,30 @@ namespace peloton { namespace catalog { -IndexMetricsCatalog::IndexMetricsCatalog(const std::string &database_name, - concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " + database_name + - "." CATALOG_SCHEMA_NAME "." INDEX_METRICS_CATALOG_NAME - " (" - "table_oid INT NOT NULL, " - "index_oid INT NOT NULL, " - "reads INT NOT NULL, " - "deletes INT NOT NULL, " - "inserts INT NOT NULL, " - "time_stamp INT NOT NULL);", - txn) { +IndexMetricsCatalog::IndexMetricsCatalog(concurrency::TransactionContext *txn, + const std::string &database_name) + : AbstractCatalog(txn, "CREATE TABLE " + database_name + + "." CATALOG_SCHEMA_NAME "." INDEX_METRICS_CATALOG_NAME + " (" + "table_oid INT NOT NULL, " + "index_oid INT NOT NULL, " + "reads INT NOT NULL, " + "deletes INT NOT NULL, " + "inserts INT NOT NULL, " + "time_stamp INT NOT NULL);") { // Add secondary index here if necessary } IndexMetricsCatalog::~IndexMetricsCatalog() {} -bool IndexMetricsCatalog::InsertIndexMetrics( - oid_t table_oid, oid_t index_oid, int64_t reads, int64_t deletes, - int64_t inserts, int64_t time_stamp, type::AbstractPool *pool, - concurrency::TransactionContext *txn) { +bool IndexMetricsCatalog::InsertIndexMetrics(concurrency::TransactionContext *txn, + oid_t table_oid, + oid_t index_oid, + int64_t reads, + int64_t deletes, + int64_t inserts, + int64_t time_stamp, + type::AbstractPool *pool) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -58,17 +61,16 @@ bool IndexMetricsCatalog::InsertIndexMetrics( tuple->SetValue(ColumnId::TIME_STAMP, val6, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } -bool IndexMetricsCatalog::DeleteIndexMetrics( - oid_t index_oid, concurrency::TransactionContext *txn) { +bool IndexMetricsCatalog::DeleteIndexMetrics(concurrency::TransactionContext *txn, oid_t index_oid) { oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(index_oid).Copy()); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } } // namespace catalog diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index ddcceb6d89d..e3a7ce1924d 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -20,7 +20,7 @@ namespace peloton { namespace catalog { -LanguageCatalogObject::LanguageCatalogObject(executor::LogicalTile *tuple) +LanguageCatalogEntry::LanguageCatalogEntry(executor::LogicalTile *tuple) : lang_oid_(tuple->GetValue(0, 0).GetAs()), lang_name_(tuple->GetValue(0, 1).GetAs()) {} @@ -33,21 +33,25 @@ LanguageCatalog &LanguageCatalog::GetInstance( LanguageCatalog::~LanguageCatalog(){}; LanguageCatalog::LanguageCatalog(concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." CATALOG_SCHEMA_NAME "." LANGUAGE_CATALOG_NAME - " (" - "language_oid INT NOT NULL PRIMARY KEY, " - "lanname VARCHAR NOT NULL);", - txn) { - Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, LANGUAGE_CATALOG_NAME, {1}, - LANGUAGE_CATALOG_NAME "_skey0", false, IndexType::BWTREE, txn); + : AbstractCatalog(txn, "CREATE TABLE " CATALOG_DATABASE_NAME + "." CATALOG_SCHEMA_NAME "." LANGUAGE_CATALOG_NAME + " (" + "language_oid INT NOT NULL PRIMARY KEY, " + "lanname VARCHAR NOT NULL);") { + Catalog::GetInstance()->CreateIndex(txn, + CATALOG_DATABASE_NAME, + CATALOG_SCHEMA_NAME, + LANGUAGE_CATALOG_NAME, + LANGUAGE_CATALOG_NAME "_skey0", + {1}, + false, + IndexType::BWTREE); } // insert a new language by name -bool LanguageCatalog::InsertLanguage(const std::string &lanname, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { +bool LanguageCatalog::InsertLanguage(concurrency::TransactionContext *txn, + const std::string &lanname, + type::AbstractPool *pool) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -59,56 +63,62 @@ bool LanguageCatalog::InsertLanguage(const std::string &lanname, tuple->SetValue(ColumnId::LANNAME, val1, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } // delete a language by name -bool LanguageCatalog::DeleteLanguage(const std::string &lanname, - concurrency::TransactionContext *txn) { +bool LanguageCatalog::DeleteLanguage(concurrency::TransactionContext *txn, + const std::string &lanname) { oid_t index_offset = IndexId::SECONDARY_KEY_0; std::vector values; values.push_back( type::ValueFactory::GetVarcharValue(lanname, nullptr).Copy()); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } -std::unique_ptr LanguageCatalog::GetLanguageByOid( - oid_t lang_oid, concurrency::TransactionContext *txn) const { - std::vector column_ids(all_column_ids); +std::unique_ptr LanguageCatalog::GetLanguageByOid(concurrency::TransactionContext *txn, + oid_t lang_oid) const { + std::vector column_ids(all_column_ids_); oid_t index_offset = IndexId::PRIMARY_KEY; std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(lang_oid).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); PELOTON_ASSERT(result_tiles->size() <= 1); - std::unique_ptr ret; + std::unique_ptr ret; if (result_tiles->size() == 1) { PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - ret.reset(new LanguageCatalogObject((*result_tiles)[0].get())); + ret.reset(new LanguageCatalogEntry((*result_tiles)[0].get())); } return ret; } -std::unique_ptr LanguageCatalog::GetLanguageByName( - const std::string &lang_name, concurrency::TransactionContext *txn) const { - std::vector column_ids(all_column_ids); +std::unique_ptr LanguageCatalog::GetLanguageByName(concurrency::TransactionContext *txn, + const std::string &lang_name) const { + std::vector column_ids(all_column_ids_); oid_t index_offset = IndexId::SECONDARY_KEY_0; std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(lang_name).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); PELOTON_ASSERT(result_tiles->size() <= 1); - std::unique_ptr ret; + std::unique_ptr ret; if (result_tiles->size() == 1) { PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - ret.reset(new LanguageCatalogObject((*result_tiles)[0].get())); + ret.reset(new LanguageCatalogEntry((*result_tiles)[0].get())); } return ret; diff --git a/src/catalog/layout_catalog.cpp b/src/catalog/layout_catalog.cpp index 2189426fb0d..8db442a03e0 100644 --- a/src/catalog/layout_catalog.cpp +++ b/src/catalog/layout_catalog.cpp @@ -26,16 +26,22 @@ namespace catalog { /** @brief Constructor invoked by the SystemsCatalog constructor. * @param pg_catalog The database to which this pg_layout belongs. */ -LayoutCatalog::LayoutCatalog( - storage::Database *pg_catalog, UNUSED_ATTRIBUTE type::AbstractPool *pool, - UNUSED_ATTRIBUTE concurrency::TransactionContext *txn) - : AbstractCatalog(LAYOUT_CATALOG_OID, LAYOUT_CATALOG_NAME, - InitializeSchema().release(), pg_catalog) { +LayoutCatalog::LayoutCatalog(concurrency::TransactionContext *, + storage::Database *pg_catalog, + type::AbstractPool *) + : AbstractCatalog(pg_catalog, + InitializeSchema().release(), + LAYOUT_CATALOG_OID, + LAYOUT_CATALOG_NAME) { // Add indexes for pg_attribute - AddIndex({ColumnId::TABLE_OID, ColumnId::LAYOUT_OID}, LAYOUT_CATALOG_PKEY_OID, - LAYOUT_CATALOG_NAME "_pkey", IndexConstraintType::PRIMARY_KEY); - AddIndex({ColumnId::TABLE_OID}, LAYOUT_CATALOG_SKEY0_OID, - LAYOUT_CATALOG_NAME "_skey0", IndexConstraintType::DEFAULT); + AddIndex(LAYOUT_CATALOG_NAME "_pkey", + LAYOUT_CATALOG_PKEY_OID, + {ColumnId::TABLE_OID, ColumnId::LAYOUT_OID}, + IndexConstraintType::PRIMARY_KEY); + AddIndex(LAYOUT_CATALOG_NAME "_skey0", + LAYOUT_CATALOG_SKEY0_OID, + {ColumnId::TABLE_OID}, + IndexConstraintType::DEFAULT); } /** @brief Destructor. Do nothing. Layouts will be dropped by DropTable. */ LayoutCatalog::~LayoutCatalog() {} @@ -89,10 +95,10 @@ std::unique_ptr LayoutCatalog::InitializeSchema() { * @param txn TransactionContext for adding the layout. * @return true on success. */ -bool LayoutCatalog::InsertLayout(oid_t table_oid, +bool LayoutCatalog::InsertLayout(concurrency::TransactionContext *txn, + oid_t table_oid, std::shared_ptr layout, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { + type::AbstractPool *pool) { // Create the tuple first std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -109,7 +115,7 @@ bool LayoutCatalog::InsertLayout(oid_t table_oid, tuple->SetValue(LayoutCatalog::ColumnId::COLUMN_MAP, val3, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } /** @brief Delete a layout from the pg_layout table. @@ -118,8 +124,9 @@ bool LayoutCatalog::InsertLayout(oid_t table_oid, * @param txn TransactionContext for deleting the layout. * @return true on success. */ -bool LayoutCatalog::DeleteLayout(oid_t table_oid, oid_t layout_oid, - concurrency::TransactionContext *txn) { +bool LayoutCatalog::DeleteLayout(concurrency::TransactionContext *txn, + oid_t table_oid, + oid_t layout_oid) { oid_t index_offset = IndexId::PRIMARY_KEY; // Index of table_oid & layout_oid std::vector values; @@ -127,14 +134,14 @@ bool LayoutCatalog::DeleteLayout(oid_t table_oid, oid_t layout_oid, values.push_back(type::ValueFactory::GetIntegerValue(layout_oid).Copy()); auto pg_table = Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) + ->GetSystemCatalogs(database_oid_) ->GetTableCatalog(); // delete column from cache - auto table_object = pg_table->GetTableObject(table_oid, txn); + auto table_object = pg_table->GetTableCatalogEntry(txn, table_oid); table_object->EvictLayout(layout_oid); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } /** @brief Delete all layouts correponding to a table from the pg_layout. @@ -142,20 +149,19 @@ bool LayoutCatalog::DeleteLayout(oid_t table_oid, oid_t layout_oid, * @param txn TransactionContext for deleting the layouts. * @return true on success. */ -bool LayoutCatalog::DeleteLayouts(oid_t table_oid, - concurrency::TransactionContext *txn) { +bool LayoutCatalog::DeleteLayouts(concurrency::TransactionContext *txn, oid_t table_oid) { oid_t index_offset = IndexId::SKEY_TABLE_OID; // Index of table_oid std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); // delete layouts from cache auto pg_table = Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) + ->GetSystemCatalogs(database_oid_) ->GetTableCatalog(); - auto table_object = pg_table->GetTableObject(table_oid, txn); + auto table_object = pg_table->GetTableCatalogEntry(txn, table_oid); table_object->EvictAllLayouts(); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } /** @brief Get all layouts correponding to a table from the pg_layout. @@ -163,14 +169,16 @@ bool LayoutCatalog::DeleteLayouts(oid_t table_oid, * @param txn TransactionContext for getting the layouts. * @return unordered_map containing a layout_oid -> layout mapping. */ -const std::unordered_map> -LayoutCatalog::GetLayouts(oid_t table_oid, - concurrency::TransactionContext *txn) { +const std::unordered_map> +LayoutCatalog::GetLayouts( +concurrency::TransactionContext *txn, +oid_t table_oid) { // Try to find the layouts in the cache auto pg_table = Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) + ->GetSystemCatalogs(database_oid_) ->GetTableCatalog(); - auto table_object = pg_table->GetTableObject(table_oid, txn); + auto table_object = pg_table->GetTableCatalogEntry(txn, table_oid); PELOTON_ASSERT(table_object && table_object->GetTableOid() == table_oid); auto layout_objects = table_object->GetLayouts(true); if (layout_objects.size() != 0) { @@ -178,13 +186,16 @@ LayoutCatalog::GetLayouts(oid_t table_oid, } // Cache miss, get from pg_catalog - std::vector column_ids(all_column_ids); + std::vector column_ids(all_column_ids_); oid_t index_offset = IndexId::SKEY_TABLE_OID; // Index of table_oid std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); for (auto &tile : (*result_tiles)) { // Iterate through the result_tiles for (auto tuple_id : *tile) { @@ -220,9 +231,10 @@ LayoutCatalog::GetLayouts(oid_t table_oid, * @return shared_ptr corresponding to the layout_oid if found. * nullptr otherwise. */ -std::shared_ptr LayoutCatalog::GetLayoutWithOid( - oid_t table_oid, oid_t layout_oid, concurrency::TransactionContext *txn) { - auto table_layouts = GetLayouts(table_oid, txn); +std::shared_ptr LayoutCatalog::GetLayoutWithOid(concurrency::TransactionContext *txn, + oid_t table_oid, + oid_t layout_oid) { + auto table_layouts = GetLayouts(txn, table_oid); for (const auto &layout_entry : table_layouts) { if (layout_entry.second->GetOid() == layout_oid) { return layout_entry.second; diff --git a/src/catalog/multi_constraint.cpp b/src/catalog/multi_constraint.cpp index 0261bccc3c2..d1e4e3d9817 100644 --- a/src/catalog/multi_constraint.cpp +++ b/src/catalog/multi_constraint.cpp @@ -21,9 +21,9 @@ namespace catalog { const std::string MultiConstraint::GetInfo() const { std::ostringstream os; os << "Constraint[" << GetName() << ", " - << ConstraintTypeToString(constraint_type) << " , related columns: ("; + << ConstraintTypeToString(constraint_type_) << " , related columns: ("; bool first = true; - for (auto id : column_ids) { + for (auto id : column_ids_) { if (first) { os << id; first = false; diff --git a/src/catalog/proc_catalog.cpp b/src/catalog/proc_catalog.cpp index 6da75db67fc..7c3fe1db77e 100644 --- a/src/catalog/proc_catalog.cpp +++ b/src/catalog/proc_catalog.cpp @@ -23,8 +23,8 @@ namespace catalog { #define PROC_CATALOG_NAME "pg_proc" -ProcCatalogObject::ProcCatalogObject(executor::LogicalTile *tile, - concurrency::TransactionContext *txn) +ProcCatalogEntry::ProcCatalogEntry(concurrency::TransactionContext *txn, + executor::LogicalTile *tile) : oid_(tile->GetValue(0, 0).GetAs()), name_(tile->GetValue(0, 1).GetAs()), ret_type_(tile->GetValue(0, 2).GetAs()), @@ -33,8 +33,8 @@ ProcCatalogObject::ProcCatalogObject(executor::LogicalTile *tile, src_(tile->GetValue(0, 5).GetAs()), txn_(txn) {} -std::unique_ptr ProcCatalogObject::GetLanguage() const { - return LanguageCatalog::GetInstance().GetLanguageByOid(GetLangOid(), txn_); +std::unique_ptr ProcCatalogEntry::GetLanguage() const { + return LanguageCatalog::GetInstance().GetLanguageByOid(txn_, GetLangOid()); } ProcCatalog &ProcCatalog::GetInstance(concurrency::TransactionContext *txn) { @@ -45,27 +45,32 @@ ProcCatalog &ProcCatalog::GetInstance(concurrency::TransactionContext *txn) { ProcCatalog::~ProcCatalog(){}; ProcCatalog::ProcCatalog(concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." CATALOG_SCHEMA_NAME "." PROC_CATALOG_NAME - " (" - "proc_oid INT NOT NULL PRIMARY KEY, " - "proname VARCHAR NOT NULL, " - "prorettype INT NOT NULL, " - "proargtypes VARCHAR NOT NULL, " - "prolang INT NOT NULL, " - "prosrc VARCHAR NOT NULL);", - txn) { - Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, PROC_CATALOG_NAME, {1, 3}, - PROC_CATALOG_NAME "_skey0", false, IndexType::BWTREE, txn); + : AbstractCatalog(txn, "CREATE TABLE " CATALOG_DATABASE_NAME + "." CATALOG_SCHEMA_NAME "." PROC_CATALOG_NAME + " (" + "proc_oid INT NOT NULL PRIMARY KEY, " + "proname VARCHAR NOT NULL, " + "prorettype INT NOT NULL, " + "proargtypes VARCHAR NOT NULL, " + "prolang INT NOT NULL, " + "prosrc VARCHAR NOT NULL);") { + Catalog::GetInstance()->CreateIndex(txn, + CATALOG_DATABASE_NAME, + CATALOG_SCHEMA_NAME, + PROC_CATALOG_NAME, + PROC_CATALOG_NAME "_skey0", + {1, 3}, + false, + IndexType::BWTREE); } -bool ProcCatalog::InsertProc(const std::string &proname, +bool ProcCatalog::InsertProc(concurrency::TransactionContext *txn, + const std::string &proname, type::TypeId prorettype, const std::vector &proargtypes, - oid_t prolang, const std::string &prosrc, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { + oid_t prolang, + const std::string &prosrc, + type::AbstractPool *pool) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -86,34 +91,36 @@ bool ProcCatalog::InsertProc(const std::string &proname, tuple->SetValue(ColumnId::PROSRC, val5, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } -std::unique_ptr ProcCatalog::GetProcByOid( - oid_t proc_oid, concurrency::TransactionContext *txn) const { - std::vector column_ids(all_column_ids); +std::unique_ptr ProcCatalog::GetProcByOid(concurrency::TransactionContext *txn, + oid_t proc_oid) const { + std::vector column_ids(all_column_ids_); oid_t index_offset = IndexId::PRIMARY_KEY; std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(proc_oid).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); PELOTON_ASSERT(result_tiles->size() <= 1); - std::unique_ptr ret; + std::unique_ptr ret; if (result_tiles->size() == 1) { PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - ret.reset(new ProcCatalogObject((*result_tiles)[0].get(), txn)); + ret.reset(new ProcCatalogEntry(txn, (*result_tiles)[0].get())); } return ret; } -std::unique_ptr ProcCatalog::GetProcByName( - const std::string &proc_name, - const std::vector &proc_arg_types, - concurrency::TransactionContext *txn) const { - std::vector column_ids(all_column_ids); +std::unique_ptr ProcCatalog::GetProcByName(concurrency::TransactionContext *txn, + const std::string &proc_name, + const std::vector &proc_arg_types) const { + std::vector column_ids(all_column_ids_); oid_t index_offset = IndexId::SECONDARY_KEY_0; std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(proc_name).Copy()); @@ -122,13 +129,16 @@ std::unique_ptr ProcCatalog::GetProcByName( .Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); PELOTON_ASSERT(result_tiles->size() <= 1); - std::unique_ptr ret; + std::unique_ptr ret; if (result_tiles->size() == 1) { PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - ret.reset(new ProcCatalogObject((*result_tiles)[0].get(), txn)); + ret.reset(new ProcCatalogEntry(txn, (*result_tiles)[0].get())); } return ret; diff --git a/src/catalog/query_history_catalog.cpp b/src/catalog/query_history_catalog.cpp index 4433197ba28..51f5690d3d2 100644 --- a/src/catalog/query_history_catalog.cpp +++ b/src/catalog/query_history_catalog.cpp @@ -26,20 +26,20 @@ QueryHistoryCatalog &QueryHistoryCatalog::GetInstance( } QueryHistoryCatalog::QueryHistoryCatalog(concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." CATALOG_SCHEMA_NAME "." QUERY_HISTORY_CATALOG_NAME - " (" - "query_string VARCHAR NOT NULL, " - "fingerprint VARCHAR NOT NULL, " - "timestamp TIMESTAMP NOT NULL);", - txn) {} + : AbstractCatalog(txn, "CREATE TABLE " CATALOG_DATABASE_NAME + "." CATALOG_SCHEMA_NAME "." QUERY_HISTORY_CATALOG_NAME + " (" + "query_string VARCHAR NOT NULL, " + "fingerprint VARCHAR NOT NULL, " + "timestamp TIMESTAMP NOT NULL);") {} QueryHistoryCatalog::~QueryHistoryCatalog() = default; -bool QueryHistoryCatalog::InsertQueryHistory( - const std::string &query_string, const std::string &fingerprint, - uint64_t timestamp, type::AbstractPool *pool, - concurrency::TransactionContext *txn) { +bool QueryHistoryCatalog::InsertQueryHistory(concurrency::TransactionContext *txn, + const std::string &query_string, + const std::string &fingerprint, + uint64_t timestamp, + type::AbstractPool *pool) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -53,7 +53,7 @@ bool QueryHistoryCatalog::InsertQueryHistory( tuple->SetValue(ColumnId::TIMESTAMP, val2, pool != nullptr ? pool : &pool_); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } } // namespace catalog diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 0fd6b7c44d7..62661d98d75 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -20,38 +20,44 @@ namespace peloton { namespace catalog { -QueryMetricsCatalog::QueryMetricsCatalog(const std::string &database_name, - concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " + database_name + - "." CATALOG_SCHEMA_NAME "." QUERY_METRICS_CATALOG_NAME - " (" - "query_name VARCHAR NOT NULL PRIMARY KEY, " - "database_oid INT NOT NULL PRIMARY KEY, " - "num_params INT NOT NULL, " - "param_types VARBINARY, " - "param_formats VARBINARY, " - "param_values VARBINARY, " - "reads INT NOT NULL, " - "updates INT NOT NULL, " - "deletes INT NOT NULL, " - "inserts INT NOT NULL, " - "latency INT NOT NULL, " - "cpu_time INT NOT NULL, " - "time_stamp INT NOT NULL);", - txn) { +QueryMetricsCatalog::QueryMetricsCatalog(concurrency::TransactionContext *txn, + const std::string &database_name) + : AbstractCatalog(txn, "CREATE TABLE " + database_name + + "." CATALOG_SCHEMA_NAME "." QUERY_METRICS_CATALOG_NAME + " (" + "query_name VARCHAR NOT NULL PRIMARY KEY, " + "database_oid INT NOT NULL PRIMARY KEY, " + "num_params INT NOT NULL, " + "param_types VARBINARY, " + "param_formats VARBINARY, " + "param_values VARBINARY, " + "reads INT NOT NULL, " + "updates INT NOT NULL, " + "deletes INT NOT NULL, " + "inserts INT NOT NULL, " + "latency INT NOT NULL, " + "cpu_time INT NOT NULL, " + "time_stamp INT NOT NULL);") { // Add secondary index here if necessary } QueryMetricsCatalog::~QueryMetricsCatalog() {} -bool QueryMetricsCatalog::InsertQueryMetrics( - const std::string &name, oid_t database_oid, int64_t num_params, - const stats::QueryMetric::QueryParamBuf &type_buf, - const stats::QueryMetric::QueryParamBuf &format_buf, - const stats::QueryMetric::QueryParamBuf &value_buf, int64_t reads, - int64_t updates, int64_t deletes, int64_t inserts, int64_t latency, - int64_t cpu_time, int64_t time_stamp, type::AbstractPool *pool, - concurrency::TransactionContext *txn) { +bool QueryMetricsCatalog::InsertQueryMetrics(concurrency::TransactionContext *txn, + const std::string &name, + oid_t database_oid, + int64_t num_params, + const stats::QueryMetric::QueryParamBuf &type_buf, + const stats::QueryMetric::QueryParamBuf &format_buf, + const stats::QueryMetric::QueryParamBuf &value_buf, + int64_t reads, + int64_t updates, + int64_t deletes, + int64_t inserts, + int64_t latency, + int64_t cpu_time, + int64_t time_stamp, + type::AbstractPool *pool) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -95,30 +101,33 @@ bool QueryMetricsCatalog::InsertQueryMetrics( tuple->SetValue(ColumnId::TIME_STAMP, val12, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } -bool QueryMetricsCatalog::DeleteQueryMetrics( - const std::string &name, concurrency::TransactionContext *txn) { +bool QueryMetricsCatalog::DeleteQueryMetrics(concurrency::TransactionContext *txn, + const std::string &name) { oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); + values.push_back(type::ValueFactory::GetIntegerValue(database_oid_).Copy()); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } -stats::QueryMetric::QueryParamBuf QueryMetricsCatalog::GetParamTypes( - const std::string &name, concurrency::TransactionContext *txn) { +stats::QueryMetric::QueryParamBuf QueryMetricsCatalog::GetParamTypes(concurrency::TransactionContext *txn, + const std::string &name) { std::vector column_ids({ColumnId::PARAM_TYPES}); // param_types oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); + values.push_back(type::ValueFactory::GetIntegerValue(database_oid_).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); stats::QueryMetric::QueryParamBuf param_types; PELOTON_ASSERT(result_tiles->size() <= 1); // unique @@ -135,15 +144,18 @@ stats::QueryMetric::QueryParamBuf QueryMetricsCatalog::GetParamTypes( return param_types; } -int64_t QueryMetricsCatalog::GetNumParams( - const std::string &name, concurrency::TransactionContext *txn) { +int64_t QueryMetricsCatalog::GetNumParams(concurrency::TransactionContext *txn, + const std::string &name) { std::vector column_ids({ColumnId::NUM_PARAMS}); // num_params oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); int64_t num_params = 0; PELOTON_ASSERT(result_tiles->size() <= 1); // unique diff --git a/src/catalog/schema.cpp b/src/catalog/schema.cpp index ab38f8c8501..66f557f2532 100644 --- a/src/catalog/schema.cpp +++ b/src/catalog/schema.cpp @@ -37,24 +37,24 @@ void Schema::CreateTupleSchema( column_offset += column.GetFixedLength(); - columns.push_back(std::move(column)); + columns_.push_back(std::move(column)); if (is_inlined[column_itr] == false) { tup_is_inlined = false; - uninlined_columns.push_back(column_itr); + uninlined_columns_.push_back(column_itr); } } - length = column_offset; - tuple_is_inlined = tup_is_inlined; + length_ = column_offset; + tuple_is_inlined_ = tup_is_inlined; - column_count = columns.size(); - uninlined_column_count = uninlined_columns.size(); + column_count_ = columns_.size(); + uninlined_column_count_ = uninlined_columns_.size(); } // Construct schema from vector of Column Schema::Schema(const std::vector &columns) - : length(0), tuple_is_inlined(false) { + : length_(0), tuple_is_inlined_(false) { oid_t column_count = columns.size(); std::vector column_types; @@ -105,7 +105,7 @@ std::shared_ptr Schema::CopySchema( for (oid_t column_itr = 0; column_itr < column_count; column_itr++) { // If column exists in set if (std::find(set.begin(), set.end(), column_itr) != set.end()) { - columns.push_back(schema->columns[column_itr]); + columns.push_back(schema->columns_[column_itr]); } } @@ -153,9 +153,9 @@ Schema *Schema::CopySchema(const Schema *schema, // For each column index, push the column for (oid_t column_index : index_list) { // Make sure the index does not refer to invalid element - PELOTON_ASSERT(column_index < schema->columns.size()); + PELOTON_ASSERT(column_index < schema->columns_.size()); - column_list.push_back(schema->columns[column_index]); + column_list.push_back(schema->columns_[column_index]); } Schema *ret_schema = new Schema(column_list); @@ -195,7 +195,7 @@ Schema *Schema::FilterSchema(const Schema *schema, for (oid_t column_itr = 0; column_itr < column_count; column_itr++) { // If column exists in set if (std::find(set.begin(), set.end(), column_itr) != set.end()) { - columns.push_back(schema->columns[column_itr]); + columns.push_back(schema->columns_[column_itr]); } } @@ -261,7 +261,7 @@ Schema *Schema::AppendSchemaPtrList( for (oid_t column_itr = 0; column_itr < column_count; column_itr++) { // If column exists in set. if (std::find(subset.begin(), subset.end(), column_itr) != subset.end()) { - columns.push_back(schema->columns[column_itr]); + columns.push_back(schema->columns_[column_itr]); } } } @@ -275,20 +275,20 @@ const std::string Schema::GetInfo() const { std::ostringstream os; os << "Schema[" - << "NumColumns:" << column_count << ", " - << "IsInlined:" << tuple_is_inlined << ", " - << "Length:" << length << ", " - << "UninlinedCount:" << uninlined_column_count << "]"; + << "NumColumns:" << column_count_ << ", " + << "IsInlined:" << tuple_is_inlined_ << ", " + << "Length:" << length_ << ", " + << "UninlinedCount:" << uninlined_column_count_ << "]"; bool first = true; os << " :: ("; - for (oid_t i = 0; i < column_count; i++) { + for (oid_t i = 0; i < column_count_; i++) { if (first) { first = false; } else { os << ", "; } - os << columns[i].GetInfo(); + os << columns_[i].GetInfo(); } os << ")"; @@ -305,7 +305,7 @@ hash_t Schema::Hash() const { auto is_inlined = IsInlined(); hash = HashUtil::CombineHashes(hash, HashUtil::Hash(&is_inlined)); - for (const auto &column : columns) { + for (const auto &column : columns_) { hash = HashUtil::CombineHashes(hash, column.Hash()); } return hash; diff --git a/src/catalog/schema_catalog.cpp b/src/catalog/schema_catalog.cpp index 4761bb0e776..815c6e467a6 100644 --- a/src/catalog/schema_catalog.cpp +++ b/src/catalog/schema_catalog.cpp @@ -24,23 +24,29 @@ namespace peloton { namespace catalog { -SchemaCatalogObject::SchemaCatalogObject(executor::LogicalTile *tile, - concurrency::TransactionContext *txn) - : schema_oid(tile->GetValue(0, SchemaCatalog::ColumnId::SCHEMA_OID) +SchemaCatalogEntry::SchemaCatalogEntry(concurrency::TransactionContext *txn, + executor::LogicalTile *tile) + : schema_oid_(tile->GetValue(0, SchemaCatalog::ColumnId::SCHEMA_OID) .GetAs()), - schema_name( + schema_name_( tile->GetValue(0, SchemaCatalog::ColumnId::SCHEMA_NAME).ToString()), - txn(txn) {} - -SchemaCatalog::SchemaCatalog( - storage::Database *database, UNUSED_ATTRIBUTE type::AbstractPool *pool, - UNUSED_ATTRIBUTE concurrency::TransactionContext *txn) - : AbstractCatalog(SCHEMA_CATALOG_OID, SCHEMA_CATALOG_NAME, - InitializeSchema().release(), database) { + txn_(txn) {} + +SchemaCatalog::SchemaCatalog(concurrency::TransactionContext *, + storage::Database *database, + type::AbstractPool *) + : AbstractCatalog(database, + InitializeSchema().release(), + SCHEMA_CATALOG_OID, + SCHEMA_CATALOG_NAME) { // Add indexes for pg_namespace - AddIndex({0}, SCHEMA_CATALOG_PKEY_OID, SCHEMA_CATALOG_NAME "_pkey", + AddIndex(SCHEMA_CATALOG_NAME "_pkey", + SCHEMA_CATALOG_PKEY_OID, + {0}, IndexConstraintType::PRIMARY_KEY); - AddIndex({1}, SCHEMA_CATALOG_SKEY0_OID, SCHEMA_CATALOG_NAME "_skey0", + AddIndex(SCHEMA_CATALOG_NAME "_skey0", + SCHEMA_CATALOG_SKEY0_OID, + {1}, IndexConstraintType::UNIQUE); } @@ -62,7 +68,7 @@ std::unique_ptr SchemaCatalog::InitializeSchema() { catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); auto schema_name_column = catalog::Column( - type::TypeId::VARCHAR, max_name_size, "schema_name", false); + type::TypeId::VARCHAR, max_name_size_, "schema_name", false); schema_name_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); @@ -71,10 +77,10 @@ std::unique_ptr SchemaCatalog::InitializeSchema() { return schema; } -bool SchemaCatalog::InsertSchema(oid_t schema_oid, +bool SchemaCatalog::InsertSchema(concurrency::TransactionContext *txn, + oid_t schema_oid, const std::string &schema_name, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { + type::AbstractPool *pool) { // Create the tuple first std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -86,37 +92,41 @@ bool SchemaCatalog::InsertSchema(oid_t schema_oid, tuple->SetValue(SchemaCatalog::ColumnId::SCHEMA_NAME, val1, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } -bool SchemaCatalog::DeleteSchema(const std::string &schema_name, - concurrency::TransactionContext *txn) { +bool SchemaCatalog::DeleteSchema(concurrency::TransactionContext *txn, + const std::string &schema_name) { oid_t index_offset = IndexId::SKEY_SCHEMA_NAME; // Index of schema_name std::vector values; values.push_back( type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } -std::shared_ptr SchemaCatalog::GetSchemaObject( - const std::string &schema_name, concurrency::TransactionContext *txn) { +std::shared_ptr SchemaCatalog::GetSchemaCatalogEntry( + concurrency::TransactionContext *txn, + const std::string &schema_name) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } // get from pg_namespace, index scan - std::vector column_ids(all_column_ids); + std::vector column_ids(all_column_ids_); oid_t index_offset = IndexId::SKEY_SCHEMA_NAME; // Index of database_name std::vector values; values.push_back( type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { auto schema_object = - std::make_shared((*result_tiles)[0].get(), txn); + std::make_shared(txn, (*result_tiles)[0].get()); // TODO: we don't have cache for schema object right now return schema_object; } diff --git a/src/catalog/settings_catalog.cpp b/src/catalog/settings_catalog.cpp index bcdc518af24..de483314d4b 100644 --- a/src/catalog/settings_catalog.cpp +++ b/src/catalog/settings_catalog.cpp @@ -28,33 +28,42 @@ SettingsCatalog &SettingsCatalog::GetInstance( } SettingsCatalog::SettingsCatalog(concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." CATALOG_SCHEMA_NAME "." SETTINGS_CATALOG_NAME - " (" - "name VARCHAR NOT NULL, " - "value VARCHAR NOT NULL, " - "value_type VARCHAR NOT NULL, " - "description VARCHAR, " - "min_value VARCHAR, " - "max_value VARCHAR, " - "default_value VARCHAR NOT NULL, " - "is_mutable BOOL NOT NULL, " - "is_persistent BOOL NOT NULL);", - txn) { + : AbstractCatalog(txn, "CREATE TABLE " CATALOG_DATABASE_NAME + "." CATALOG_SCHEMA_NAME "." SETTINGS_CATALOG_NAME + " (" + "name VARCHAR NOT NULL, " + "value VARCHAR NOT NULL, " + "value_type VARCHAR NOT NULL, " + "description VARCHAR, " + "min_value VARCHAR, " + "max_value VARCHAR, " + "default_value VARCHAR NOT NULL, " + "is_mutable BOOL NOT NULL, " + "is_persistent BOOL NOT NULL);") { // Add secondary index here if necessary - Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, SETTINGS_CATALOG_NAME, {0}, - SETTINGS_CATALOG_NAME "_skey0", false, IndexType::BWTREE, txn); + Catalog::GetInstance()->CreateIndex(txn, + CATALOG_DATABASE_NAME, + CATALOG_SCHEMA_NAME, + SETTINGS_CATALOG_NAME, + SETTINGS_CATALOG_NAME "_skey0", + {0}, + false, + IndexType::BWTREE); } SettingsCatalog::~SettingsCatalog() {} -bool SettingsCatalog::InsertSetting( - const std::string &name, const std::string &value, type::TypeId value_type, - const std::string &description, const std::string &min_value, - const std::string &max_value, const std::string &default_value, - bool is_mutable, bool is_persistent, type::AbstractPool *pool, - concurrency::TransactionContext *txn) { +bool SettingsCatalog::InsertSetting(concurrency::TransactionContext *txn, + const std::string &name, + const std::string &value, + type::TypeId value_type, + const std::string &description, + const std::string &min_value, + const std::string &max_value, + const std::string &default_value, + bool is_mutable, + bool is_persistent, + type::AbstractPool *pool) { // Create the tuple first std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -81,27 +90,30 @@ bool SettingsCatalog::InsertSetting( tuple->SetValue(static_cast(ColumnId::IS_PERSISTENT), val8, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } -bool SettingsCatalog::DeleteSetting(const std::string &name, - concurrency::TransactionContext *txn) { +bool SettingsCatalog::DeleteSetting(concurrency::TransactionContext *txn, + const std::string &name) { oid_t index_offset = 0; std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } -std::string SettingsCatalog::GetSettingValue( - const std::string &name, concurrency::TransactionContext *txn) { +std::string SettingsCatalog::GetSettingValue(concurrency::TransactionContext *txn, + const std::string &name) { std::vector column_ids({static_cast(ColumnId::VALUE)}); oid_t index_offset = static_cast(IndexId::SECONDARY_KEY_0); std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); std::string config_value = ""; PELOTON_ASSERT(result_tiles->size() <= 1); @@ -114,15 +126,18 @@ std::string SettingsCatalog::GetSettingValue( return config_value; } -std::string SettingsCatalog::GetDefaultValue( - const std::string &name, concurrency::TransactionContext *txn) { +std::string SettingsCatalog::GetDefaultValue(concurrency::TransactionContext *txn, + const std::string &name) { std::vector column_ids({static_cast(ColumnId::VALUE)}); oid_t index_offset = static_cast(IndexId::SECONDARY_KEY_0); std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); std::string config_value = ""; PELOTON_ASSERT(result_tiles->size() <= 1); diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index 611f6562c42..7e92755c001 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -27,19 +27,19 @@ namespace catalog { * @param database the database which the catalog tables belongs to * @param txn TransactionContext */ -SystemCatalogs::SystemCatalogs(storage::Database *database, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) +SystemCatalogs::SystemCatalogs(concurrency::TransactionContext *txn, + storage::Database *database, + type::AbstractPool *pool) : pg_trigger_(nullptr), pg_table_metrics_(nullptr), pg_index_metrics_(nullptr), pg_query_metrics_(nullptr) { oid_t database_oid = database->GetOid(); - pg_attribute_ = new ColumnCatalog(database, pool, txn); - pg_namespace_ = new SchemaCatalog(database, pool, txn); - pg_table_ = new TableCatalog(database, pool, txn); - pg_index_ = new IndexCatalog(database, pool, txn); - pg_layout_ = new LayoutCatalog(database, pool, txn); + pg_attribute_ = new ColumnCatalog(txn, database, pool); + pg_namespace_ = new SchemaCatalog(txn, database, pool); + pg_table_ = new TableCatalog(txn, database, pool); + pg_index_ = new IndexCatalog(txn, database, pool); + pg_layout_ = new LayoutCatalog(txn, database, pool); // TODO: can we move this to BootstrapSystemCatalogs()? // insert column information into pg_attribute @@ -57,11 +57,16 @@ SystemCatalogs::SystemCatalogs(storage::Database *database, ->GetTableWithOid(shared_tables[i].first, shared_tables[i].second) ->GetSchema() ->GetColumns()) { - pg_attribute_->InsertColumn(shared_tables[i].second, column.GetName(), - column_id, column.GetOffset(), - column.GetType(), column.GetLength(), - column.IsInlined(), column.GetConstraints(), - pool, txn); + pg_attribute_->InsertColumn(txn, + shared_tables[i].second, + column_id, + column.GetName(), + column.GetOffset(), + column.GetType(), + column.GetLength(), + column.GetConstraints(), + column.IsInlined(), + pool); column_id++; } } @@ -84,12 +89,12 @@ SystemCatalogs::~SystemCatalogs() { * @param database_name the database which the namespace belongs to * @param txn TransactionContext */ -void SystemCatalogs::Bootstrap(const std::string &database_name, - concurrency::TransactionContext *txn) { +void SystemCatalogs::Bootstrap(concurrency::TransactionContext *txn, + const std::string &database_name) { LOG_DEBUG("Bootstrapping database: %s", database_name.c_str()); if (!pg_trigger_) { - pg_trigger_ = new TriggerCatalog(database_name, txn); + pg_trigger_ = new TriggerCatalog(txn, database_name); } // if (!pg_proc) { @@ -97,15 +102,15 @@ void SystemCatalogs::Bootstrap(const std::string &database_name, // } if (!pg_table_metrics_) { - pg_table_metrics_ = new TableMetricsCatalog(database_name, txn); + pg_table_metrics_ = new TableMetricsCatalog(txn, database_name); } if (!pg_index_metrics_) { - pg_index_metrics_ = new IndexMetricsCatalog(database_name, txn); + pg_index_metrics_ = new IndexMetricsCatalog(txn, database_name); } if (!pg_query_metrics_) { - pg_query_metrics_ = new QueryMetricsCatalog(database_name, txn); + pg_query_metrics_ = new QueryMetricsCatalog(txn, database_name); } // Reset oid of each catalog to avoid collisions between catalog diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 478bb5f2d79..8031fdd961e 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -28,8 +28,8 @@ namespace peloton { namespace catalog { -TableCatalogObject::TableCatalogObject(executor::LogicalTile *tile, - concurrency::TransactionContext *txn, +TableCatalogEntry::TableCatalogEntry(concurrency::TransactionContext *txn, + executor::LogicalTile *tile, int tupleId) : table_oid(tile->GetValue(tupleId, TableCatalog::ColumnId::TABLE_OID) .GetAs()), @@ -42,43 +42,43 @@ TableCatalogObject::TableCatalogObject(executor::LogicalTile *tile, version_id(tile->GetValue(tupleId, TableCatalog::ColumnId::VERSION_ID) .GetAs()), default_layout_oid(tile->GetValue(tupleId, - TableCatalog::ColumnId::DEFAULT_LAYOUT_OID).GetAs()), - index_objects(), - index_names(), - valid_index_objects(false), - column_objects(), - column_names(), - valid_column_objects(false), - valid_layout_objects_(false), - txn(txn) {} + TableCatalog::ColumnId::DEFAULT_LAYOUT_OID).GetAs()), + index_catalog_entries(), + index_catalog_entries_by_name_(), + valid_index_catalog_entries_(false), + column_catalog_entries_(), + column_names_(), + valid_column_catalog_entries_(false), + valid_layout_catalog_entries_(false), + txn_(txn) {} /* @brief insert index catalog object into cache * @param index_object * @return false if index_name already exists in cache */ -bool TableCatalogObject::InsertIndexObject( - std::shared_ptr index_object) { - if (!index_object || index_object->GetIndexOid() == INVALID_OID) { +bool TableCatalogEntry::InsertIndexCatalogEntry( + std::shared_ptr index_catalog_entry) { + if (!index_catalog_entry || index_catalog_entry->GetIndexOid() == INVALID_OID) { return false; // invalid object } // check if already in cache - if (index_objects.find(index_object->GetIndexOid()) != index_objects.end()) { - LOG_DEBUG("Index %u already exists in cache!", index_object->GetIndexOid()); + if (index_catalog_entries.find(index_catalog_entry->GetIndexOid()) != index_catalog_entries.end()) { + LOG_DEBUG("Index %u already exists in cache!", index_catalog_entry->GetIndexOid()); return false; } - if (index_names.find(index_object->GetIndexName()) != index_names.end()) { + if (index_catalog_entries_by_name_.find(index_catalog_entry->GetIndexName()) != index_catalog_entries_by_name_.end()) { LOG_DEBUG("Index %s already exists in cache!", - index_object->GetIndexName().c_str()); + index_catalog_entry->GetIndexName().c_str()); return false; } - valid_index_objects = true; - index_objects.insert( - std::make_pair(index_object->GetIndexOid(), index_object)); - index_names.insert( - std::make_pair(index_object->GetIndexName(), index_object)); + valid_index_catalog_entries_ = true; + index_catalog_entries.insert( + std::make_pair(index_catalog_entry->GetIndexOid(), index_catalog_entry)); + index_catalog_entries_by_name_.insert( + std::make_pair(index_catalog_entry->GetIndexName(), index_catalog_entry)); return true; } @@ -86,19 +86,19 @@ bool TableCatalogObject::InsertIndexObject( * @param index_oid * @return true if index_oid is found and evicted; false if not found */ -bool TableCatalogObject::EvictIndexObject(oid_t index_oid) { - if (!valid_index_objects) return false; +bool TableCatalogEntry::EvictIndexCatalogEntry(oid_t index_oid) { + if (!valid_index_catalog_entries_) return false; // find index name from index name cache - auto it = index_objects.find(index_oid); - if (it == index_objects.end()) { + auto it = index_catalog_entries.find(index_oid); + if (it == index_catalog_entries.end()) { return false; // index oid not found in cache } auto index_object = it->second; PELOTON_ASSERT(index_object); - index_objects.erase(it); - index_names.erase(index_object->GetIndexName()); + index_catalog_entries.erase(it); + index_catalog_entries_by_name_.erase(index_object->GetIndexName()); return true; } @@ -106,44 +106,44 @@ bool TableCatalogObject::EvictIndexObject(oid_t index_oid) { * @param index_name * @return true if index_name is found and evicted; false if not found */ -bool TableCatalogObject::EvictIndexObject(const std::string &index_name) { - if (!valid_index_objects) return false; +bool TableCatalogEntry::EvictIndexCatalogEntry(const std::string &index_name) { + if (!valid_index_catalog_entries_) return false; // find index name from index name cache - auto it = index_names.find(index_name); - if (it == index_names.end()) { + auto it = index_catalog_entries_by_name_.find(index_name); + if (it == index_catalog_entries_by_name_.end()) { return false; // index name not found in cache } auto index_object = it->second; PELOTON_ASSERT(index_object); - index_names.erase(it); - index_objects.erase(index_object->GetIndexOid()); + index_catalog_entries_by_name_.erase(it); + index_catalog_entries.erase(index_object->GetIndexOid()); return true; } /* @brief evict all index catalog objects from cache */ -void TableCatalogObject::EvictAllIndexObjects() { - index_objects.clear(); - index_names.clear(); - valid_index_objects = false; +void TableCatalogEntry::EvictAllIndexCatalogEntries() { + index_catalog_entries.clear(); + index_catalog_entries_by_name_.clear(); + valid_index_catalog_entries_ = false; } /* @brief get all index objects of this table into cache * @return map from index oid to cached index object */ -std::unordered_map> -TableCatalogObject::GetIndexObjects(bool cached_only) { - if (!valid_index_objects && !cached_only) { +std::unordered_map> +TableCatalogEntry::GetIndexCatalogEntries(bool cached_only) { + if (!valid_index_catalog_entries_ && !cached_only) { // get index catalog objects from pg_index - valid_index_objects = true; + valid_index_catalog_entries_ = true; auto pg_index = Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetIndexCatalog(); - index_objects = pg_index->GetIndexObjects(table_oid, txn); + index_catalog_entries = pg_index->GetIndexCatalogEntries(txn_, table_oid); } - return index_objects; + return index_catalog_entries; } /* @brief get index object with index oid from cache @@ -151,11 +151,11 @@ TableCatalogObject::GetIndexObjects(bool cached_only) { * @param cached_only if cached only, return nullptr on a cache miss * @return shared pointer to the cached index object, nullptr if not found */ -std::shared_ptr TableCatalogObject::GetIndexObject( +std::shared_ptr TableCatalogEntry::GetIndexCatalogEntries( oid_t index_oid, bool cached_only) { - GetIndexObjects(cached_only); // fetch index objects in case we have not - auto it = index_objects.find(index_oid); - if (it != index_objects.end()) { + GetIndexCatalogEntries(cached_only); // fetch index objects in case we have not + auto it = index_catalog_entries.find(index_oid); + if (it != index_catalog_entries.end()) { return it->second; } return nullptr; @@ -166,11 +166,11 @@ std::shared_ptr TableCatalogObject::GetIndexObject( * @param cached_only if cached only, return nullptr on a cache miss * @return shared pointer to the cached index object, nullptr if not found */ -std::shared_ptr TableCatalogObject::GetIndexObject( +std::shared_ptr TableCatalogEntry::GetIndexCatalogEntry( const std::string &index_name, bool cached_only) { - GetIndexObjects(cached_only); // fetch index objects in case we have not - auto it = index_names.find(index_name); - if (it != index_names.end()) { + GetIndexCatalogEntries(cached_only); // fetch index objects in case we have not + auto it = index_catalog_entries_by_name_.find(index_name); + if (it != index_catalog_entries_by_name_.end()) { return it->second; } return nullptr; @@ -180,31 +180,31 @@ std::shared_ptr TableCatalogObject::GetIndexObject( * @param column_object * @return false if column_name already exists in cache */ -bool TableCatalogObject::InsertColumnObject( - std::shared_ptr column_object) { - if (!column_object || column_object->GetTableOid() == INVALID_OID) { +bool TableCatalogEntry::InsertColumnCatalogEntry( + std::shared_ptr column_catalog_entry) { + if (!column_catalog_entry || column_catalog_entry->GetTableOid() == INVALID_OID) { return false; // invalid object } // check if already in cache - if (column_objects.find(column_object->GetColumnId()) != - column_objects.end()) { + if (column_catalog_entries_.find(column_catalog_entry->GetColumnId()) != + column_catalog_entries_.end()) { LOG_DEBUG("Column %u already exists in cache!", - column_object->GetColumnId()); + column_catalog_entry->GetColumnId()); return false; } - if (column_names.find(column_object->GetColumnName()) != column_names.end()) { + if (column_names_.find(column_catalog_entry->GetColumnName()) != column_names_.end()) { LOG_DEBUG("Column %s already exists in cache!", - column_object->GetColumnName().c_str()); + column_catalog_entry->GetColumnName().c_str()); return false; } - valid_column_objects = true; - column_objects.insert( - std::make_pair(column_object->GetColumnId(), column_object)); - column_names.insert( - std::make_pair(column_object->GetColumnName(), column_object)); + valid_column_catalog_entries_ = true; + column_catalog_entries_.insert( + std::make_pair(column_catalog_entry->GetColumnId(), column_catalog_entry)); + column_names_.insert( + std::make_pair(column_catalog_entry->GetColumnName(), column_catalog_entry)); return true; } @@ -212,19 +212,19 @@ bool TableCatalogObject::InsertColumnObject( * @param column_id * @return true if column_id is found and evicted; false if not found */ -bool TableCatalogObject::EvictColumnObject(oid_t column_id) { - if (!valid_column_objects) return false; +bool TableCatalogEntry::EvictColumnCatalogEntry(oid_t column_id) { + if (!valid_column_catalog_entries_) return false; // find column name from column name cache - auto it = column_objects.find(column_id); - if (it == column_objects.end()) { + auto it = column_catalog_entries_.find(column_id); + if (it == column_catalog_entries_.end()) { return false; // column id not found in cache } auto column_object = it->second; PELOTON_ASSERT(column_object); - column_objects.erase(it); - column_names.erase(column_object->GetColumnName()); + column_catalog_entries_.erase(it); + column_names_.erase(column_object->GetColumnName()); return true; } @@ -232,62 +232,62 @@ bool TableCatalogObject::EvictColumnObject(oid_t column_id) { * @param column_name * @return true if column_name is found and evicted; false if not found */ -bool TableCatalogObject::EvictColumnObject(const std::string &column_name) { - if (!valid_column_objects) return false; +bool TableCatalogEntry::EvictColumnCatalogEntry(const std::string &column_name) { + if (!valid_column_catalog_entries_) return false; // find column name from column name cache - auto it = column_names.find(column_name); - if (it == column_names.end()) { + auto it = column_names_.find(column_name); + if (it == column_names_.end()) { return false; // column name not found in cache } auto column_object = it->second; PELOTON_ASSERT(column_object); - column_names.erase(it); - column_objects.erase(column_object->GetColumnId()); + column_names_.erase(it); + column_catalog_entries_.erase(column_object->GetColumnId()); return true; } /* @brief evict all column catalog objects from cache * @return true if column_name is found and evicted; false if not found */ -void TableCatalogObject::EvictAllColumnObjects() { - column_objects.clear(); - column_names.clear(); - valid_column_objects = false; +void TableCatalogEntry::EvictAllColumnCatalogEntries() { + column_catalog_entries_.clear(); + column_names_.clear(); + valid_column_catalog_entries_ = false; } /* @brief get all column objects of this table into cache * @return map from column id to cached column object */ -std::unordered_map> -TableCatalogObject::GetColumnObjects(bool cached_only) { - if (!valid_column_objects && !cached_only) { +std::unordered_map> +TableCatalogEntry::GetColumnCatalogEntries(bool cached_only) { + if (!valid_column_catalog_entries_ && !cached_only) { // get column catalog objects from pg_column auto pg_attribute = Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetColumnCatalog(); - pg_attribute->GetColumnObjects(table_oid, txn); - valid_column_objects = true; + pg_attribute->GetColumnCatalogEntries(txn_, table_oid); + valid_column_catalog_entries_ = true; } - return column_objects; + return column_catalog_entries_; } /* @brief get all column objects of this table into cache * @return map from column name to cached column object */ -std::unordered_map> -TableCatalogObject::GetColumnNames(bool cached_only) { - if (!valid_column_objects && !cached_only) { - auto column_objects = GetColumnObjects(); - std::unordered_map> +std::unordered_map> +TableCatalogEntry::GetColumnCatalogEntriesByName(bool cached_only) { + if (!valid_column_catalog_entries_ && !cached_only) { + auto column_objects = GetColumnCatalogEntries(); + std::unordered_map> column_names; for (auto &pair : column_objects) { auto column = pair.second; column_names[column->GetColumnName()] = column; } } - return column_names; + return column_names_; } /* @brief get column object with column id from cache @@ -295,11 +295,11 @@ TableCatalogObject::GetColumnNames(bool cached_only) { * @param cached_only if cached only, return nullptr on a cache miss * @return shared pointer to the cached column object, nullptr if not found */ -std::shared_ptr TableCatalogObject::GetColumnObject( +std::shared_ptr TableCatalogEntry::GetColumnCatalogEntry( oid_t column_id, bool cached_only) { - GetColumnObjects(cached_only); // fetch column objects in case we have not - auto it = column_objects.find(column_id); - if (it != column_objects.end()) { + GetColumnCatalogEntries(cached_only); // fetch column objects in case we have not + auto it = column_catalog_entries_.find(column_id); + if (it != column_catalog_entries_.end()) { return it->second; } return nullptr; @@ -310,27 +310,35 @@ std::shared_ptr TableCatalogObject::GetColumnObject( * @param cached_only if cached only, return nullptr on a cache miss * @return shared pointer to the cached column object, nullptr if not found */ -std::shared_ptr TableCatalogObject::GetColumnObject( +std::shared_ptr TableCatalogEntry::GetColumnCatalogEntry( const std::string &column_name, bool cached_only) { - GetColumnObjects(cached_only); // fetch column objects in case we have not - auto it = column_names.find(column_name); - if (it != column_names.end()) { + GetColumnCatalogEntries(cached_only); // fetch column objects in case we have not + auto it = column_names_.find(column_name); + if (it != column_names_.end()) { return it->second; } return nullptr; } -TableCatalog::TableCatalog( - storage::Database *database, UNUSED_ATTRIBUTE type::AbstractPool *pool, - UNUSED_ATTRIBUTE concurrency::TransactionContext *txn) - : AbstractCatalog(TABLE_CATALOG_OID, TABLE_CATALOG_NAME, - InitializeSchema().release(), database) { +TableCatalog::TableCatalog(concurrency::TransactionContext *, + storage::Database *database, + type::AbstractPool *) + : AbstractCatalog(database, + InitializeSchema().release(), + TABLE_CATALOG_OID, + TABLE_CATALOG_NAME) { // Add indexes for pg_namespace - AddIndex({0}, TABLE_CATALOG_PKEY_OID, TABLE_CATALOG_NAME "_pkey", + AddIndex(TABLE_CATALOG_NAME "_pkey", + TABLE_CATALOG_PKEY_OID, + {0}, IndexConstraintType::PRIMARY_KEY); - AddIndex({1, 2}, TABLE_CATALOG_SKEY0_OID, TABLE_CATALOG_NAME "_skey0", + AddIndex(TABLE_CATALOG_NAME "_skey0", + TABLE_CATALOG_SKEY0_OID, + {1, 2}, IndexConstraintType::UNIQUE); - AddIndex({3}, TABLE_CATALOG_SKEY1_OID, TABLE_CATALOG_NAME "_skey1", + AddIndex(TABLE_CATALOG_NAME "_skey1", + TABLE_CATALOG_SKEY1_OID, + {3}, IndexConstraintType::DEFAULT); } @@ -338,7 +346,7 @@ TableCatalog::TableCatalog( * @param layout Layout object to be inserted * @return false if layout already exists in cache */ -bool TableCatalogObject::InsertLayout( +bool TableCatalogEntry::InsertLayout( std::shared_ptr layout) { // Invalid object if (!layout || (layout->GetOid() == INVALID_OID)) { @@ -347,19 +355,19 @@ bool TableCatalogObject::InsertLayout( oid_t layout_id = layout->GetOid(); // layout is already present in the cache. - if (layout_objects_.find(layout_id) != layout_objects_.end()) { + if (layout_catalog_entries_.find(layout_id) != layout_catalog_entries_.end()) { LOG_DEBUG("Layout %u already exists in cache!", layout_id); return false; } - layout_objects_.insert(std::make_pair(layout_id, layout)); + layout_catalog_entries_.insert(std::make_pair(layout_id, layout)); return true; } /** @brief evict all layout objects from cache. */ -void TableCatalogObject::EvictAllLayouts() { - layout_objects_.clear(); - valid_layout_objects_ = false; +void TableCatalogEntry::EvictAllLayouts() { + layout_catalog_entries_.clear(); + valid_layout_catalog_entries_ = false; } /** @brief Get all layout objects of this table. @@ -368,16 +376,16 @@ void TableCatalogObject::EvictAllLayouts() { * @return Map from layout_oid to cached layout object. */ std::unordered_map> -TableCatalogObject::GetLayouts(bool cached_only) { - if (!valid_layout_objects_ && !cached_only) { +TableCatalogEntry::GetLayouts(bool cached_only) { + if (!valid_layout_catalog_entries_ && !cached_only) { // get layout catalog objects from pg_layout auto pg_layout = Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetLayoutCatalog(); - pg_layout->GetLayouts(table_oid, txn); - valid_column_objects = true; + pg_layout->GetLayouts(txn_, table_oid); + valid_column_catalog_entries_ = true; } - return layout_objects_; + return layout_catalog_entries_; } /** @brief Get the layout object of the given layout_id. @@ -385,12 +393,12 @@ TableCatalogObject::GetLayouts(bool cached_only) { * @param cached_only If set to true, don't fetch the layout objects. * @return Layout object of corresponding to the layout_id if present. */ -std::shared_ptr TableCatalogObject::GetLayout( +std::shared_ptr TableCatalogEntry::GetLayout( oid_t layout_id, bool cached_entry) { // fetch layout objects in case we have not GetLayouts(cached_entry); - auto it = layout_objects_.find(layout_id); - if (it != layout_objects_.end()) { + auto it = layout_catalog_entries_.find(layout_id); + if (it != layout_catalog_entries_.end()) { return it->second; } return nullptr; @@ -400,18 +408,18 @@ std::shared_ptr TableCatalogObject::GetLayout( * @param layout_id Id of the layout to be deleted. * @return true if layout_id is found and evicted; false if not found. */ -bool TableCatalogObject::EvictLayout(oid_t layout_id) { - if (!valid_layout_objects_) return false; +bool TableCatalogEntry::EvictLayout(oid_t layout_id) { + if (!valid_layout_catalog_entries_) return false; // find layout from the cache - auto it = layout_objects_.find(layout_id); - if (it == layout_objects_.end()) { + auto it = layout_catalog_entries_.find(layout_id); + if (it == layout_catalog_entries_.end()) { return false; // layout_id not found in cache } auto layout = it->second; PELOTON_ASSERT(layout); - layout_objects_.erase(it); + layout_catalog_entries_.erase(it); return true; } @@ -432,13 +440,13 @@ std::unique_ptr TableCatalog::InitializeSchema() { table_id_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); - auto table_name_column = catalog::Column(type::TypeId::VARCHAR, max_name_size, + auto table_name_column = catalog::Column(type::TypeId::VARCHAR, max_name_size_, "table_name", false); table_name_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); auto schema_name_column = catalog::Column( - type::TypeId::VARCHAR, max_name_size, "schema_name", false); + type::TypeId::VARCHAR, max_name_size_, "schema_name", false); schema_name_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); @@ -474,11 +482,13 @@ std::unique_ptr TableCatalog::InitializeSchema() { * @param txn TransactionContext * @return Whether insertion is Successful */ -bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, +bool TableCatalog::InsertTable(concurrency::TransactionContext *txn, + oid_t database_oid, const std::string &schema_name, - oid_t database_oid, oid_t layout_oid, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { + oid_t table_oid, + const std::string &table_name, + oid_t layout_oid, + type::AbstractPool *pool) { // Create the tuple first std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -498,7 +508,7 @@ bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, tuple->SetValue(TableCatalog::ColumnId::DEFAULT_LAYOUT_OID, val5, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } /*@brief delete a tuple about table info from pg_table(using index scan) @@ -506,22 +516,24 @@ bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, * @param txn TransactionContext * @return Whether deletion is successful */ -bool TableCatalog::DeleteTable(oid_t table_oid, - concurrency::TransactionContext *txn) { +bool TableCatalog::DeleteTable(concurrency::TransactionContext *txn, oid_t table_oid) { oid_t index_offset = IndexId::PRIMARY_KEY; // Index of table_oid std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); // evict from cache - auto table_object = txn->catalog_cache.GetCachedTableObject(database_oid, - table_oid); + auto table_object = txn->catalog_cache.GetCachedTableObject(database_oid_, + table_oid); if (table_object) { auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); - database_object->EvictTableObject(table_oid); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_oid_); + database_object->EvictTableCatalogEntry(table_oid); } - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } /*@brief read table catalog object from pg_table using table oid @@ -529,33 +541,40 @@ bool TableCatalog::DeleteTable(oid_t table_oid, * @param txn TransactionContext * @return table catalog object */ -std::shared_ptr TableCatalog::GetTableObject( - oid_t table_oid, concurrency::TransactionContext *txn) { +std::shared_ptr TableCatalog::GetTableCatalogEntry( + concurrency::TransactionContext *txn, + oid_t table_oid) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } // try get from cache - auto table_object = txn->catalog_cache.GetCachedTableObject(database_oid, - table_oid); + auto table_object = txn->catalog_cache.GetCachedTableObject(database_oid_, + table_oid); if (table_object) return table_object; // cache miss, get from pg_table - std::vector column_ids(all_column_ids); + std::vector column_ids(all_column_ids_); oid_t index_offset = IndexId::PRIMARY_KEY; // Index of table_oid std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { auto table_object = - std::make_shared((*result_tiles)[0].get(), txn); + std::make_shared(txn, (*result_tiles)[0].get()); // insert into cache auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_oid_); PELOTON_ASSERT(database_object); - bool success = database_object->InsertTableObject(table_object); + bool success = database_object->InsertTableCatalogEntry(table_object); PELOTON_ASSERT(success == true); (void)success; return table_object; @@ -575,22 +594,23 @@ std::shared_ptr TableCatalog::GetTableObject( * @param txn TransactionContext * @return table catalog object */ -std::shared_ptr TableCatalog::GetTableObject( - const std::string &table_name, const std::string &schema_name, - concurrency::TransactionContext *txn) { +std::shared_ptr TableCatalog::GetTableCatalogEntry( + concurrency::TransactionContext *txn, + const std::string &schema_name, + const std::string &table_name) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } // try get from cache - auto database_object = txn->catalog_cache.GetDatabaseObject(database_oid); + auto database_object = txn->catalog_cache.GetDatabaseObject(database_oid_); if (database_object) { auto table_object = - database_object->GetTableObject(table_name, schema_name, true); + database_object->GetTableCatalogEntry(table_name, schema_name, true); if (table_object) return table_object; } // cache miss, get from pg_table - std::vector column_ids(all_column_ids); + std::vector column_ids(all_column_ids_); oid_t index_offset = IndexId::SKEY_TABLE_NAME; // Index of table_name std::vector values; values.push_back( @@ -599,16 +619,22 @@ std::shared_ptr TableCatalog::GetTableObject( type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { auto table_object = - std::make_shared((*result_tiles)[0].get(), txn); + std::make_shared(txn, (*result_tiles)[0].get()); // insert into cache auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_oid_); PELOTON_ASSERT(database_object); - bool success = database_object->InsertTableObject(table_object); + bool success = database_object->InsertTableCatalogEntry(table_object); PELOTON_ASSERT(success == true); (void)success; return table_object; @@ -623,38 +649,44 @@ std::shared_ptr TableCatalog::GetTableObject( * @param txn TransactionContext * @return table catalog objects */ -std::unordered_map> -TableCatalog::GetTableObjects(concurrency::TransactionContext *txn) { +std::unordered_map> +TableCatalog::GetTableCatalogEntries(concurrency::TransactionContext *txn) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } // try get from cache auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_oid_); PELOTON_ASSERT(database_object != nullptr); - if (database_object->IsValidTableObjects()) { - return database_object->GetTableObjects(true); + if (database_object->IsValidTableCatalogEntries()) { + return database_object->GetTableCatalogEntries(true); } // cache miss, get from pg_table - std::vector column_ids(all_column_ids); + std::vector column_ids(all_column_ids_); oid_t index_offset = IndexId::SKEY_DATABASE_OID; // Index of database_oid std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); + values.push_back(type::ValueFactory::GetIntegerValue(database_oid_).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); for (auto &tile : (*result_tiles)) { for (auto tuple_id : *tile) { auto table_object = - std::make_shared(tile.get(), txn, tuple_id); - database_object->InsertTableObject(table_object); + std::make_shared(txn, tile.get(), tuple_id); + database_object->InsertTableCatalogEntry(table_object); } } - database_object->SetValidTableObjects(true); - return database_object->GetTableObjects(); + database_object->SetValidTableCatalogEntries(true); + return database_object->GetTableCatalogEntries(); } /*@brief update version id column within pg_table @@ -663,8 +695,9 @@ TableCatalog::GetTableObjects(concurrency::TransactionContext *txn) { * @param txn TransactionContext * @return Whether update is successful */ -bool TableCatalog::UpdateVersionId(oid_t update_val, oid_t table_oid, - concurrency::TransactionContext *txn) { +bool TableCatalog::UpdateVersionId(concurrency::TransactionContext *txn, + oid_t table_oid, + oid_t update_val) { std::vector update_columns({ColumnId::VERSION_ID}); // version_id oid_t index_offset = IndexId::PRIMARY_KEY; // Index of table_oid // values to execute index scan @@ -676,16 +709,22 @@ bool TableCatalog::UpdateVersionId(oid_t update_val, oid_t table_oid, type::ValueFactory::GetIntegerValue(update_val).Copy()); // get table object, then evict table object - auto table_object = txn->catalog_cache.GetCachedTableObject(database_oid, - table_oid); + auto table_object = txn->catalog_cache.GetCachedTableObject(database_oid_, + table_oid); if (table_object) { auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); - database_object->EvictTableObject(table_oid); - } - - return UpdateWithIndexScan(update_columns, update_values, scan_values, - index_offset, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_oid_); + database_object->EvictTableCatalogEntry(table_oid); + } + + return UpdateWithIndexScan(txn, + index_offset, + scan_values, + update_columns, + update_values); } /*@brief update default layout oid column within pg_table @@ -694,8 +733,9 @@ bool TableCatalog::UpdateVersionId(oid_t update_val, oid_t table_oid, * @param txn TransactionContext * @return Whether update is successful */ -bool TableCatalog::UpdateDefaultLayoutOid(oid_t update_val, oid_t table_oid, - concurrency::TransactionContext *txn) { +bool TableCatalog::UpdateDefaultLayoutOid(concurrency::TransactionContext *txn, + oid_t table_oid, + oid_t update_val) { std::vector update_columns({ColumnId::DEFAULT_LAYOUT_OID}); // defalut_layout_oid oid_t index_offset = IndexId::PRIMARY_KEY; // Index of table_oid // values to execute index scan @@ -707,16 +747,22 @@ bool TableCatalog::UpdateDefaultLayoutOid(oid_t update_val, oid_t table_oid, type::ValueFactory::GetIntegerValue(update_val).Copy()); // get table object, then evict table object - auto table_object = txn->catalog_cache.GetCachedTableObject(database_oid, - table_oid); + auto table_object = txn->catalog_cache.GetCachedTableObject(database_oid_, + table_oid); if (table_object) { auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); - database_object->EvictTableObject(table_oid); - } - - return UpdateWithIndexScan(update_columns, update_values, scan_values, - index_offset, txn); + DatabaseCatalog::GetInstance(nullptr, + nullptr, + nullptr)->GetDatabaseCatalogEntry(txn, + database_oid_); + database_object->EvictTableCatalogEntry(table_oid); + } + + return UpdateWithIndexScan(txn, + index_offset, + scan_values, + update_columns, + update_values); } diff --git a/src/catalog/table_metrics_catalog.cpp b/src/catalog/table_metrics_catalog.cpp index f1f91f46474..a7960b966ca 100644 --- a/src/catalog/table_metrics_catalog.cpp +++ b/src/catalog/table_metrics_catalog.cpp @@ -19,27 +19,30 @@ namespace peloton { namespace catalog { -TableMetricsCatalog::TableMetricsCatalog(const std::string &database_name, - concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " + database_name + - "." CATALOG_SCHEMA_NAME "." TABLE_METRICS_CATALOG_NAME - " (" - "table_oid INT NOT NULL, " - "reads INT NOT NULL, " - "updates INT NOT NULL, " - "deletes INT NOT NULL, " - "inserts INT NOT NULL, " - "time_stamp INT NOT NULL);", - txn) { +TableMetricsCatalog::TableMetricsCatalog(concurrency::TransactionContext *txn, + const std::string &database_name) + : AbstractCatalog(txn, "CREATE TABLE " + database_name + + "." CATALOG_SCHEMA_NAME "." TABLE_METRICS_CATALOG_NAME + " (" + "table_oid INT NOT NULL, " + "reads INT NOT NULL, " + "updates INT NOT NULL, " + "deletes INT NOT NULL, " + "inserts INT NOT NULL, " + "time_stamp INT NOT NULL);") { // Add secondary index here if necessary } TableMetricsCatalog::~TableMetricsCatalog() {} -bool TableMetricsCatalog::InsertTableMetrics( - oid_t table_oid, int64_t reads, int64_t updates, int64_t deletes, - int64_t inserts, int64_t time_stamp, type::AbstractPool *pool, - concurrency::TransactionContext *txn) { +bool TableMetricsCatalog::InsertTableMetrics(concurrency::TransactionContext *txn, + oid_t table_oid, + int64_t reads, + int64_t updates, + int64_t deletes, + int64_t inserts, + int64_t time_stamp, + type::AbstractPool *pool) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -58,17 +61,16 @@ bool TableMetricsCatalog::InsertTableMetrics( tuple->SetValue(ColumnId::TIME_STAMP, val6, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } -bool TableMetricsCatalog::DeleteTableMetrics( - oid_t table_oid, concurrency::TransactionContext *txn) { +bool TableMetricsCatalog::DeleteTableMetrics(concurrency::TransactionContext *txn, oid_t table_oid) { oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } } // namespace catalog diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index 1474dd20d4c..7c95b705f00 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -22,46 +22,61 @@ namespace peloton { namespace catalog { -TriggerCatalog::TriggerCatalog(const std::string &database_name, - concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " + database_name + - "." CATALOG_SCHEMA_NAME "." TRIGGER_CATALOG_NAME - " (" - "oid INT NOT NULL PRIMARY KEY, " - "tgrelid INT NOT NULL, " - "tgname VARCHAR NOT NULL, " - "tgfoid VARCHAR, " - "tgtype INT NOT NULL, " - "tgargs VARCHAR, " - "tgqual VARBINARY, " - "timestamp TIMESTAMP NOT NULL);", - txn) { +TriggerCatalog::TriggerCatalog(concurrency::TransactionContext *txn, + const std::string &database_name) + : AbstractCatalog(txn, "CREATE TABLE " + database_name + + "." CATALOG_SCHEMA_NAME "." TRIGGER_CATALOG_NAME + " (" + "oid INT NOT NULL PRIMARY KEY, " + "tgrelid INT NOT NULL, " + "tgname VARCHAR NOT NULL, " + "tgfoid VARCHAR, " + "tgtype INT NOT NULL, " + "tgargs VARCHAR, " + "tgqual VARBINARY, " + "timestamp TIMESTAMP NOT NULL);") { // Add secondary index here if necessary - Catalog::GetInstance()->CreateIndex( - database_name, CATALOG_SCHEMA_NAME, TRIGGER_CATALOG_NAME, - {ColumnId::TABLE_OID, ColumnId::TRIGGER_TYPE}, - TRIGGER_CATALOG_NAME "_skey0", false, IndexType::BWTREE, txn); - - Catalog::GetInstance()->CreateIndex( - database_name, CATALOG_SCHEMA_NAME, TRIGGER_CATALOG_NAME, - {ColumnId::TABLE_OID}, TRIGGER_CATALOG_NAME "_skey1", false, - IndexType::BWTREE, txn); - - Catalog::GetInstance()->CreateIndex( - database_name, CATALOG_SCHEMA_NAME, TRIGGER_CATALOG_NAME, - {ColumnId::TRIGGER_NAME, ColumnId::TABLE_OID}, - TRIGGER_CATALOG_NAME "_skey2", false, IndexType::BWTREE, txn); + Catalog::GetInstance()->CreateIndex(txn, + database_name, + CATALOG_SCHEMA_NAME, + TRIGGER_CATALOG_NAME, + TRIGGER_CATALOG_NAME "_skey0", + {ColumnId::TABLE_OID, + ColumnId::TRIGGER_TYPE}, + false, + IndexType::BWTREE); + + Catalog::GetInstance()->CreateIndex(txn, + database_name, + CATALOG_SCHEMA_NAME, + TRIGGER_CATALOG_NAME, + TRIGGER_CATALOG_NAME "_skey1", + {ColumnId::TABLE_OID}, + false, + IndexType::BWTREE); + + Catalog::GetInstance()->CreateIndex(txn, + database_name, + CATALOG_SCHEMA_NAME, + TRIGGER_CATALOG_NAME, + TRIGGER_CATALOG_NAME "_skey2", + {ColumnId::TRIGGER_NAME, + ColumnId::TABLE_OID}, + false, + IndexType::BWTREE); } TriggerCatalog::~TriggerCatalog() {} -bool TriggerCatalog::InsertTrigger(oid_t table_oid, std::string trigger_name, - int16_t trigger_type, std::string proc_oid, +bool TriggerCatalog::InsertTrigger(concurrency::TransactionContext *txn, + oid_t table_oid, + std::string trigger_name, + int16_t trigger_type, + std::string proc_oid, std::string function_arguments, type::Value fire_condition, type::Value timestamp, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { + type::AbstractPool *pool) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -86,14 +101,14 @@ bool TriggerCatalog::InsertTrigger(oid_t table_oid, std::string trigger_name, tuple->SetValue(ColumnId::TIMESTAMP, val7, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(txn, std::move(tuple)); } -ResultType TriggerCatalog::DropTrigger(const oid_t database_oid, +ResultType TriggerCatalog::DropTrigger(concurrency::TransactionContext *txn, + const oid_t database_oid, const oid_t table_oid, - const std::string &trigger_name, - concurrency::TransactionContext *txn) { - bool delete_success = DeleteTriggerByName(trigger_name, table_oid, txn); + const std::string &trigger_name) { + bool delete_success = DeleteTriggerByName(txn, table_oid, trigger_name); if (delete_success) { LOG_TRACE("Delete trigger successfully"); // ask target table to update its trigger list variable @@ -107,8 +122,9 @@ ResultType TriggerCatalog::DropTrigger(const oid_t database_oid, return ResultType::FAILURE; } -oid_t TriggerCatalog::GetTriggerOid(std::string trigger_name, oid_t table_oid, - concurrency::TransactionContext *txn) { +oid_t TriggerCatalog::GetTriggerOid(concurrency::TransactionContext *txn, + oid_t table_oid, + std::string trigger_name) { std::vector column_ids({ColumnId::TRIGGER_OID}); oid_t index_offset = IndexId::NAME_TABLE_KEY_2; std::vector values; @@ -116,7 +132,10 @@ oid_t TriggerCatalog::GetTriggerOid(std::string trigger_name, oid_t table_oid, values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); oid_t trigger_oid = INVALID_OID; if (result_tiles->size() == 0) { @@ -131,20 +150,20 @@ oid_t TriggerCatalog::GetTriggerOid(std::string trigger_name, oid_t table_oid, return trigger_oid; } -bool TriggerCatalog::DeleteTriggerByName(const std::string &trigger_name, +bool TriggerCatalog::DeleteTriggerByName(concurrency::TransactionContext *txn, oid_t table_oid, - concurrency::TransactionContext *txn) { + const std::string &trigger_name) { oid_t index_offset = IndexId::NAME_TABLE_KEY_2; std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(trigger_name).Copy()); values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } -std::unique_ptr TriggerCatalog::GetTriggersByType( - oid_t table_oid, int16_t trigger_type, - concurrency::TransactionContext *txn) { +std::unique_ptr TriggerCatalog::GetTriggersByType(concurrency::TransactionContext *txn, + oid_t table_oid, + int16_t trigger_type) { LOG_INFO("Get triggers for table %d", table_oid); // select trigger_name, fire condition, function_name, function_args std::vector column_ids( @@ -157,7 +176,10 @@ std::unique_ptr TriggerCatalog::GetTriggersByType( // the result is a vector of executor::LogicalTile auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); // carefull! the result tile could be null! if (result_tiles == nullptr) { LOG_INFO("no trigger on table %d", table_oid); @@ -185,8 +207,8 @@ std::unique_ptr TriggerCatalog::GetTriggersByType( return new_trigger_list; } -std::unique_ptr TriggerCatalog::GetTriggers( - oid_t table_oid, concurrency::TransactionContext *txn) { +std::unique_ptr TriggerCatalog::GetTriggers(concurrency::TransactionContext *txn, + oid_t table_oid) { // LOG_DEBUG("Get triggers for table %d", table_oid); // select trigger_name, fire condition, function_name, function_args std::vector column_ids( @@ -200,7 +222,10 @@ std::unique_ptr TriggerCatalog::GetTriggers( // the result is a vector of executor::LogicalTile auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); // carefull! the result tile could be null! // if (result_tiles == nullptr) { // LOG_INFO("no trigger on table %d", table_oid); diff --git a/src/catalog/zone_map_catalog.cpp b/src/catalog/zone_map_catalog.cpp index ec59dd24d82..b38e73da8db 100644 --- a/src/catalog/zone_map_catalog.cpp +++ b/src/catalog/zone_map_catalog.cpp @@ -33,29 +33,37 @@ ZoneMapCatalog *ZoneMapCatalog::GetInstance( } ZoneMapCatalog::ZoneMapCatalog(concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." CATALOG_SCHEMA_NAME "." ZONE_MAP_CATALOG_NAME - " (" - "database_id INT NOT NULL, " - "table_id INT NOT NULL, " - "tile_group_id INT NOT NULL, " - "column_id INT NOT NULL, " - "minimum VARCHAR, " - "maximum VARCHAR, " - "type VARCHAR);", - txn) { - Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, ZONE_MAP_CATALOG_NAME, - {0, 1, 2, 3}, ZONE_MAP_CATALOG_NAME "_skey0", true, IndexType::BWTREE, - txn); + : AbstractCatalog(txn, "CREATE TABLE " CATALOG_DATABASE_NAME + "." CATALOG_SCHEMA_NAME "." ZONE_MAP_CATALOG_NAME + " (" + "database_id INT NOT NULL, " + "table_id INT NOT NULL, " + "tile_group_id INT NOT NULL, " + "column_id INT NOT NULL, " + "minimum VARCHAR, " + "maximum VARCHAR, " + "type VARCHAR);") { + Catalog::GetInstance()->CreateIndex(txn, + CATALOG_DATABASE_NAME, + CATALOG_SCHEMA_NAME, + ZONE_MAP_CATALOG_NAME, + ZONE_MAP_CATALOG_NAME "_skey0", + {0, 1, 2, 3}, + true, + IndexType::BWTREE); } ZoneMapCatalog::~ZoneMapCatalog() {} -bool ZoneMapCatalog::InsertColumnStatistics( - oid_t database_id, oid_t table_id, oid_t tile_group_id, oid_t column_id, - std::string minimum, std::string maximum, std::string type, - type::AbstractPool *pool, concurrency::TransactionContext *txn) { +bool ZoneMapCatalog::InsertColumnStatistics(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + oid_t tile_group_id, + oid_t column_id, + std::string minimum, + std::string maximum, + std::string type, + type::AbstractPool *pool) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); @@ -77,25 +85,29 @@ bool ZoneMapCatalog::InsertColumnStatistics( tuple->SetValue(static_cast(ColumnId::MAXIMUM), val_maximum, pool); tuple->SetValue(static_cast(ColumnId::TYPE), val_type, pool); - bool return_val = InsertTuple(std::move(tuple), txn); + bool return_val = InsertTuple(txn, std::move(tuple)); return return_val; } -bool ZoneMapCatalog::DeleteColumnStatistics( - oid_t database_id, oid_t table_id, oid_t tile_group_id, oid_t column_id, - concurrency::TransactionContext *txn) { +bool ZoneMapCatalog::DeleteColumnStatistics(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + oid_t tile_group_id, + oid_t column_id) { oid_t index_offset = static_cast(IndexId::SECONDARY_KEY_0); std::vector values( {type::ValueFactory::GetIntegerValue(database_id), type::ValueFactory::GetIntegerValue(table_id), type::ValueFactory::GetIntegerValue(tile_group_id), type::ValueFactory::GetIntegerValue(column_id)}); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithIndexScan(txn, index_offset, values); } -std::unique_ptr> ZoneMapCatalog::GetColumnStatistics( - oid_t database_id, oid_t table_id, oid_t tile_group_id, oid_t column_id, - concurrency::TransactionContext *txn) { +std::unique_ptr> ZoneMapCatalog::GetColumnStatistics(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + oid_t tile_group_id, + oid_t column_id) { std::vector column_ids({static_cast(ColumnId::MINIMUM), static_cast(ColumnId::MAXIMUM), static_cast(ColumnId::TYPE)}); @@ -109,7 +121,10 @@ std::unique_ptr> ZoneMapCatalog::GetColumnStatistics( type::ValueFactory::GetIntegerValue(column_id)}); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(txn, + column_ids, + index_offset, + values); PELOTON_ASSERT(result_tiles->size() <= 1); // unique if (result_tiles->size() == 0) { diff --git a/src/common/init.cpp b/src/common/init.cpp index fdc085e6ce3..c8b87133211 100644 --- a/src/common/init.cpp +++ b/src/common/init.cpp @@ -87,7 +87,7 @@ void PelotonInit::Initialize() { // initialize the catalog and add the default database, so we don't do this on // the first query - pg_catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + pg_catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); diff --git a/src/executor/create_executor.cpp b/src/executor/create_executor.cpp index 83e85c92c48..bbd3e773d43 100644 --- a/src/executor/create_executor.cpp +++ b/src/executor/create_executor.cpp @@ -94,7 +94,7 @@ bool CreateExecutor::CreateDatabase(const planner::CreatePlan &node) { auto database_name = node.GetDatabaseName(); // invoke logic within catalog.cpp ResultType result = - catalog::Catalog::GetInstance()->CreateDatabase(database_name, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, database_name); txn->SetResult(result); LOG_TRACE("Result is: %s", ResultTypeToString(txn->GetResult()).c_str()); return (true); @@ -105,8 +105,9 @@ bool CreateExecutor::CreateSchema(const planner::CreatePlan &node) { auto database_name = node.GetDatabaseName(); auto schema_name = node.GetSchemaName(); // invoke logic within catalog.cpp - ResultType result = catalog::Catalog::GetInstance()->CreateSchema( - database_name, schema_name, txn); + ResultType result = catalog::Catalog::GetInstance()->CreateSchema(txn, + database_name, + schema_name); txn->SetResult(result); LOG_TRACE("Result is: %s", ResultTypeToString(txn->GetResult()).c_str()); return (true); @@ -119,8 +120,12 @@ bool CreateExecutor::CreateTable(const planner::CreatePlan &node) { std::string database_name = node.GetDatabaseName(); std::unique_ptr schema(node.GetSchema()); - ResultType result = catalog::Catalog::GetInstance()->CreateTable( - database_name, schema_name, table_name, std::move(schema), current_txn); + ResultType result = catalog::Catalog::GetInstance()->CreateTable(current_txn, + database_name, + schema_name, + std::move(schema), + table_name, + false); current_txn->SetResult(result); if (current_txn->GetResult() == ResultType::SUCCESS) { @@ -130,12 +135,16 @@ bool CreateExecutor::CreateTable(const planner::CreatePlan &node) { if (node.GetForeignKeys().empty() == false) { int count = 1; auto catalog = catalog::Catalog::GetInstance(); - auto source_table = catalog->GetTableWithName(database_name, schema_name, - table_name, current_txn); + auto source_table = catalog->GetTableWithName(current_txn, + database_name, + schema_name, + table_name); for (auto fk : node.GetForeignKeys()) { - auto sink_table = catalog->GetTableWithName( - database_name, schema_name, fk.sink_table_name, current_txn); + auto sink_table = catalog->GetTableWithName(current_txn, + database_name, + schema_name, + fk.sink_table_name); // Source Column Offsets std::vector source_col_ids; for (auto col_name : fk.foreign_key_sources) { @@ -182,9 +191,14 @@ bool CreateExecutor::CreateTable(const planner::CreatePlan &node) { std::vector source_col_names = fk.foreign_key_sources; std::string index_name = table_name + "_FK_" + sink_table->GetName() + "_" + std::to_string(count); - catalog->CreateIndex(database_name, schema_name, table_name, - source_col_ids, index_name, false, - IndexType::BWTREE, current_txn); + catalog->CreateIndex(current_txn, + database_name, + schema_name, + table_name, + index_name, + source_col_ids, + false, + IndexType::BWTREE); count++; #ifdef LOG_DEBUG_ENABLED @@ -220,9 +234,14 @@ bool CreateExecutor::CreateIndex(const planner::CreatePlan &node) { auto key_attrs = node.GetKeyAttrs(); - ResultType result = catalog::Catalog::GetInstance()->CreateIndex( - database_name, schema_name, table_name, key_attrs, index_name, - unique_flag, index_type, txn); + ResultType result = catalog::Catalog::GetInstance()->CreateIndex(txn, + database_name, + schema_name, + table_name, + index_name, + key_attrs, + unique_flag, + index_type); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { @@ -243,8 +262,10 @@ bool CreateExecutor::CreateTrigger(const planner::CreatePlan &node) { std::string trigger_name = node.GetTriggerName(); trigger::Trigger newTrigger(node); - auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - database_name, schema_name, table_name, txn); + auto table_object = catalog::Catalog::GetInstance()->GetTableCatalogEntry(txn, + database_name, + schema_name, + table_name); // durable trigger: insert the information of this trigger in the trigger // catalog table @@ -262,13 +283,21 @@ bool CreateExecutor::CreateTrigger(const planner::CreatePlan &node) { catalog::Catalog::GetInstance() ->GetSystemCatalogs(table_object->GetDatabaseOid()) ->GetTriggerCatalog() - ->InsertTrigger(table_object->GetTableOid(), trigger_name, - newTrigger.GetTriggerType(), newTrigger.GetFuncname(), - newTrigger.GetArgs(), when, time_stamp, pool_.get(), txn); + ->InsertTrigger(txn, + table_object->GetTableOid(), + trigger_name, + newTrigger.GetTriggerType(), + newTrigger.GetFuncname(), + newTrigger.GetArgs(), + when, + time_stamp, + pool_.get()); // ask target table to update its trigger list variable storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName( - database_name, schema_name, table_name, txn); + catalog::Catalog::GetInstance()->GetTableWithName(txn, + database_name, + schema_name, + table_name); target_table->UpdateTriggerListFromCatalog(txn); // hardcode SUCCESS result for txn diff --git a/src/executor/create_function_executor.cpp b/src/executor/create_function_executor.cpp index 11ceafb0c17..cd85d9197d4 100644 --- a/src/executor/create_function_executor.cpp +++ b/src/executor/create_function_executor.cpp @@ -40,7 +40,7 @@ bool CreateFunctionExecutor::DExecute() { auto proname = node.GetFunctionName(); oid_t prolang = catalog::LanguageCatalog::GetInstance() - .GetLanguageByName("plpgsql", current_txn) + .GetLanguageByName(current_txn, "plpgsql") ->GetOid(); auto prorettype = node.GetReturnType(); auto proargtypes = node.GetFunctionParameterTypes(); @@ -63,9 +63,13 @@ bool CreateFunctionExecutor::DExecute() { auto func_ptr = code_context->GetUDF(); if (func_ptr != nullptr) { // Insert into catalog - catalog::Catalog::GetInstance()->AddPlpgsqlFunction( - proname, proargtypes, prorettype, prolang, prosrc, code_context, - current_txn); + catalog::Catalog::GetInstance()->AddProcedure(current_txn, + proname, + prorettype, + proargtypes, + prolang, + code_context, + prosrc); result = ResultType::SUCCESS; } else { result = ResultType::FAILURE; diff --git a/src/executor/drop_executor.cpp b/src/executor/drop_executor.cpp index cf4073ce9d2..66fcf3800d7 100644 --- a/src/executor/drop_executor.cpp +++ b/src/executor/drop_executor.cpp @@ -80,8 +80,9 @@ bool DropExecutor::DropDatabase(const planner::DropPlan &node, if (node.IsMissing()) { try { - auto database_object = catalog::Catalog::GetInstance()->GetDatabaseObject( - database_name, txn); + auto database_object = + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, + database_name); } catch (CatalogException &e) { LOG_TRACE("Database %s does not exist.", database_name.c_str()); return false; @@ -89,10 +90,11 @@ bool DropExecutor::DropDatabase(const planner::DropPlan &node, } auto database_object = - catalog::Catalog::GetInstance()->GetDatabaseObject(database_name, txn); + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, + database_name); ResultType result = - catalog::Catalog::GetInstance()->DropDatabaseWithName(database_name, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, database_name); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { @@ -100,7 +102,7 @@ bool DropExecutor::DropDatabase(const planner::DropPlan &node, if (StatementCacheManager::GetStmtCacheManager().get()) { std::set table_ids; - auto table_objects = database_object->GetTableObjects(false); + auto table_objects = database_object->GetTableCatalogEntries(false); for (auto it : table_objects) { table_ids.insert(it.second->GetTableOid()); } @@ -118,8 +120,9 @@ bool DropExecutor::DropSchema(const planner::DropPlan &node, std::string database_name = node.GetDatabaseName(); std::string schema_name = node.GetSchemaName(); - ResultType result = catalog::Catalog::GetInstance()->DropSchema( - database_name, schema_name, txn); + ResultType result = catalog::Catalog::GetInstance()->DropSchema(txn, + database_name, + schema_name); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { @@ -127,9 +130,10 @@ bool DropExecutor::DropSchema(const planner::DropPlan &node, // add dropped table into StatementCacheManager if (StatementCacheManager::GetStmtCacheManager().get()) { std::set table_ids; - auto database_object = catalog::Catalog::GetInstance()->GetDatabaseObject( - database_name, txn); - auto table_objects = database_object->GetTableObjects(schema_name); + auto database_object = + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, + database_name); + auto table_objects = database_object->GetTableCatalogEntries(schema_name); for (int i = 0; i < (int)table_objects.size(); i++) { table_ids.insert(table_objects[i]->GetTableOid()); } @@ -150,16 +154,21 @@ bool DropExecutor::DropTable(const planner::DropPlan &node, if (node.IsMissing()) { try { - auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - database_name, schema_name, table_name, txn); + auto table_object = + catalog::Catalog::GetInstance()->GetTableCatalogEntry(txn, + database_name, + schema_name, + table_name); } catch (CatalogException &e) { LOG_TRACE("Table %s does not exist.", table_name.c_str()); return false; } } - ResultType result = catalog::Catalog::GetInstance()->DropTable( - database_name, schema_name, table_name, txn); + ResultType result = catalog::Catalog::GetInstance()->DropTable(txn, + database_name, + schema_name, + table_name); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { @@ -168,7 +177,10 @@ bool DropExecutor::DropTable(const planner::DropPlan &node, if (StatementCacheManager::GetStmtCacheManager().get()) { oid_t table_id = catalog::Catalog::GetInstance() - ->GetTableObject(database_name, schema_name, table_name, txn) + ->GetTableCatalogEntry(txn, + database_name, + schema_name, + table_name) ->GetTableOid(); StatementCacheManager::GetStmtCacheManager()->InvalidateTableOid( table_id); @@ -186,15 +198,19 @@ bool DropExecutor::DropTrigger(const planner::DropPlan &node, std::string table_name = node.GetTableName(); std::string trigger_name = node.GetTriggerName(); - auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - database_name, schema_name, table_name, txn); + auto table_object = catalog::Catalog::GetInstance()->GetTableCatalogEntry(txn, + database_name, + schema_name, + table_name); // drop trigger ResultType result = catalog::Catalog::GetInstance() ->GetSystemCatalogs(table_object->GetDatabaseOid()) ->GetTriggerCatalog() - ->DropTrigger(table_object->GetDatabaseOid(), - table_object->GetTableOid(), trigger_name, txn); + ->DropTrigger(txn, + table_object->GetDatabaseOid(), + table_object->GetTableOid(), + trigger_name); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { LOG_DEBUG("Dropping trigger succeeded!"); @@ -219,8 +235,9 @@ bool DropExecutor::DropIndex(const planner::DropPlan &node, concurrency::TransactionContext *txn) { std::string index_name = node.GetIndexName(); std::string schema_name = node.GetSchemaName(); - auto database_object = catalog::Catalog::GetInstance()->GetDatabaseObject( - node.GetDatabaseName(), txn); + auto database_object = + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, + node.GetDatabaseName()); if (database_object == nullptr) { throw CatalogException("Index name " + index_name + " cannot be found"); } @@ -228,15 +245,18 @@ bool DropExecutor::DropIndex(const planner::DropPlan &node, auto pg_index = catalog::Catalog::GetInstance() ->GetSystemCatalogs(database_object->GetDatabaseOid()) ->GetIndexCatalog(); - auto index_object = pg_index->GetIndexObject(database_object->GetDatabaseName(), - index_name, schema_name, txn); + auto index_object = pg_index->GetIndexCatalogEntry(txn, + database_object->GetDatabaseName(), + schema_name, + index_name); if (index_object == nullptr) { throw CatalogException("Can't find index " + schema_name + "." + index_name + " to drop"); } // invoke directly using oid - ResultType result = catalog::Catalog::GetInstance()->DropIndex( - database_object->GetDatabaseOid(), index_object->GetIndexOid(), txn); + ResultType result = catalog::Catalog::GetInstance()->DropIndex(txn, + database_object->GetDatabaseOid(), + index_object->GetIndexOid()); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { diff --git a/src/include/binder/binder_context.h b/src/include/binder/binder_context.h index 93aca140539..299dbe75c3e 100644 --- a/src/include/binder/binder_context.h +++ b/src/include/binder/binder_context.h @@ -27,7 +27,7 @@ class TransactionContext; } namespace catalog { -class TableCatalogObject; +class TableCatalogEntry; } namespace binder { @@ -96,7 +96,7 @@ class BinderContext { */ static bool GetColumnPosTuple( const std::string &col_name, - std::shared_ptr table_obj, + std::shared_ptr table_obj, std::tuple &col_pos_tuple, type::TypeId &value_type); /** @@ -133,7 +133,7 @@ class BinderContext { */ static bool GetRegularTableObj( std::shared_ptr current_context, std::string &alias, - std::shared_ptr &table_obj, int &depth); + std::shared_ptr &table_obj, int &depth); static bool CheckNestedTableColumn( std::shared_ptr current_context, std::string &alias, @@ -154,7 +154,7 @@ class BinderContext { private: /** @brief Map table alias to table obj */ - std::unordered_map> + std::unordered_map> regular_table_alias_map_; std::unordered_map> nested_table_alias_map_; diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index e0c8d81df53..0d180975309 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -45,41 +45,47 @@ class AbstractCatalog { protected: /* For pg_database, pg_table, pg_index, pg_column */ - AbstractCatalog(oid_t catalog_table_oid, std::string catalog_table_name, + AbstractCatalog(storage::Database *pg_catalog, catalog::Schema *catalog_table_schema, - storage::Database *pg_catalog); + oid_t catalog_table_oid, + std::string catalog_table_name); /* For other catalogs */ - AbstractCatalog(const std::string &catalog_table_ddl, - concurrency::TransactionContext *txn); + AbstractCatalog(concurrency::TransactionContext *txn, + const std::string &catalog_table_ddl); //===--------------------------------------------------------------------===// // Helper Functions //===--------------------------------------------------------------------===// - bool InsertTuple(std::unique_ptr tuple, - concurrency::TransactionContext *txn); + bool InsertTuple(concurrency::TransactionContext *txn, + std::unique_ptr tuple); - bool DeleteWithIndexScan(oid_t index_offset, std::vector values, - concurrency::TransactionContext *txn); + bool DeleteWithIndexScan(concurrency::TransactionContext *txn, + oid_t index_offset, + std::vector values); std::unique_ptr>> - GetResultWithIndexScan(std::vector column_offsets, oid_t index_offset, - std::vector values, - concurrency::TransactionContext *txn) const; + GetResultWithIndexScan( + concurrency::TransactionContext *txn, + std::vector column_offsets, + oid_t index_offset, + std::vector values) const; std::unique_ptr>> - GetResultWithSeqScan(std::vector column_offsets, - expression::AbstractExpression *predicate, - concurrency::TransactionContext *txn); + GetResultWithSeqScan( + concurrency::TransactionContext *txn, + expression::AbstractExpression *predicate, + std::vector column_offsets); - bool UpdateWithIndexScan(std::vector update_columns, - std::vector update_values, - std::vector scan_values, + bool UpdateWithIndexScan(concurrency::TransactionContext *txn, oid_t index_offset, - concurrency::TransactionContext *txn); + std::vector scan_values, + std::vector update_columns, + std::vector update_values); - void AddIndex(const std::vector &key_attrs, oid_t index_oid, - const std::string &index_name, + void AddIndex(const std::string &index_name, + oid_t index_oid, + const std::vector &key_attrs, IndexConstraintType index_constraint); //===--------------------------------------------------------------------===// @@ -87,9 +93,9 @@ class AbstractCatalog { //===--------------------------------------------------------------------===// // Maximum column name size for catalog schemas - static const size_t max_name_size = 64; + static const size_t max_name_size_ = 64; // which database catalog table is stored int - oid_t database_oid; + oid_t database_oid_; // Local oid (without catalog type mask) starts from START_OID + OID_OFFSET std::atomic oid_ = ATOMIC_VAR_INIT(START_OID + OID_OFFSET); diff --git a/src/include/catalog/catalog.h b/src/include/catalog/catalog.h index 5b9d4fd2ba1..5940f162864 100644 --- a/src/include/catalog/catalog.h +++ b/src/include/catalog/catalog.h @@ -21,9 +21,9 @@ namespace peloton { namespace catalog { class Schema; -class DatabaseCatalogObject; -class TableCatalogObject; -class IndexCatalogObject; +class DatabaseCatalogEntry; +class TableCatalogEntry; +class IndexCatalogEntry; class SystemCatalogs; } // namespace catalog @@ -91,38 +91,44 @@ class Catalog { // CREATE FUNCTIONS //===--------------------------------------------------------------------===// // Create a database - ResultType CreateDatabase(const std::string &database_name, - concurrency::TransactionContext *txn); + ResultType CreateDatabase(concurrency::TransactionContext *txn, + const std::string &database_name); // Create a schema(namespace) - ResultType CreateSchema(const std::string &database_name, - const std::string &schema_name, - concurrency::TransactionContext *txn); + ResultType CreateSchema(concurrency::TransactionContext *txn, + const std::string &database_name, + const std::string &schema_name); // Create a table in a database - ResultType CreateTable( - const std::string &database_name, const std::string &schema_name, - const std::string &table_name, std::unique_ptr, - concurrency::TransactionContext *txn, bool is_catalog = false, - uint32_t tuples_per_tilegroup = DEFAULT_TUPLES_PER_TILEGROUP, - peloton::LayoutType layout_type = LayoutType::ROW); + ResultType CreateTable(concurrency::TransactionContext *txn, + const std::string &database_name, + const std::string &schema_name, + std::unique_ptr schema, + const std::string &table_name, + bool is_catalog, + uint32_t tuples_per_tilegroup = DEFAULT_TUPLES_PER_TILEGROUP, + LayoutType layout_type = LayoutType::ROW); // Create index for a table - ResultType CreateIndex(const std::string &database_name, + ResultType CreateIndex(concurrency::TransactionContext *txn, + const std::string &database_name, const std::string &schema_name, const std::string &table_name, + const std::string &index_name, const std::vector &key_attrs, - const std::string &index_name, bool unique_keys, - IndexType index_type, - concurrency::TransactionContext *txn); + bool unique_keys, + IndexType index_type); - ResultType CreateIndex(oid_t database_oid, oid_t table_oid, - const std::vector &key_attrs, + ResultType CreateIndex(concurrency::TransactionContext *txn, + oid_t database_oid, const std::string &schema_name, - const std::string &index_name, IndexType index_type, - IndexConstraintType index_constraint, bool unique_keys, - concurrency::TransactionContext *txn, - bool is_catalog = false); + oid_t table_oid, + bool is_catalog, + const std::string &index_name, + const std::vector &key_attrs, + bool unique_keys, + IndexType index_type, + IndexConstraintType index_constraint); /** * @brief create a new layout for a table @@ -133,9 +139,10 @@ class Catalog { * @return shared_ptr shared_ptr to the newly created layout in case of * success. nullptr in case of failure. */ - std::shared_ptr CreateLayout( - oid_t database_oid, oid_t table_oid, const column_map_type &column_map, - concurrency::TransactionContext *txn); + std::shared_ptr CreateLayout(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t table_oid, + const column_map_type &column_map); /** * @brief create a new layout for a table and make it the default if @@ -147,37 +154,42 @@ class Catalog { * @return shared_ptr shared_ptr to the newly created layout in case of * success. nullptr in case of failure. */ - std::shared_ptr CreateDefaultLayout( - oid_t database_oid, oid_t table_oid, const column_map_type &column_map, - concurrency::TransactionContext *txn); + std::shared_ptr CreateDefaultLayout(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t table_oid, + const column_map_type &column_map); //===--------------------------------------------------------------------===// // DROP FUNCTIONS //===--------------------------------------------------------------------===// // Drop a database with its name - ResultType DropDatabaseWithName(const std::string &database_name, - concurrency::TransactionContext *txn); + ResultType DropDatabaseWithName(concurrency::TransactionContext *txn, + const std::string &database_name); // Drop a database with its oid - ResultType DropDatabaseWithOid(oid_t database_oid, - concurrency::TransactionContext *txn); + ResultType DropDatabaseWithOid(concurrency::TransactionContext *txn, + oid_t database_oid); // Drop a schema(namespace) using schema name - ResultType DropSchema(const std::string &database_name, - const std::string &schema_name, - concurrency::TransactionContext *txn); + ResultType DropSchema(concurrency::TransactionContext *txn, + const std::string &database_name, + const std::string &schema_name); // Drop a table using table name - ResultType DropTable(const std::string &database_name, + ResultType DropTable(concurrency::TransactionContext *txn, + const std::string &database_name, const std::string &schema_name, - const std::string &table_name, - concurrency::TransactionContext *txn); + const std::string &table_name); + // Drop a table, use this one in the future - ResultType DropTable(oid_t database_oid, oid_t table_oid, - concurrency::TransactionContext *txn); + ResultType DropTable(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t table_oid); + // Drop an index, using its index_oid - ResultType DropIndex(oid_t database_oid, oid_t index_oid, - concurrency::TransactionContext *txn); + ResultType DropIndex(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t index_oid); /** @brief Drop layout * tile_groups @@ -187,8 +199,10 @@ class Catalog { * @param txn TransactionContext * @return ResultType(SUCCESS or FAILURE) */ - ResultType DropLayout(oid_t database_oid, oid_t table_oid, oid_t layout_oid, - concurrency::TransactionContext *txn); + ResultType DropLayout(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t table_oid, + oid_t layout_oid); //===--------------------------------------------------------------------===// // GET WITH NAME - CHECK FROM CATALOG TABLES, USING TRANSACTION //===--------------------------------------------------------------------===// @@ -197,42 +211,45 @@ class Catalog { * get it from storage layer using database_oid, * throw exception and abort txn if not exists/invisible * */ - storage::Database *GetDatabaseWithName( - const std::string &db_name, concurrency::TransactionContext *txn) const; + storage::Database *GetDatabaseWithName(concurrency::TransactionContext *txn, + const std::string &db_name) const; /* Check table from pg_table with table_name & schema_name using txn, * get it from storage layer using table_oid, * throw exception and abort txn if not exists/invisible * */ - storage::DataTable *GetTableWithName(const std::string &database_name, + storage::DataTable *GetTableWithName(concurrency::TransactionContext *txn, + const std::string &database_name, const std::string &schema_name, - const std::string &table_name, - concurrency::TransactionContext *txn); + const std::string &table_name); /* Check table from pg_database with database_name using txn, * get it from storage layer using table_oid, * throw exception and abort txn if not exists/invisible * */ - std::shared_ptr GetDatabaseObject( - const std::string &database_name, concurrency::TransactionContext *txn); - std::shared_ptr GetDatabaseObject( - oid_t database_oid, concurrency::TransactionContext *txn); + std::shared_ptr GetDatabaseCatalogEntry(concurrency::TransactionContext *txn, + const std::string &database_name); + + std::shared_ptr GetDatabaseCatalogEntry(concurrency::TransactionContext *txn, + oid_t database_oid); /* Check table from pg_table with table_name using txn, * get it from storage layer using table_oid, * throw exception and abort txn if not exists/invisible * */ - std::shared_ptr GetTableObject( - const std::string &database_name, const std::string &schema_name, - const std::string &table_name, concurrency::TransactionContext *txn); - std::shared_ptr GetTableObject( - oid_t database_oid, oid_t table_oid, - concurrency::TransactionContext *txn); + std::shared_ptr GetTableCatalogEntry(concurrency::TransactionContext *txn, + const std::string &database_name, + const std::string &schema_name, + const std::string &table_name); + + std::shared_ptr GetTableCatalogEntry(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t table_oid); /* * Using database oid to get system catalog object */ - std::shared_ptr GetSystemCatalogs(const oid_t database_oid); + std::shared_ptr GetSystemCatalogs(oid_t database_oid); //===--------------------------------------------------------------------===// // DEPRECATED FUNCTIONS //===--------------------------------------------------------------------===// @@ -252,34 +269,39 @@ class Catalog { void InitializeFunctions(); - void AddPlpgsqlFunction( - const std::string &name, const std::vector &argument_types, - const type::TypeId return_type, oid_t prolang, - const std::string &func_src, - std::shared_ptr code_context, - concurrency::TransactionContext *txn); - - void AddBuiltinFunction(const std::string &name, - const std::vector &argument_types, - const type::TypeId return_type, oid_t prolang, - const std::string &func_name, + void AddProcedure(concurrency::TransactionContext *txn, + const std::string &name, + type::TypeId return_type, + const std::vector &argument_types, + oid_t prolang, + std::shared_ptr code_context, + const std::string &func_src); + + // TODO(Tianyu): Somebody should comment on what the difference between name + // and func_name is. I am confused. + void AddBuiltinFunction(concurrency::TransactionContext *txn, + const std::string &name, function::BuiltInFuncType func, - concurrency::TransactionContext *txn); + const std::string &func_name, + type::TypeId return_type, + const std::vector &argument_types, + oid_t prolang); - const FunctionData GetFunction( - const std::string &name, const std::vector &argument_types); + const FunctionData GetFunction(const std::string &name, + const std::vector &argument_types); private: Catalog(); - void BootstrapSystemCatalogs(storage::Database *database, - concurrency::TransactionContext *txn); + void BootstrapSystemCatalogs(concurrency::TransactionContext *txn, + storage::Database *database); // Create the primary key index for a table, don't call this function outside // catalog.cpp - ResultType CreatePrimaryIndex(oid_t database_oid, oid_t table_oid, + ResultType CreatePrimaryIndex(concurrency::TransactionContext *txn, + oid_t database_oid, const std::string &schema_name, - concurrency::TransactionContext *txn); + oid_t table_oid); // The pool for new varlen tuple fields std::unique_ptr pool_; diff --git a/src/include/catalog/catalog_cache.h b/src/include/catalog/catalog_cache.h index 28ff9edacd0..3f00559a8db 100644 --- a/src/include/catalog/catalog_cache.h +++ b/src/include/catalog/catalog_cache.h @@ -25,49 +25,48 @@ class PlanUtil; namespace catalog { -class DatabaseCatalogObject; -class TableCatalogObject; -class IndexCatalogObject; +class DatabaseCatalogEntry; +class TableCatalogEntry; +class IndexCatalogEntry; class CatalogCache { friend class Transaction; friend class DatabaseCatalog; friend class TableCatalog; friend class IndexCatalog; - friend class DatabaseCatalogObject; - friend class TableCatalogObject; - friend class IndexCatalogObject; + friend class DatabaseCatalogEntry; + friend class TableCatalogEntry; + friend class IndexCatalogEntry; friend class planner::PlanUtil; public: CatalogCache() {} - CatalogCache(CatalogCache const &) = delete; - CatalogCache &operator=(CatalogCache const &) = delete; + DISALLOW_COPY(CatalogCache) private: - std::shared_ptr GetDatabaseObject(oid_t database_oid); - std::shared_ptr GetDatabaseObject( + std::shared_ptr GetDatabaseObject(oid_t database_oid); + std::shared_ptr GetDatabaseObject( const std::string &name); - std::shared_ptr GetCachedTableObject(oid_t database_oid, - oid_t table_oid); - std::shared_ptr GetCachedIndexObject(oid_t database_oid, - oid_t index_oid); - std::shared_ptr GetCachedIndexObject( - const std::string &database_name, const std::string &index_name, - const std::string &schema_name); + std::shared_ptr GetCachedTableObject(oid_t database_oid, + oid_t table_oid); + std::shared_ptr GetCachedIndexObject(oid_t database_oid, + oid_t index_oid); + std::shared_ptr GetCachedIndexObject(const std::string &database_name, + const std::string &schema_name, + const std::string &index_name); // database catalog cache interface bool InsertDatabaseObject( - std::shared_ptr database_object); + std::shared_ptr database_object); bool EvictDatabaseObject(oid_t database_oid); bool EvictDatabaseObject(const std::string &database_name); // cache for database catalog object - std::unordered_map> - database_objects_cache; - std::unordered_map> - database_name_cache; + std::unordered_map> + database_objects_cache_; + std::unordered_map> + database_name_cache_; }; } // namespace catalog diff --git a/src/include/catalog/column.h b/src/include/catalog/column.h index f351f72c5b9..a8741247648 100644 --- a/src/include/catalog/column.h +++ b/src/include/catalog/column.h @@ -29,7 +29,7 @@ class Column : public Printable { friend class Constraint; public: - Column() : column_type(type::TypeId::INVALID), fixed_length(INVALID_OID) { + Column() : column_type_(type::TypeId::INVALID), fixed_length_(INVALID_OID) { // Nothing to see... } @@ -37,10 +37,10 @@ class Column : public Printable { std::string column_name, bool is_inlined = false, oid_t column_offset = INVALID_OID) : column_name(column_name), - column_type(value_type), - fixed_length(INVALID_OID), - is_inlined(is_inlined), - column_offset(column_offset) { + column_type_(value_type), + fixed_length_(INVALID_OID), + is_inlined_(is_inlined), + column_offset_(column_offset) { SetInlined(); // We should not have an inline value of length 0 @@ -61,24 +61,24 @@ class Column : public Printable { // Set the appropriate column length void SetLength(size_t column_length); - oid_t GetOffset() const { return column_offset; } + oid_t GetOffset() const { return column_offset_; } std::string GetName() const { return column_name; } size_t GetLength() const { - if (is_inlined) - return fixed_length; + if (is_inlined_) + return fixed_length_; else - return variable_length; + return variable_length_; } - size_t GetFixedLength() const { return fixed_length; } + size_t GetFixedLength() const { return fixed_length_; } - size_t GetVariableLength() const { return variable_length; } + size_t GetVariableLength() const { return variable_length_; } - inline type::TypeId GetType() const { return column_type; } + inline type::TypeId GetType() const { return column_type_; } - inline bool IsInlined() const { return is_inlined; } + inline bool IsInlined() const { return is_inlined_; } inline bool IsPrimary() const { return is_primary_; } @@ -88,9 +88,9 @@ class Column : public Printable { void AddConstraint(const catalog::Constraint &constraint) { if (constraint.GetType() == ConstraintType::DEFAULT) { // Add the default constraint to the front - constraints.insert(constraints.begin(), constraint); + constraints_.insert(constraints_.begin(), constraint); } else { - constraints.push_back(constraint); + constraints_.push_back(constraint); } if (constraint.GetType() == ConstraintType::PRIMARY) { @@ -101,16 +101,16 @@ class Column : public Printable { } } - const std::vector &GetConstraints() const { return constraints; } + const std::vector &GetConstraints() const { return constraints_; } hash_t Hash() const { - hash_t hash = HashUtil::Hash(&column_type); - return HashUtil::CombineHashes(hash, HashUtil::Hash(&is_inlined)); + hash_t hash = HashUtil::Hash(&column_type_); + return HashUtil::CombineHashes(hash, HashUtil::Hash(&is_inlined_)); } // Compare two column objects bool operator==(const Column &other) const { - if (other.column_type != column_type || other.is_inlined != is_inlined) { + if (other.column_type_ != column_type_ || other.is_inlined_ != is_inlined_) { return false; } return true; @@ -130,18 +130,18 @@ class Column : public Printable { private: // value type of column - type::TypeId column_type; // = type::TypeId::INVALID; + type::TypeId column_type_; // = type::TypeId::INVALID; // if the column is not inlined, this is set to pointer size // else, it is set to length of the fixed length column - size_t fixed_length; // = INVALID_OID; + size_t fixed_length_; // = INVALID_OID; // if the column is inlined, this is set to 0 // else, it is set to length of the variable length column - size_t variable_length = 0; + size_t variable_length_ = 0; // is the column inlined ? - bool is_inlined = false; + bool is_inlined_ = false; // is the column contained the primary key? bool is_primary_ = false; @@ -150,10 +150,10 @@ class Column : public Printable { bool is_unique_ = false; // offset of column in tuple - oid_t column_offset = INVALID_OID; + oid_t column_offset_ = INVALID_OID; // Constraints - std::vector constraints; + std::vector constraints_; }; } // namespace catalog diff --git a/src/include/catalog/column_catalog.h b/src/include/catalog/column_catalog.h index 6a9173029fb..490855822f1 100644 --- a/src/include/catalog/column_catalog.h +++ b/src/include/catalog/column_catalog.h @@ -38,41 +38,42 @@ namespace peloton { namespace catalog { -class ColumnCatalogObject { +class ColumnCatalogEntry { public: - ColumnCatalogObject(executor::LogicalTile *tile, int tupleId = 0); - - inline oid_t GetTableOid() { return table_oid; } - inline const std::string &GetColumnName() { return column_name; } - inline oid_t GetColumnId() { return column_id; } - inline oid_t GetColumnOffset() { return column_offset; } - inline type::TypeId GetColumnType() { return column_type; } - inline size_t GetColumnLength() { return column_length; } - inline bool IsInlined() { return is_inlined; } - inline bool IsPrimary() { return is_primary; } - inline bool IsNotNull() { return is_not_null; } + ColumnCatalogEntry(executor::LogicalTile *tile, int tupleId = 0); + + inline oid_t GetTableOid() { return table_oid_; } + inline const std::string &GetColumnName() { return column_name_; } + inline oid_t GetColumnId() { return column_id_; } + inline oid_t GetColumnOffset() { return column_offset_; } + inline type::TypeId GetColumnType() { return column_type_; } + inline size_t GetColumnLength() { return column_length_; } + inline bool IsInlined() { return is_inlined_; } + inline bool IsPrimary() { return is_primary_; } + inline bool IsNotNull() { return is_not_null_; } private: // member variables - oid_t table_oid; - std::string column_name; - oid_t column_id; - oid_t column_offset; - type::TypeId column_type; - size_t column_length; - bool is_inlined; - bool is_primary; - bool is_not_null; + oid_t table_oid_; + std::string column_name_; + oid_t column_id_; + oid_t column_offset_; + type::TypeId column_type_; + size_t column_length_; + bool is_inlined_; + bool is_primary_; + bool is_not_null_; }; class ColumnCatalog : public AbstractCatalog { - friend class ColumnCatalogObject; - friend class TableCatalogObject; + friend class ColumnCatalogEntry; + friend class TableCatalogEntry; friend class Catalog; public: - ColumnCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, - concurrency::TransactionContext *txn); + ColumnCatalog(concurrency::TransactionContext *txn, + storage::Database *pg_catalog, + type::AbstractPool *pool); ~ColumnCatalog(); @@ -84,22 +85,30 @@ class ColumnCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertColumn(oid_t table_oid, const std::string &column_name, - oid_t column_id, oid_t column_offset, - type::TypeId column_type, size_t column_length, - bool is_inlined, const std::vector &constraints, - type::AbstractPool *pool, - concurrency::TransactionContext *txn); - bool DeleteColumn(oid_t table_oid, const std::string &column_name, - concurrency::TransactionContext *txn); - bool DeleteColumns(oid_t table_oid, concurrency::TransactionContext *txn); + bool InsertColumn(concurrency::TransactionContext *txn, + oid_t table_oid, + oid_t column_id, + const std::string &column_name, + oid_t column_offset, + type::TypeId column_type, + size_t column_length, + const std::vector &constraints, + bool is_inlined, + type::AbstractPool *pool); + + bool DeleteColumn(concurrency::TransactionContext *txn, + oid_t table_oid, + const std::string &column_name); + + bool DeleteColumns(concurrency::TransactionContext *txn, oid_t table_oid); private: //===--------------------------------------------------------------------===// // Read Related API(only called within table catalog object) //===--------------------------------------------------------------------===// - const std::unordered_map> - GetColumnObjects(oid_t table_oid, concurrency::TransactionContext *txn); + const std::unordered_map> + GetColumnCatalogEntries(concurrency::TransactionContext *txn, + oid_t table_oid); std::unique_ptr InitializeSchema(); @@ -115,7 +124,7 @@ class ColumnCatalog : public AbstractCatalog { IS_NOT_NULL = 8, // Add new columns here in creation order }; - std::vector all_column_ids = {0, 1, 2, 3, 4, 5, 6, 7, 8}; + std::vector all_column_ids_ = {0, 1, 2, 3, 4, 5, 6, 7, 8}; enum IndexId { PRIMARY_KEY = 0, diff --git a/src/include/catalog/column_stats_catalog.h b/src/include/catalog/column_stats_catalog.h index d409a9da338..fd643400db6 100644 --- a/src/include/catalog/column_stats_catalog.h +++ b/src/include/catalog/column_stats_catalog.h @@ -56,27 +56,38 @@ class ColumnStatsCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertColumnStats(oid_t database_id, oid_t table_id, oid_t column_id, - int num_rows, double cardinality, double frac_null, + bool InsertColumnStats(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + oid_t column_id, + std::string column_name, + int num_rows, + double frac_null, std::string most_common_vals, std::string most_common_freqs, - std::string histogram_bounds, std::string column_name, - bool has_index, type::AbstractPool *pool, - concurrency::TransactionContext *txn); - bool DeleteColumnStats(oid_t database_id, oid_t table_id, oid_t column_id, - concurrency::TransactionContext *txn); + std::string histogram_bounds, + double cardinality, + bool has_index, + type::AbstractPool *pool); + + bool DeleteColumnStats(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + oid_t column_id); //===--------------------------------------------------------------------===// // Read-only Related API //===--------------------------------------------------------------------===// - std::unique_ptr> GetColumnStats( - oid_t database_id, oid_t table_id, oid_t column_id, - concurrency::TransactionContext *txn); - - size_t GetTableStats( - oid_t database_id, oid_t table_id, concurrency::TransactionContext *txn, - std::map>> & - column_stats_map); + std::unique_ptr> GetColumnStats(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + oid_t column_id); + + size_t GetTableStats(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + std::map>> + &column_stats_map); // TODO: add more if needed enum ColumnId { diff --git a/src/include/catalog/constraint.h b/src/include/catalog/constraint.h index c63b881c727..7f67b1f78b6 100644 --- a/src/include/catalog/constraint.h +++ b/src/include/catalog/constraint.h @@ -14,6 +14,7 @@ #pragma once #include +#include #include #include "common/printable.h" @@ -30,56 +31,55 @@ namespace catalog { class Constraint : public Printable { public: Constraint(ConstraintType type, std::string constraint_name) - : constraint_type(type), constraint_name(constraint_name) {} + : constraint_type_(type), constraint_name_(std::move(constraint_name)) {} Constraint(ConstraintType type, std::string constraint_name, std::string check_cmd) - : constraint_type(type), - constraint_name(constraint_name), - check_cmd(check_cmd) {} + : constraint_type_(type), + constraint_name_(std::move(constraint_name)), + check_cmd_(std::move(check_cmd)) {} //===--------------------------------------------------------------------===// // ACCESSORS //===--------------------------------------------------------------------===// - ConstraintType GetType() const { return constraint_type; } + ConstraintType GetType() const { return constraint_type_; } - std::pair GetCheckExpression() { return exp; } + std::pair GetCheckExpression() { return exp_; } // Offset into the list of "reference tables" in the Table. - void SetForeignKeyListOffset(oid_t offset) { fk_list_offset = offset; } + void SetForeignKeyListOffset(oid_t offset) { fk_list_offset_ = offset; } // Offset into the list of "unique indices" in the Table. - void SetUniqueIndexOffset(oid_t offset) { unique_index_list_offset = offset; } + void SetUniqueIndexOffset(oid_t offset) { + unique_index_list_offset_ = offset; + } // Get the offset - oid_t GetForeignKeyListOffset() const { return fk_list_offset; } + oid_t GetForeignKeyListOffset() const { return fk_list_offset_; } // Get the offset - oid_t GetUniqueIndexOffset() const { return unique_index_list_offset; } + oid_t GetUniqueIndexOffset() const { return unique_index_list_offset_; } - std::string GetName() const { return constraint_name; } + std::string GetName() const { return constraint_name_; } // Get a string representation for debugging - const std::string GetInfo() const; + const std::string GetInfo() const override; // Todo: default union data structure, // For default constraint void addDefaultValue(const type::Value &value) { - if (constraint_type != ConstraintType::DEFAULT || default_value.get() != nullptr) { - return; - } - - default_value.reset(new peloton::type::Value(value)); + if (constraint_type_ != ConstraintType::DEFAULT + || default_value_.get() != nullptr) return; + default_value_.reset(new peloton::type::Value(value)); } - type::Value* getDefaultValue() { - return default_value.get(); + type::Value *getDefaultValue() { + return default_value_.get(); } // Add check constrain void AddCheck(ExpressionType op, peloton::type::Value val) { - exp = std::pair(op, val); - return; + exp_ = std::pair(op, val); }; private: @@ -88,21 +88,21 @@ class Constraint : public Printable { //===--------------------------------------------------------------------===// // The type of constraint - ConstraintType constraint_type = ConstraintType::INVALID; + ConstraintType constraint_type_ = ConstraintType::INVALID; // Offsets into the Unique index and reference table lists in Table - oid_t fk_list_offset = INVALID_OID; + oid_t fk_list_offset_ = INVALID_OID; - oid_t unique_index_list_offset = INVALID_OID; + oid_t unique_index_list_offset_ = INVALID_OID; - std::string constraint_name; + std::string constraint_name_; - std::shared_ptr default_value; + std::shared_ptr default_value_; - std::string check_cmd = ""; + std::string check_cmd_ = ""; // key string is column name - std::pair exp; + std::pair exp_; }; } // namespace catalog diff --git a/src/include/catalog/database_catalog.h b/src/include/catalog/database_catalog.h index fc94b1944bb..91267c3d995 100644 --- a/src/include/catalog/database_catalog.h +++ b/src/include/catalog/database_catalog.h @@ -33,69 +33,75 @@ namespace peloton { namespace catalog { -class TableCatalogObject; -class IndexCatalogObject; +class TableCatalogEntry; +class IndexCatalogEntry; -class DatabaseCatalogObject { +class DatabaseCatalogEntry { friend class DatabaseCatalog; friend class TableCatalog; friend class CatalogCache; public: - DatabaseCatalogObject(executor::LogicalTile *tile, - concurrency::TransactionContext *txn); + DatabaseCatalogEntry(concurrency::TransactionContext *txn, + executor::LogicalTile *tile); - void EvictAllTableObjects(); - std::shared_ptr GetTableObject(oid_t table_oid, - bool cached_only = false); - std::shared_ptr GetTableObject( + void EvictAllTableCatalogEntries(); + + std::shared_ptr GetTableCatalogEntry(oid_t table_oid, + bool cached_only = false); + std::shared_ptr GetTableCatalogEntry( const std::string &table_name, const std::string &schema_name, bool cached_only = false); - bool IsValidTableObjects() { - // return true if this database object contains all table - // objects within the database - return valid_table_objects; + bool IsValidTableCatalogEntries() { + // return true if this database catalog entries contains all table + // catalog entries within the database + return valid_table_catalog_entries; } - std::vector> GetTableObjects( + std::vector> GetTableCatalogEntries( const std::string &schema_name); - std::unordered_map> - GetTableObjects(bool cached_only = false); + std::unordered_map> + GetTableCatalogEntries(bool cached_only = false); + + inline oid_t GetDatabaseOid() { return database_oid_; } - inline oid_t GetDatabaseOid() { return database_oid; } - inline const std::string &GetDatabaseName() { return database_name; } + inline const std::string &GetDatabaseName() { return database_name_; } private: // member variables - oid_t database_oid; - std::string database_name; + oid_t database_oid_; + std::string database_name_; + + bool InsertTableCatalogEntry(std::shared_ptr table_catalog_entry); + + bool EvictTableCatalogEntry(oid_t table_oid); - bool InsertTableObject(std::shared_ptr table_object); - bool EvictTableObject(oid_t table_oid); - bool EvictTableObject(const std::string &table_name, - const std::string &schema_name); - void SetValidTableObjects(bool valid = true) { valid_table_objects = valid; } + bool EvictTableCatalogEntry(const std::string &table_name, + const std::string &schema_name); - std::shared_ptr GetCachedIndexObject(oid_t index_oid); - std::shared_ptr GetCachedIndexObject( + void SetValidTableCatalogEntries(bool valid = true) { valid_table_catalog_entries = valid; } + + std::shared_ptr GetCachedIndexCatalogEntry(oid_t index_oid); + + std::shared_ptr GetCachedIndexCatalogEntry( const std::string &index_name, const std::string &schema_name); // cache for table name to oid translation - std::unordered_map> - table_objects_cache; - std::unordered_map> - table_name_cache; - bool valid_table_objects; + std::unordered_map> + table_catalog_entries_cache_; + std::unordered_map> + table_catalog_entries_cache_by_name; + bool valid_table_catalog_entries; // Pointer to its corresponding transaction // This object is only visible during this transaction - concurrency::TransactionContext *txn; + concurrency::TransactionContext *txn_; }; class DatabaseCatalog : public AbstractCatalog { - friend class DatabaseCatalogObject; + friend class DatabaseCatalogEntry; friend class TableCatalog; friend class CatalogCache; friend class Catalog; @@ -104,10 +110,9 @@ class DatabaseCatalog : public AbstractCatalog { ~DatabaseCatalog(); // Global Singleton, only the first call requires passing parameters. - static DatabaseCatalog *GetInstance( - storage::Database *pg_catalog = nullptr, - type::AbstractPool *pool = nullptr, - concurrency::TransactionContext *txn = nullptr); + static DatabaseCatalog *GetInstance(concurrency::TransactionContext *txn = nullptr, + storage::Database *pg_catalog = nullptr, + type::AbstractPool *pool = nullptr); inline oid_t GetNextOid() { return oid_++ | DATABASE_OID_MASK; } @@ -116,22 +121,26 @@ class DatabaseCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertDatabase(oid_t database_oid, const std::string &database_name, - type::AbstractPool *pool, - concurrency::TransactionContext *txn); - bool DeleteDatabase(oid_t database_oid, concurrency::TransactionContext *txn); + bool InsertDatabase(concurrency::TransactionContext *txn, + oid_t database_oid, + const std::string &database_name, + type::AbstractPool *pool); + + bool DeleteDatabase(concurrency::TransactionContext *txn, oid_t database_oid); private: //===--------------------------------------------------------------------===// // Read Related API //===--------------------------------------------------------------------===// - std::shared_ptr GetDatabaseObject( - oid_t database_oid, concurrency::TransactionContext *txn); - std::shared_ptr GetDatabaseObject( - const std::string &database_name, concurrency::TransactionContext *txn); + std::shared_ptr GetDatabaseCatalogEntry(concurrency::TransactionContext *txn, + oid_t database_oid); + + std::shared_ptr GetDatabaseCatalogEntry(concurrency::TransactionContext *txn, + const std::string &database_name); - DatabaseCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, - concurrency::TransactionContext *txn); + DatabaseCatalog(concurrency::TransactionContext *txn, + storage::Database *pg_catalog, + type::AbstractPool *pool); std::unique_ptr InitializeSchema(); @@ -140,7 +149,7 @@ class DatabaseCatalog : public AbstractCatalog { DATABASE_NAME = 1, // Add new columns here in creation order }; - std::vector all_column_ids = {0, 1}; + std::vector all_column_ids_ = {0, 1}; enum IndexId { PRIMARY_KEY = 0, diff --git a/src/include/catalog/database_metrics_catalog.h b/src/include/catalog/database_metrics_catalog.h index a035063a1a5..bb72bc540dc 100644 --- a/src/include/catalog/database_metrics_catalog.h +++ b/src/include/catalog/database_metrics_catalog.h @@ -45,16 +45,20 @@ class DatabaseMetricsCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertDatabaseMetrics(oid_t database_oid, oid_t txn_committed, - oid_t txn_aborted, oid_t time_stamp, - type::AbstractPool *pool, - concurrency::TransactionContext *txn); - bool DeleteDatabaseMetrics(oid_t database_oid, concurrency::TransactionContext *txn); + bool InsertDatabaseMetrics(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t txn_committed, + oid_t txn_aborted, + oid_t time_stamp, + type::AbstractPool *pool); + + bool DeleteDatabaseMetrics(concurrency::TransactionContext *txn, + oid_t database_oid); //===--------------------------------------------------------------------===// // Read-only Related API //===--------------------------------------------------------------------===// - oid_t GetTimeStamp(oid_t database_oid, concurrency::TransactionContext *txn); + oid_t GetTimestamp(concurrency::TransactionContext *txn, oid_t database_oid); // TODO: add more if needed enum ColumnId { diff --git a/src/include/catalog/foreign_key.h b/src/include/catalog/foreign_key.h index 02b28d7abf6..1fb745560e7 100644 --- a/src/include/catalog/foreign_key.h +++ b/src/include/catalog/foreign_key.h @@ -36,40 +36,40 @@ class ForeignKey { FKConstrActionType delete_action, std::string constraint_name) - : source_table_id(source_table_id), - sink_table_id(sink_table_id), - sink_col_ids(sink_col_ids), - source_col_ids(source_col_ids), - update_action(update_action), - delete_action(delete_action), - fk_name(constraint_name) {} + : source_table_id_(source_table_id), + sink_table_id_(sink_table_id), + sink_col_ids_(sink_col_ids), + source_col_ids_(source_col_ids), + update_action_(update_action), + delete_action_(delete_action), + fk_name_(constraint_name) {} - oid_t GetSourceTableOid() const { return source_table_id; } - oid_t GetSinkTableOid() const { return sink_table_id; } + oid_t GetSourceTableOid() const { return source_table_id_; } + oid_t GetSinkTableOid() const { return sink_table_id_; } - std::vector GetSinkColumnIds() const { return sink_col_ids; } - std::vector GetSourceColumnIds() const { return source_col_ids; } + std::vector GetSinkColumnIds() const { return sink_col_ids_; } + std::vector GetSourceColumnIds() const { return source_col_ids_; } - FKConstrActionType GetUpdateAction() const { return update_action; } - FKConstrActionType GetDeleteAction() const { return delete_action; } - std::string &GetConstraintName() { return fk_name; } + FKConstrActionType GetUpdateAction() const { return update_action_; } + FKConstrActionType GetDeleteAction() const { return delete_action_; } + std::string &GetConstraintName() { return fk_name_; } private: - oid_t source_table_id = INVALID_OID; - oid_t sink_table_id = INVALID_OID; + oid_t source_table_id_ = INVALID_OID; + oid_t sink_table_id_ = INVALID_OID; // Columns in the reference table (sink) - std::vector sink_col_ids; + std::vector sink_col_ids_; // Columns in the current table (source) // Can be a single column or multiple columns depending // on the constraint - std::vector source_col_ids; + std::vector source_col_ids_; - FKConstrActionType update_action; - FKConstrActionType delete_action; + FKConstrActionType update_action_; + FKConstrActionType delete_action_; - std::string fk_name; + std::string fk_name_; }; } // namespace catalog diff --git a/src/include/catalog/index_catalog.h b/src/include/catalog/index_catalog.h index 68e4d754f4c..dcd15ea285a 100644 --- a/src/include/catalog/index_catalog.h +++ b/src/include/catalog/index_catalog.h @@ -40,41 +40,42 @@ namespace peloton { namespace catalog { -class IndexCatalogObject { - friend class TableCatalogObject; +class IndexCatalogEntry { + friend class TableCatalogEntry; public: - IndexCatalogObject(executor::LogicalTile *tile, int tupleId = 0); + IndexCatalogEntry(executor::LogicalTile *tile, int tupleId = 0); - inline oid_t GetIndexOid() { return index_oid; } - inline const std::string &GetIndexName() { return index_name; } - inline oid_t GetTableOid() { return table_oid; } - inline const std::string &GetSchemaName() { return schema_name; } - inline IndexType GetIndexType() { return index_type; } - inline IndexConstraintType GetIndexConstraint() { return index_constraint; } - inline bool HasUniqueKeys() { return unique_keys; } - inline const std::vector &GetKeyAttrs() { return key_attrs; } + inline oid_t GetIndexOid() { return index_oid_; } + inline const std::string &GetIndexName() { return index_name_; } + inline oid_t GetTableOid() { return table_oid_; } + inline const std::string &GetSchemaName() { return schema_name_; } + inline IndexType GetIndexType() { return index_type_; } + inline IndexConstraintType GetIndexConstraint() { return index_constraint_; } + inline bool HasUniqueKeys() { return unique_keys_; } + inline const std::vector &GetKeyAttrs() { return key_attrs_; } private: // member variables - oid_t index_oid; - std::string index_name; - oid_t table_oid; - std::string schema_name; - IndexType index_type; - IndexConstraintType index_constraint; - bool unique_keys; - std::vector key_attrs; + oid_t index_oid_; + std::string index_name_; + oid_t table_oid_; + std::string schema_name_; + IndexType index_type_; + IndexConstraintType index_constraint_; + bool unique_keys_; + std::vector key_attrs_; }; class IndexCatalog : public AbstractCatalog { - friend class IndexCatalogObject; - friend class TableCatalogObject; + friend class IndexCatalogEntry; + friend class TableCatalogEntry; friend class Catalog; public: - IndexCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, - concurrency::TransactionContext *txn); + IndexCatalog(concurrency::TransactionContext *txn, + storage::Database *pg_catalog, + type::AbstractPool *pool); ~IndexCatalog(); @@ -83,27 +84,36 @@ class IndexCatalog : public AbstractCatalog { void UpdateOid(oid_t add_value) { oid_ += add_value; } /** Write Related API */ - bool InsertIndex(oid_t index_oid, const std::string &index_name, - oid_t table_oid, const std::string &schema_name, - IndexType index_type, IndexConstraintType index_constraint, - bool unique_keys, std::vector indekeys, - type::AbstractPool *pool, - concurrency::TransactionContext *txn); - bool DeleteIndex(oid_t database_oid, oid_t index_oid, - concurrency::TransactionContext *txn); + bool InsertIndex(concurrency::TransactionContext *txn, + const std::string &schema_name, + oid_t table_oid, + oid_t index_oid, + const std::string &index_name, + IndexType index_type, + IndexConstraintType index_constraint, + bool unique_keys, + std::vector index_keys, + type::AbstractPool *pool); + + bool DeleteIndex(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t index_oid); /** Read Related API */ - std::shared_ptr GetIndexObject( - const std::string &database_name, const std::string &index_name, - const std::string &schema_name, concurrency::TransactionContext *txn); + std::shared_ptr GetIndexCatalogEntry(concurrency::TransactionContext *txn, + const std::string &database_name, + const std::string &schema_name, + const std::string &index_name); private: - std::shared_ptr GetIndexObject( - oid_t database_oid, oid_t index_oid, - concurrency::TransactionContext *txn); - - const std::unordered_map> - GetIndexObjects(oid_t table_oid, concurrency::TransactionContext *txn); + std::shared_ptr GetIndexCatalogEntry(concurrency::TransactionContext *txn, + oid_t database_oid, + oid_t index_oid); + + const std::unordered_map> + GetIndexCatalogEntries( + concurrency::TransactionContext *txn, + oid_t table_oid); std::unique_ptr InitializeSchema(); diff --git a/src/include/catalog/index_metrics_catalog.h b/src/include/catalog/index_metrics_catalog.h index 7b806623565..6047bfe063f 100644 --- a/src/include/catalog/index_metrics_catalog.h +++ b/src/include/catalog/index_metrics_catalog.h @@ -38,19 +38,23 @@ namespace catalog { class IndexMetricsCatalog : public AbstractCatalog { public: - IndexMetricsCatalog(const std::string &database_name, - concurrency::TransactionContext *txn); + IndexMetricsCatalog(concurrency::TransactionContext *txn, + const std::string &database_name); ~IndexMetricsCatalog(); //===--------------------------------------------------------------------===// // Write Related API //===--------------------------------------------------------------------===// - bool InsertIndexMetrics(oid_t table_oid, oid_t index_oid, int64_t reads, - int64_t deletes, int64_t inserts, int64_t time_stamp, - type::AbstractPool *pool, - concurrency::TransactionContext *txn); - bool DeleteIndexMetrics(oid_t index_oid, - concurrency::TransactionContext *txn); + bool InsertIndexMetrics(concurrency::TransactionContext *txn, + oid_t table_oid, + oid_t index_oid, + int64_t reads, + int64_t deletes, + int64_t inserts, + int64_t time_stamp, + type::AbstractPool *pool); + + bool DeleteIndexMetrics(concurrency::TransactionContext *txn, oid_t index_oid); //===--------------------------------------------------------------------===// // Read-only Related API diff --git a/src/include/catalog/language_catalog.h b/src/include/catalog/language_catalog.h index 68249dcbe48..7a6e906d422 100644 --- a/src/include/catalog/language_catalog.h +++ b/src/include/catalog/language_catalog.h @@ -36,9 +36,9 @@ class LogicalTile; namespace catalog { -class LanguageCatalogObject { +class LanguageCatalogEntry { public: - LanguageCatalogObject(executor::LogicalTile *tuple); + LanguageCatalogEntry(executor::LogicalTile *tuple); oid_t GetOid() const { return lang_oid_; } @@ -63,28 +63,29 @@ class LanguageCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertLanguage(const std::string &lanname, type::AbstractPool *pool, - concurrency::TransactionContext *txn); + bool InsertLanguage(concurrency::TransactionContext *txn, + const std::string &lanname, + type::AbstractPool *pool); - bool DeleteLanguage(const std::string &lanname, - concurrency::TransactionContext *txn); + bool DeleteLanguage(concurrency::TransactionContext *txn, + const std::string &lanname); //===--------------------------------------------------------------------===// // Read-only Related API //===--------------------------------------------------------------------===// - std::unique_ptr GetLanguageByOid( - oid_t lang_oid, concurrency::TransactionContext *txn) const; + std::unique_ptr GetLanguageByOid(concurrency::TransactionContext *txn, + oid_t lang_oid) const; - std::unique_ptr GetLanguageByName( - const std::string &lang_name, concurrency::TransactionContext *txn) const; + std::unique_ptr GetLanguageByName(concurrency::TransactionContext *txn, + const std::string &lang_name) const; enum ColumnId { OID = 0, LANNAME = 1, // Add new columns here in creation order }; - std::vector all_column_ids = {0, 1}; + std::vector all_column_ids_ = {0, 1}; private: LanguageCatalog(concurrency::TransactionContext *txn); diff --git a/src/include/catalog/layout_catalog.h b/src/include/catalog/layout_catalog.h index 0fc224f094d..babdb346583 100644 --- a/src/include/catalog/layout_catalog.h +++ b/src/include/catalog/layout_catalog.h @@ -25,32 +25,35 @@ namespace catalog { class LayoutCatalog : public AbstractCatalog { public: - LayoutCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, - concurrency::TransactionContext *txn); + LayoutCatalog(concurrency::TransactionContext *txn, + storage::Database *pg_catalog, + type::AbstractPool *pool); ~LayoutCatalog(); //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertLayout(oid_t table_oid, + bool InsertLayout(concurrency::TransactionContext *txn, + oid_t table_oid, std::shared_ptr layout, - type::AbstractPool *pool, - concurrency::TransactionContext *txn); + type::AbstractPool *pool); - bool DeleteLayout(oid_t table_oid, oid_t layout_oid, - concurrency::TransactionContext *txn); + bool DeleteLayout(concurrency::TransactionContext *txn, + oid_t table_oid, + oid_t layout_oid); - bool DeleteLayouts(oid_t table_oid, concurrency::TransactionContext *txn); + bool DeleteLayouts(concurrency::TransactionContext *txn, oid_t table_oid); //===--------------------------------------------------------------------===// // Read Related API //===--------------------------------------------------------------------===// const std::unordered_map> - GetLayouts(oid_t table_oid, concurrency::TransactionContext *txn); + GetLayouts(concurrency::TransactionContext *txn, oid_t table_oid); - std::shared_ptr GetLayoutWithOid( - oid_t table_oid, oid_t layout_oid, concurrency::TransactionContext *txn); + std::shared_ptr GetLayoutWithOid(concurrency::TransactionContext *txn, + oid_t table_oid, + oid_t layout_oid); private: std::unique_ptr InitializeSchema(); @@ -62,7 +65,7 @@ class LayoutCatalog : public AbstractCatalog { COLUMN_MAP = 3, // Add new columns here in creation order }; - std::vector all_column_ids = {0, 1, 2, 3}; + std::vector all_column_ids_ = {0, 1, 2, 3}; enum IndexId { PRIMARY_KEY = 0, diff --git a/src/include/catalog/manager.h b/src/include/catalog/manager.h index 87aee3fcc2e..40ff5079cda 100644 --- a/src/include/catalog/manager.h +++ b/src/include/catalog/manager.h @@ -57,9 +57,9 @@ class Manager { void DropIndirectionArray(const oid_t oid); - void ClearIndirectionArray(void); + void ClearIndirectionArray(); - Manager(Manager const &) = delete; + DISALLOW_COPY(Manager) private: diff --git a/src/include/catalog/multi_constraint.h b/src/include/catalog/multi_constraint.h index 9a5e6e13f9d..46b254ed90e 100644 --- a/src/include/catalog/multi_constraint.h +++ b/src/include/catalog/multi_constraint.h @@ -30,26 +30,26 @@ namespace catalog { class MultiConstraint : public Printable { public: MultiConstraint(ConstraintType type, std::string constraint_name) - : constraint_type(type), constraint_name(constraint_name){}; + : constraint_type_(type), constraint_name_(constraint_name){}; MultiConstraint(ConstraintType type, std::string constraint_name, std::vector column_ids) - : constraint_type(type), constraint_name(constraint_name) { - this->column_ids = column_ids; + : constraint_type_(type), constraint_name_(constraint_name) { + this->column_ids_ = column_ids; }; //===--------------------------------------------------------------------===// // ACCESSORS //===--------------------------------------------------------------------===// - ConstraintType GetType() const { return constraint_type; } + ConstraintType GetType() const { return constraint_type_; } - std::string GetName() const { return constraint_name; } + std::string GetName() const { return constraint_name_; } // Get a string representation for debugging const std::string GetInfo() const; - std::vector GetCols() const { return column_ids; } + std::vector GetCols() const { return column_ids_; } private: //===--------------------------------------------------------------------===// @@ -57,13 +57,13 @@ class MultiConstraint : public Printable { //===--------------------------------------------------------------------===// // The type of constraint - ConstraintType constraint_type = ConstraintType::INVALID; + ConstraintType constraint_type_ = ConstraintType::INVALID; // constraints on column set - std::vector column_ids; + std::vector column_ids_; // we do not allow duplicate constraint name in single table - std::string constraint_name; + std::string constraint_name_; }; } // namespace catalog diff --git a/src/include/catalog/proc_catalog.h b/src/include/catalog/proc_catalog.h index 75c1a666123..19fc39fbd43 100644 --- a/src/include/catalog/proc_catalog.h +++ b/src/include/catalog/proc_catalog.h @@ -34,14 +34,15 @@ namespace peloton { namespace catalog { // Forward declare -class LanguageCatalogObject; +class LanguageCatalogEntry; //===----------------------------------------------------------------------===// // In-memory representation of a row from the pg_proc table. //===----------------------------------------------------------------------===// -class ProcCatalogObject { +class ProcCatalogEntry { public: - ProcCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn); + ProcCatalogEntry(concurrency::TransactionContext *txn, + executor::LogicalTile *tile); // Accessors @@ -55,7 +56,7 @@ class ProcCatalogObject { oid_t GetLangOid() const { return lang_oid_; } - std::unique_ptr GetLanguage() const; + std::unique_ptr GetLanguage() const; const std::string &GetSrc() const { return src_; } @@ -89,22 +90,24 @@ class ProcCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertProc(const std::string &proname, type::TypeId prorettype, - const std::vector &proargtypes, oid_t prolang, - const std::string &prosrc, type::AbstractPool *pool, - concurrency::TransactionContext *txn); + bool InsertProc(concurrency::TransactionContext *txn, + const std::string &proname, + type::TypeId prorettype, + const std::vector &proargtypes, + oid_t prolang, + const std::string &prosrc, + type::AbstractPool *pool); //===--------------------------------------------------------------------===// // Read-only Related API //===--------------------------------------------------------------------===// - std::unique_ptr GetProcByOid( - oid_t proc_oid, concurrency::TransactionContext *txn) const; + std::unique_ptr GetProcByOid(concurrency::TransactionContext *txn, + oid_t proc_oid) const; - std::unique_ptr GetProcByName( - const std::string &proc_name, - const std::vector &proc_arg_types, - concurrency::TransactionContext *txn) const; + std::unique_ptr GetProcByName(concurrency::TransactionContext *txn, + const std::string &proc_name, + const std::vector &proc_arg_types) const; enum ColumnId { OID = 0, @@ -115,7 +118,7 @@ class ProcCatalog : public AbstractCatalog { PROSRC = 5, // Add new columns here in creation order }; - std::vector all_column_ids = {0, 1, 2, 3, 4, 5}; + std::vector all_column_ids_ = {0, 1, 2, 3, 4, 5}; private: ProcCatalog(concurrency::TransactionContext *txn); diff --git a/src/include/catalog/query_history_catalog.h b/src/include/catalog/query_history_catalog.h index 3f004508d02..0c69fe9c54e 100644 --- a/src/include/catalog/query_history_catalog.h +++ b/src/include/catalog/query_history_catalog.h @@ -41,10 +41,11 @@ class QueryHistoryCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertQueryHistory(const std::string &query_string, - const std::string &fingerprint, uint64_t timestamp, - type::AbstractPool *pool, - concurrency::TransactionContext *txn); + bool InsertQueryHistory(concurrency::TransactionContext *txn, + const std::string &query_string, + const std::string &fingerprint, + uint64_t timestamp, + type::AbstractPool *pool); enum ColumnId { QUERY_STRING = 0, diff --git a/src/include/catalog/query_metrics_catalog.h b/src/include/catalog/query_metrics_catalog.h index a8045fd94e1..30e44ccbc43 100644 --- a/src/include/catalog/query_metrics_catalog.h +++ b/src/include/catalog/query_metrics_catalog.h @@ -43,32 +43,40 @@ namespace catalog { class QueryMetricsCatalog : public AbstractCatalog { public: - QueryMetricsCatalog(const std::string &database_name, - concurrency::TransactionContext *txn); + QueryMetricsCatalog(concurrency::TransactionContext *txn, + const std::string &database_name); ~QueryMetricsCatalog(); //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertQueryMetrics(const std::string &name, oid_t database_oid, + bool InsertQueryMetrics(concurrency::TransactionContext *txn, + const std::string &name, + oid_t database_oid, int64_t num_params, const stats::QueryMetric::QueryParamBuf &type_buf, const stats::QueryMetric::QueryParamBuf &format_buf, const stats::QueryMetric::QueryParamBuf &value_buf, - int64_t reads, int64_t updates, int64_t deletes, - int64_t inserts, int64_t latency, int64_t cpu_time, - int64_t time_stamp, type::AbstractPool *pool, - concurrency::TransactionContext *txn); - bool DeleteQueryMetrics(const std::string &name, - concurrency::TransactionContext *txn); + int64_t reads, + int64_t updates, + int64_t deletes, + int64_t inserts, + int64_t latency, + int64_t cpu_time, + int64_t time_stamp, + type::AbstractPool *pool); + + bool DeleteQueryMetrics(concurrency::TransactionContext *txn, + const std::string &name); //===--------------------------------------------------------------------===// // Read-only Related API //===--------------------------------------------------------------------===// - stats::QueryMetric::QueryParamBuf GetParamTypes( - const std::string &name, concurrency::TransactionContext *txn); - int64_t GetNumParams(const std::string &name, - concurrency::TransactionContext *txn); + stats::QueryMetric::QueryParamBuf GetParamTypes(concurrency::TransactionContext *txn, + const std::string &name); + + int64_t GetNumParams(concurrency::TransactionContext *txn, + const std::string &name); // TODO: In theory, we don't need database_oid // but now we store all the query metrics under default database "peloton" enum ColumnId { diff --git a/src/include/catalog/schema.h b/src/include/catalog/schema.h index 2f6875b453b..e70c7636d5d 100644 --- a/src/include/catalog/schema.h +++ b/src/include/catalog/schema.h @@ -92,16 +92,16 @@ class Schema : public Printable { //===--------------------------------------------------------------------===// inline size_t GetOffset(const oid_t column_id) const { - return columns[column_id].GetOffset(); + return columns_[column_id].GetOffset(); } inline type::TypeId GetType(const oid_t column_id) const { - return columns[column_id].GetType(); + return columns_[column_id].GetType(); } // Return appropriate length based on whether column is inlined inline size_t GetAppropriateLength(const oid_t column_id) const { - auto is_inlined = columns[column_id].IsInlined(); + auto is_inlined = columns_[column_id].IsInlined(); size_t column_length; if (is_inlined) { @@ -115,19 +115,19 @@ class Schema : public Printable { // Returns fixed length inline size_t GetLength(const oid_t column_id) const { - return columns[column_id].GetLength(); + return columns_[column_id].GetLength(); } inline size_t GetVariableLength(const oid_t column_id) const { - return columns[column_id].GetVariableLength(); + return columns_[column_id].GetVariableLength(); } inline bool IsInlined(const oid_t column_id) const { - return columns[column_id].IsInlined(); + return columns_[column_id].IsInlined(); } inline const Column &GetColumn(const oid_t column_id) const { - return columns[column_id]; + return columns_[column_id]; } /** @@ -138,8 +138,8 @@ class Schema : public Printable { */ inline oid_t GetColumnID(std::string col_name) const { oid_t index = INVALID_OID; - for (oid_t i = 0, cnt = columns.size(); i < cnt; ++i) { - if (columns[i].GetName() == col_name) { + for (oid_t i = 0, cnt = columns_.size(); i < cnt; ++i) { + if (columns_[i].GetName() == col_name) { index = i; break; } @@ -148,23 +148,23 @@ class Schema : public Printable { } inline oid_t GetUninlinedColumn(const oid_t column_id) const { - return uninlined_columns[column_id]; + return uninlined_columns_[column_id]; } - inline const std::vector &GetColumns() const { return columns; } + inline const std::vector &GetColumns() const { return columns_; } // Return the number of columns in the schema for the tuple. - inline size_t GetColumnCount() const { return column_count; } + inline size_t GetColumnCount() const { return column_count_; } inline oid_t GetUninlinedColumnCount() const { - return uninlined_column_count; + return uninlined_column_count_; } // Return the number of bytes used by one tuple. - inline oid_t GetLength() const { return length; } + inline oid_t GetLength() const { return length_; } // Returns a flag indicating whether all columns are inlined - inline bool IsInlined() const { return tuple_is_inlined; } + inline bool IsInlined() const { return tuple_is_inlined_; } inline void SetIndexedColumns(const std::vector &indexed_columns) { indexed_columns_ = indexed_columns; @@ -176,7 +176,7 @@ class Schema : public Printable { // Get the nullability of the column at a given index. inline bool AllowNull(const oid_t column_id) const { - for (auto constraint : columns[column_id].GetConstraints()) { + for (auto constraint : columns_[column_id].GetConstraints()) { if (constraint.GetType() == ConstraintType::NOTNULL) return false; } return true; @@ -184,7 +184,7 @@ class Schema : public Printable { // For single column default inline bool AllowDefault(const oid_t column_id) const { - for (auto constraint : columns[column_id].GetConstraints()) { + for (auto constraint : columns_[column_id].GetConstraints()) { if (constraint.GetType() == ConstraintType::DEFAULT) { return true; } @@ -194,8 +194,8 @@ class Schema : public Printable { } // Get the default value for the column - inline type::Value* GetDefaultValue(const oid_t column_id) const { - for (auto constraint : columns[column_id].GetConstraints()) { + inline type::Value *GetDefaultValue(const oid_t column_id) const { + for (auto constraint : columns_[column_id].GetConstraints()) { if (constraint.GetType() == ConstraintType::DEFAULT) { return constraint.getDefaultValue(); } @@ -207,25 +207,25 @@ class Schema : public Printable { // Add constraint for column by id inline void AddConstraint(oid_t column_id, const catalog::Constraint &constraint) { - columns[column_id].AddConstraint(constraint); + columns_[column_id].AddConstraint(constraint); } // Add constraint for column by name inline void AddConstraint(std::string column_name, const catalog::Constraint &constraint) { - for (size_t column_itr = 0; column_itr < columns.size(); column_itr++) { - if (columns[column_itr].GetName() == column_name) { - columns[column_itr].AddConstraint(constraint); + for (size_t column_itr = 0; column_itr < columns_.size(); column_itr++) { + if (columns_[column_itr].GetName() == column_name) { + columns_[column_itr].AddConstraint(constraint); } } } inline void AddMultiConstraints(const catalog::MultiConstraint &mc) { - multi_constraints.push_back(mc); + multi_constraints_.push_back(mc); } inline std::vector GetMultiConstraints() { - return multi_constraints; + return multi_constraints_; } // Get a string representation for debugging @@ -233,24 +233,24 @@ class Schema : public Printable { private: // size of fixed length columns - size_t length; + size_t length_; // all inlined and uninlined columns in the tuple - std::vector columns; + std::vector columns_; // keeps track of unlined columns - std::vector uninlined_columns; + std::vector uninlined_columns_; // keeps multi_constraints - std::vector multi_constraints; + std::vector multi_constraints_; // keep these in sync with the vectors above - oid_t column_count = INVALID_OID; + oid_t column_count_ = INVALID_OID; - oid_t uninlined_column_count = INVALID_OID; + oid_t uninlined_column_count_ = INVALID_OID; // are all columns inlined - bool tuple_is_inlined; + bool tuple_is_inlined_; // keeps track of indexed columns in original table std::vector indexed_columns_; diff --git a/src/include/catalog/schema_catalog.h b/src/include/catalog/schema_catalog.h index 38a3f3cbb96..357afd911e6 100644 --- a/src/include/catalog/schema_catalog.h +++ b/src/include/catalog/schema_catalog.h @@ -31,32 +31,34 @@ namespace peloton { namespace catalog { -class SchemaCatalogObject { - friend class DatabaseCatalogObject; +class SchemaCatalogEntry { + friend class DatabaseCatalogEntry; public: - SchemaCatalogObject(executor::LogicalTile *tile, - concurrency::TransactionContext *txn); + SchemaCatalogEntry(concurrency::TransactionContext *txn, + executor::LogicalTile *tile); - inline oid_t GetSchemaOid() { return schema_oid; } - inline const std::string &GetSchemaName() { return schema_name; } + inline oid_t GetSchemaOid() { return schema_oid_; } + + inline const std::string &GetSchemaName() { return schema_name_; } private: // member variables - oid_t schema_oid; - std::string schema_name; + oid_t schema_oid_; + std::string schema_name_; // Pointer to its corresponding transaction // This object is only visible during this transaction - concurrency::TransactionContext *txn; + concurrency::TransactionContext *txn_; }; class SchemaCatalog : public AbstractCatalog { - friend class SchemaCatalogObject; + friend class SchemaCatalogEntry; friend class Catalog; public: - SchemaCatalog(storage::Database *peloton, type::AbstractPool *pool, - concurrency::TransactionContext *txn); + SchemaCatalog(concurrency::TransactionContext *txn, + storage::Database *peloton, + type::AbstractPool *pool); ~SchemaCatalog(); @@ -67,17 +69,19 @@ class SchemaCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertSchema(oid_t schema_oid, const std::string &schema_name, - type::AbstractPool *pool, - concurrency::TransactionContext *txn); - bool DeleteSchema(const std::string &schema_name, - concurrency::TransactionContext *txn); + bool InsertSchema(concurrency::TransactionContext *txn, + oid_t schema_oid, + const std::string &schema_name, + type::AbstractPool *pool); + + bool DeleteSchema(concurrency::TransactionContext *txn, + const std::string &schema_name); //===--------------------------------------------------------------------===// // Read Related API //===--------------------------------------------------------------------===// - std::shared_ptr GetSchemaObject( - const std::string &schema_name, concurrency::TransactionContext *txn); + std::shared_ptr GetSchemaCatalogEntry(concurrency::TransactionContext *txn, + const std::string &schema_name); private: std::unique_ptr InitializeSchema(); @@ -87,7 +91,7 @@ class SchemaCatalog : public AbstractCatalog { SCHEMA_NAME = 1, // Add new columns here in creation order }; - std::vector all_column_ids = {0, 1}; + std::vector all_column_ids_ = {0, 1}; enum IndexId { PRIMARY_KEY = 0, diff --git a/src/include/catalog/settings_catalog.h b/src/include/catalog/settings_catalog.h index a3c8b1bf6df..3441658ef0a 100644 --- a/src/include/catalog/settings_catalog.h +++ b/src/include/catalog/settings_catalog.h @@ -27,23 +27,29 @@ class SettingsCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertSetting(const std::string &name, const std::string &value, - type::TypeId value_type, const std::string &description, - const std::string &min_value, const std::string &max_value, - const std::string &default_value, bool is_mutable, - bool is_persistent, type::AbstractPool *pool, - concurrency::TransactionContext *txn); + bool InsertSetting(concurrency::TransactionContext *txn, + const std::string &name, + const std::string &value, + type::TypeId value_type, + const std::string &description, + const std::string &min_value, + const std::string &max_value, + const std::string &default_value, + bool is_mutable, + bool is_persistent, + type::AbstractPool *pool); - bool DeleteSetting(const std::string &name, concurrency::TransactionContext *txn); + bool DeleteSetting(concurrency::TransactionContext *txn, + const std::string &name); //===--------------------------------------------------------------------===// // Read-only Related API //===--------------------------------------------------------------------===// - std::string GetSettingValue(const std::string &name, - concurrency::TransactionContext *txn); + std::string GetSettingValue(concurrency::TransactionContext *txn, + const std::string &name); - std::string GetDefaultValue(const std::string &name, - concurrency::TransactionContext *txn); + std::string GetDefaultValue(concurrency::TransactionContext *txn, + const std::string &name); enum class ColumnId { NAME = 0, diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h index 9792d180f9d..1d3e8c081dc 100644 --- a/src/include/catalog/system_catalogs.h +++ b/src/include/catalog/system_catalogs.h @@ -40,13 +40,14 @@ class SystemCatalogs { public: SystemCatalogs() = delete; - SystemCatalogs(storage::Database *database, type::AbstractPool *pool, - concurrency::TransactionContext *txn); + SystemCatalogs(concurrency::TransactionContext *txn, + storage::Database *database, + type::AbstractPool *pool); ~SystemCatalogs(); - void Bootstrap(const std::string &database_name, - concurrency::TransactionContext *txn); + void Bootstrap(concurrency::TransactionContext *txn, + const std::string &database_name); //===--------------------------------------------------------------------===// // GET FUNCTIONS diff --git a/src/include/catalog/table_catalog.h b/src/include/catalog/table_catalog.h index c4698f90a1c..e22af23b262 100644 --- a/src/include/catalog/table_catalog.h +++ b/src/include/catalog/table_catalog.h @@ -43,40 +43,47 @@ class Layout; namespace catalog { -class IndexCatalogObject; -class ColumnCatalogObject; +class IndexCatalogEntry; +class ColumnCatalogEntry; -class TableCatalogObject { +class TableCatalogEntry { friend class TableCatalog; friend class IndexCatalog; friend class ColumnCatalog; friend class LayoutCatalog; public: - TableCatalogObject(executor::LogicalTile *tile, - concurrency::TransactionContext *txn, int tupleId = 0); + TableCatalogEntry(concurrency::TransactionContext *txn, + executor::LogicalTile *tile, + int tupleId = 0); public: // Get indexes - void EvictAllIndexObjects(); - std::unordered_map> - GetIndexObjects(bool cached_only = false); - std::unordered_map> - GetIndexNames(bool cached_only = false); - std::shared_ptr GetIndexObject(oid_t index_oid, - bool cached_only = false); - std::shared_ptr GetIndexObject( + void EvictAllIndexCatalogEntries(); + + std::unordered_map> + GetIndexCatalogEntries(bool cached_only = false); + + + std::shared_ptr GetIndexCatalogEntries(oid_t index_oid, + bool cached_only = false); + + std::shared_ptr GetIndexCatalogEntry( const std::string &index_name, bool cached_only = false); // Get columns - void EvictAllColumnObjects(); - std::unordered_map> - GetColumnObjects(bool cached_only = false); - std::unordered_map> - GetColumnNames(bool cached_only = false); - std::shared_ptr GetColumnObject( + void EvictAllColumnCatalogEntries(); + + std::unordered_map> + GetColumnCatalogEntries(bool cached_only = false); + + std::unordered_map> + GetColumnCatalogEntriesByName(bool cached_only = false); + + std::shared_ptr GetColumnCatalogEntry( oid_t column_id, bool cached_only = false); - std::shared_ptr GetColumnObject( + + std::shared_ptr GetColumnCatalogEntry( const std::string &column_name, bool cached_only = false); // Evict all layouts from the cache @@ -105,14 +112,14 @@ class TableCatalogObject { oid_t default_layout_oid; // Get index objects - bool InsertIndexObject(std::shared_ptr index_object); - bool EvictIndexObject(oid_t index_oid); - bool EvictIndexObject(const std::string &index_name); + bool InsertIndexCatalogEntry(std::shared_ptr index_catalog_entry); + bool EvictIndexCatalogEntry(oid_t index_oid); + bool EvictIndexCatalogEntry(const std::string &index_name); // Get column objects - bool InsertColumnObject(std::shared_ptr column_object); - bool EvictColumnObject(oid_t column_id); - bool EvictColumnObject(const std::string &column_name); + bool InsertColumnCatalogEntry(std::shared_ptr column_catalog_entry); + bool EvictColumnCatalogEntry(oid_t column_id); + bool EvictColumnCatalogEntry(const std::string &column_name); // Insert layout into table object bool InsertLayout(std::shared_ptr layout); @@ -120,38 +127,39 @@ class TableCatalogObject { bool EvictLayout(oid_t layout_id); // cache for *all* index catalog objects in this table - std::unordered_map> index_objects; - std::unordered_map> - index_names; - bool valid_index_objects; + std::unordered_map> index_catalog_entries; + std::unordered_map> + index_catalog_entries_by_name_; + bool valid_index_catalog_entries_; // cache for *all* column catalog objects in this table - std::unordered_map> - column_objects; - std::unordered_map> - column_names; - bool valid_column_objects; + std::unordered_map> + column_catalog_entries_; + std::unordered_map> + column_names_; + bool valid_column_catalog_entries_; // cache for *all* layout objects in the table std::unordered_map> - layout_objects_; - bool valid_layout_objects_; + layout_catalog_entries_; + bool valid_layout_catalog_entries_; // Pointer to its corresponding transaction - concurrency::TransactionContext *txn; + concurrency::TransactionContext *txn_; }; class TableCatalog : public AbstractCatalog { - friend class TableCatalogObject; - friend class DatabaseCatalogObject; + friend class TableCatalogEntry; + friend class DatabaseCatalogEntry; friend class ColumnCatalog; friend class IndexCatalog; friend class LayoutCatalog; friend class Catalog; public: - TableCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, - concurrency::TransactionContext *txn); + TableCatalog(concurrency::TransactionContext *txn, + storage::Database *pg_catalog, + type::AbstractPool *pool); ~TableCatalog(); @@ -162,29 +170,37 @@ class TableCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertTable(oid_t table_oid, const std::string &table_name, - const std::string &schema_name, oid_t database_oid, - oid_t layout_oid, type::AbstractPool *pool, - concurrency::TransactionContext *txn); - bool DeleteTable(oid_t table_oid, concurrency::TransactionContext *txn); + bool InsertTable(concurrency::TransactionContext *txn, + oid_t database_oid, + const std::string &schema_name, + oid_t table_oid, + const std::string &table_name, + oid_t layout_oid, + type::AbstractPool *pool); + + bool DeleteTable(concurrency::TransactionContext *txn, oid_t table_oid); - bool UpdateVersionId(oid_t update_val, oid_t table_oid, - concurrency::TransactionContext *txn); + bool UpdateVersionId(concurrency::TransactionContext *txn, + oid_t table_oid, + oid_t update_val); - bool UpdateDefaultLayoutOid(oid_t update_val, oid_t table_oid, - concurrency::TransactionContext *txn); + bool UpdateDefaultLayoutOid(concurrency::TransactionContext *txn, + oid_t table_oid, + oid_t update_val); //===--------------------------------------------------------------------===// // Read Related API //===--------------------------------------------------------------------===// private: - std::shared_ptr GetTableObject( - oid_t table_oid, concurrency::TransactionContext *txn); - std::shared_ptr GetTableObject( - const std::string &table_name, const std::string &schema_name, - concurrency::TransactionContext *txn); - std::unordered_map> - GetTableObjects(concurrency::TransactionContext *txn); + std::shared_ptr GetTableCatalogEntry(concurrency::TransactionContext *txn, + oid_t table_oid); + + std::shared_ptr GetTableCatalogEntry(concurrency::TransactionContext *txn, + const std::string &schema_name, + const std::string &table_name); + + std::unordered_map> + GetTableCatalogEntries(concurrency::TransactionContext *txn); std::unique_ptr InitializeSchema(); @@ -197,7 +213,7 @@ class TableCatalog : public AbstractCatalog { DEFAULT_LAYOUT_OID = 5, // Add new columns here in creation order }; - std::vector all_column_ids = {0, 1, 2, 3, 4, 5}; + std::vector all_column_ids_ = {0, 1, 2, 3, 4, 5}; enum IndexId { PRIMARY_KEY = 0, diff --git a/src/include/catalog/table_metrics_catalog.h b/src/include/catalog/table_metrics_catalog.h index 38c59a76857..ba2e8d1c5b1 100644 --- a/src/include/catalog/table_metrics_catalog.h +++ b/src/include/catalog/table_metrics_catalog.h @@ -38,19 +38,23 @@ namespace catalog { class TableMetricsCatalog : public AbstractCatalog { public: - TableMetricsCatalog(const std::string &database_name, - concurrency::TransactionContext *txn); + TableMetricsCatalog(concurrency::TransactionContext *txn, + const std::string &database_name); ~TableMetricsCatalog(); //===--------------------------------------------------------------------===// // Write Related API //===--------------------------------------------------------------------===// - bool InsertTableMetrics(oid_t table_oid, int64_t reads, int64_t updates, - int64_t deletes, int64_t inserts, int64_t time_stamp, - type::AbstractPool *pool, - concurrency::TransactionContext *txn); - bool DeleteTableMetrics(oid_t table_oid, - concurrency::TransactionContext *txn); + bool InsertTableMetrics(concurrency::TransactionContext *txn, + oid_t table_oid, + int64_t reads, + int64_t updates, + int64_t deletes, + int64_t inserts, + int64_t time_stamp, + type::AbstractPool *pool); + + bool DeleteTableMetrics(concurrency::TransactionContext *txn, oid_t table_oid); //===--------------------------------------------------------------------===// // Read-only Related API diff --git a/src/include/catalog/trigger_catalog.h b/src/include/catalog/trigger_catalog.h index 18b2a774868..83088727aa8 100644 --- a/src/include/catalog/trigger_catalog.h +++ b/src/include/catalog/trigger_catalog.h @@ -47,8 +47,8 @@ namespace catalog { class TriggerCatalog : public AbstractCatalog { public: - TriggerCatalog(const std::string &database_name, - concurrency::TransactionContext *txn); + TriggerCatalog(concurrency::TransactionContext *txn, + const std::string &database_name); ~TriggerCatalog(); oid_t GetNextOid() { return oid_++ | TRIGGER_OID_MASK; } @@ -58,35 +58,42 @@ class TriggerCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertTrigger(oid_t table_oid, std::string trigger_name, - int16_t trigger_type, std::string proc_oid, - std::string function_arguments, type::Value fire_condition, - type::Value timestamp, type::AbstractPool *pool, - concurrency::TransactionContext *txn); - - ResultType DropTrigger(const oid_t database_oid, const oid_t table_oid, - const std::string &trigger_name, - concurrency::TransactionContext *txn); - - bool DeleteTriggerByName(const std::string &trigger_name, oid_t table_oid, - concurrency::TransactionContext *txn); + bool InsertTrigger(concurrency::TransactionContext *txn, + oid_t table_oid, + std::string trigger_name, + int16_t trigger_type, + std::string proc_oid, + std::string function_arguments, + type::Value fire_condition, + type::Value timestamp, + type::AbstractPool *pool); + + ResultType DropTrigger(concurrency::TransactionContext *txn, + const oid_t database_oid, + const oid_t table_oid, + const std::string &trigger_name); + + bool DeleteTriggerByName(concurrency::TransactionContext *txn, + oid_t table_oid, + const std::string &trigger_name); //===--------------------------------------------------------------------===// // get triggers for a specific table; one table may have multiple triggers // of the same type //===--------------------------------------------------------------------===// - std::unique_ptr GetTriggersByType( - oid_t table_oid, int16_t trigger_type, - concurrency::TransactionContext *txn); + std::unique_ptr GetTriggersByType(concurrency::TransactionContext *txn, + oid_t table_oid, + int16_t trigger_type); //===--------------------------------------------------------------------===// // get all types of triggers for a specific table //===--------------------------------------------------------------------===// - std::unique_ptr GetTriggers( - oid_t table_oid, concurrency::TransactionContext *txn); + std::unique_ptr GetTriggers(concurrency::TransactionContext *txn, + oid_t table_oid); - oid_t GetTriggerOid(std::string trigger_name, oid_t table_oid, - concurrency::TransactionContext *txn); + oid_t GetTriggerOid(concurrency::TransactionContext *txn, + oid_t table_oid, + std::string trigger_name); enum ColumnId { TRIGGER_OID = 0, diff --git a/src/include/catalog/zone_map_catalog.h b/src/include/catalog/zone_map_catalog.h index a38d26d0597..9933652b1b8 100644 --- a/src/include/catalog/zone_map_catalog.h +++ b/src/include/catalog/zone_map_catalog.h @@ -36,23 +36,31 @@ class ZoneMapCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertColumnStatistics(oid_t database_id, oid_t table_id, - oid_t tile_group_id, oid_t column_id, - std::string minimum, std::string maximum, - std::string type, type::AbstractPool *pool, - concurrency::TransactionContext *txn); - - bool DeleteColumnStatistics(oid_t database_id, oid_t table_id, - oid_t tile_group_id, oid_t column_id, - concurrency::TransactionContext *txn); + bool InsertColumnStatistics(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + oid_t tile_group_id, + oid_t column_id, + std::string minimum, + std::string maximum, + std::string type, + type::AbstractPool *pool); + + bool DeleteColumnStatistics(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + oid_t tile_group_id, + oid_t column_id); //===--------------------------------------------------------------------===// // Read-only Related API //===--------------------------------------------------------------------===// - std::unique_ptr> GetColumnStatistics( - oid_t database_id, oid_t table_id, oid_t tile_group_id, oid_t column_id, - concurrency::TransactionContext *txn); + std::unique_ptr> GetColumnStatistics(concurrency::TransactionContext *txn, + oid_t database_id, + oid_t table_id, + oid_t tile_group_id, + oid_t column_id); enum class ColumnId { DATABASE_ID = 0, @@ -64,10 +72,10 @@ class ZoneMapCatalog : public AbstractCatalog { TYPE = 6 }; - enum class ZoneMapOffset { - MINIMUM_OFF = 0, - MAXIMUM_OFF = 1, - TYPE_OFF = 2 + enum class ZoneMapOffset { + MINIMUM_OFF = 0, + MAXIMUM_OFF = 1, + TYPE_OFF = 2 }; private: diff --git a/src/include/optimizer/operators.h b/src/include/optimizer/operators.h index fb5242ba8e3..c8a8483d242 100644 --- a/src/include/optimizer/operators.h +++ b/src/include/optimizer/operators.h @@ -30,7 +30,7 @@ class UpdateClause; } namespace catalog { -class TableCatalogObject; +class TableCatalogEntry; } namespace optimizer { @@ -52,7 +52,7 @@ class LogicalGet : public OperatorNode { public: static Operator make( oid_t get_id = 0, std::vector predicates = {}, - std::shared_ptr table = nullptr, + std::shared_ptr table = nullptr, std::string alias = "", bool update = false); bool operator==(const BaseOperatorNode &r) override; @@ -62,7 +62,7 @@ class LogicalGet : public OperatorNode { // identifier for all get operators oid_t get_id; std::vector predicates; - std::shared_ptr table; + std::shared_ptr table; std::string table_alias; bool is_for_update; }; @@ -267,12 +267,12 @@ class LogicalAggregateAndGroupBy class LogicalInsert : public OperatorNode { public: static Operator make( - std::shared_ptr target_table, + std::shared_ptr target_table, const std::vector *columns, const std::vector>> *values); - std::shared_ptr target_table; + std::shared_ptr target_table; const std::vector *columns; const std::vector< std::vector>> *values; @@ -281,9 +281,9 @@ class LogicalInsert : public OperatorNode { class LogicalInsertSelect : public OperatorNode { public: static Operator make( - std::shared_ptr target_table); + std::shared_ptr target_table); - std::shared_ptr target_table; + std::shared_ptr target_table; }; //===--------------------------------------------------------------------===// @@ -319,9 +319,9 @@ class LogicalLimit : public OperatorNode { class LogicalDelete : public OperatorNode { public: static Operator make( - std::shared_ptr target_table); + std::shared_ptr target_table); - std::shared_ptr target_table; + std::shared_ptr target_table; }; //===--------------------------------------------------------------------===// @@ -330,10 +330,10 @@ class LogicalDelete : public OperatorNode { class LogicalUpdate : public OperatorNode { public: static Operator make( - std::shared_ptr target_table, + std::shared_ptr target_table, const std::vector> *updates); - std::shared_ptr target_table; + std::shared_ptr target_table; const std::vector> *updates; }; @@ -371,7 +371,7 @@ class DummyScan : public OperatorNode { class PhysicalSeqScan : public OperatorNode { public: static Operator make(oid_t get_id, - std::shared_ptr table, + std::shared_ptr table, std::string alias, std::vector predicates, bool update); @@ -385,7 +385,7 @@ class PhysicalSeqScan : public OperatorNode { std::vector predicates; std::string table_alias; bool is_for_update; - std::shared_ptr table_; + std::shared_ptr table_; }; //===--------------------------------------------------------------------===// @@ -394,7 +394,7 @@ class PhysicalSeqScan : public OperatorNode { class PhysicalIndexScan : public OperatorNode { public: static Operator make(oid_t get_id, - std::shared_ptr table, + std::shared_ptr table, std::string alias, std::vector predicates, bool update, oid_t index_id, std::vector key_column_id_list, @@ -410,7 +410,7 @@ class PhysicalIndexScan : public OperatorNode { std::vector predicates; std::string table_alias; bool is_for_update; - std::shared_ptr table_; + std::shared_ptr table_; // Index info. // Match planner::IndexScanPlan::IndexScanDesc index_scan_desc( @@ -599,12 +599,12 @@ class PhysicalOuterHashJoin : public OperatorNode { class PhysicalInsert : public OperatorNode { public: static Operator make( - std::shared_ptr target_table, + std::shared_ptr target_table, const std::vector *columns, const std::vector>> *values); - std::shared_ptr target_table; + std::shared_ptr target_table; const std::vector *columns; const std::vector< std::vector>> *values; @@ -613,9 +613,9 @@ class PhysicalInsert : public OperatorNode { class PhysicalInsertSelect : public OperatorNode { public: static Operator make( - std::shared_ptr target_table); + std::shared_ptr target_table); - std::shared_ptr target_table; + std::shared_ptr target_table; }; //===--------------------------------------------------------------------===// @@ -624,8 +624,8 @@ class PhysicalInsertSelect : public OperatorNode { class PhysicalDelete : public OperatorNode { public: static Operator make( - std::shared_ptr target_table); - std::shared_ptr target_table; + std::shared_ptr target_table); + std::shared_ptr target_table; }; //===--------------------------------------------------------------------===// @@ -634,10 +634,10 @@ class PhysicalDelete : public OperatorNode { class PhysicalUpdate : public OperatorNode { public: static Operator make( - std::shared_ptr target_table, + std::shared_ptr target_table, const std::vector> *updates); - std::shared_ptr target_table; + std::shared_ptr target_table; const std::vector> *updates; }; diff --git a/src/include/optimizer/plan_generator.h b/src/include/optimizer/plan_generator.h index 9fba272d4a8..6c020a38783 100644 --- a/src/include/optimizer/plan_generator.h +++ b/src/include/optimizer/plan_generator.h @@ -109,7 +109,7 @@ class PlanGenerator : public OperatorVisitor { */ std::vector> GenerateTableTVExprs(const std::string &alias, - std::shared_ptr table); + std::shared_ptr table); /** * @brief Generate the column oids vector for a scan plan @@ -131,7 +131,7 @@ class PlanGenerator : public OperatorVisitor { std::unique_ptr GeneratePredicateForScan( const std::shared_ptr predicate_expr, const std::string &alias, - std::shared_ptr table); + std::shared_ptr table); /** * @brief Generate projection info and projection schema for join diff --git a/src/main/tpch/tpch_database.cpp b/src/main/tpch/tpch_database.cpp index 4c93c91c4dd..5252104cc88 100644 --- a/src/main/tpch/tpch_database.cpp +++ b/src/main/tpch/tpch_database.cpp @@ -104,7 +104,7 @@ TPCHDatabase::TPCHDatabase(const Configuration &c) : config_(c) { TPCHDatabase::~TPCHDatabase() { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto *txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithOid(kTPCHDatabaseId, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithOid(txn, kTPCHDatabaseId); txn_manager.CommitTransaction(txn); } diff --git a/src/optimizer/child_property_deriver.cpp b/src/optimizer/child_property_deriver.cpp index 62b0c95288d..b432067fae1 100644 --- a/src/optimizer/child_property_deriver.cpp +++ b/src/optimizer/child_property_deriver.cpp @@ -50,7 +50,7 @@ void ChildPropertyDeriver::Visit(const PhysicalSeqScan *) { void ChildPropertyDeriver::Visit(const PhysicalIndexScan *op) { auto provided_prop = make_shared(); - std::shared_ptr target_table = op->table_; + std::shared_ptr target_table = op->table_; for (auto prop : requirements_->Properties()) { if (prop->Type() == PropertyType::SORT) { // Walk through all indices in the table, check if any of the index could @@ -69,7 +69,7 @@ void ChildPropertyDeriver::Visit(const PhysicalIndexScan *op) { } } if (!can_fulfill) break; - for (auto &index : target_table->GetIndexObjects()) { + for (auto &index : target_table->GetIndexCatalogEntries()) { auto key_oids = index.second->GetKeyAttrs(); // If the sort column size is larger, then can't be fulfill by the index if (sort_col_size > key_oids.size()) { diff --git a/src/optimizer/operators.cpp b/src/optimizer/operators.cpp index c669125c191..52cf83f9a8c 100644 --- a/src/optimizer/operators.cpp +++ b/src/optimizer/operators.cpp @@ -32,7 +32,7 @@ Operator LeafOperator::make(GroupID group) { //===--------------------------------------------------------------------===// Operator LogicalGet::make(oid_t get_id, std::vector predicates, - std::shared_ptr table, + std::shared_ptr table, std::string alias, bool update) { LogicalGet *get = new LogicalGet; get->table = table; @@ -391,7 +391,7 @@ hash_t LogicalAggregateAndGroupBy::Hash() const { // Insert //===--------------------------------------------------------------------===// Operator LogicalInsert::make( - std::shared_ptr target_table, + std::shared_ptr target_table, const std::vector *columns, const std::vector>> *values) { @@ -403,7 +403,7 @@ Operator LogicalInsert::make( } Operator LogicalInsertSelect::make( - std::shared_ptr target_table) { + std::shared_ptr target_table) { LogicalInsertSelect *insert_op = new LogicalInsertSelect; insert_op->target_table = target_table; return Operator(insert_op); @@ -413,7 +413,7 @@ Operator LogicalInsertSelect::make( // Delete //===--------------------------------------------------------------------===// Operator LogicalDelete::make( - std::shared_ptr target_table) { + std::shared_ptr target_table) { LogicalDelete *delete_op = new LogicalDelete; delete_op->target_table = target_table; return Operator(delete_op); @@ -423,7 +423,7 @@ Operator LogicalDelete::make( // Update //===--------------------------------------------------------------------===// Operator LogicalUpdate::make( - std::shared_ptr target_table, + std::shared_ptr target_table, const std::vector> * updates) { LogicalUpdate *update_op = new LogicalUpdate; @@ -502,7 +502,7 @@ Operator DummyScan::make() { // SeqScan //===--------------------------------------------------------------------===// Operator PhysicalSeqScan::make( - oid_t get_id, std::shared_ptr table, + oid_t get_id, std::shared_ptr table, std::string alias, std::vector predicates, bool update) { PELOTON_ASSERT(table != nullptr); @@ -539,7 +539,7 @@ hash_t PhysicalSeqScan::Hash() const { // IndexScan //===--------------------------------------------------------------------===// Operator PhysicalIndexScan::make( - oid_t get_id, std::shared_ptr table, + oid_t get_id, std::shared_ptr table, std::string alias, std::vector predicates, bool update, oid_t index_id, std::vector key_column_id_list, std::vector expr_type_list, @@ -832,7 +832,7 @@ Operator PhysicalOuterHashJoin::make( // PhysicalInsert //===--------------------------------------------------------------------===// Operator PhysicalInsert::make( - std::shared_ptr target_table, + std::shared_ptr target_table, const std::vector *columns, const std::vector>> *values) { @@ -847,7 +847,7 @@ Operator PhysicalInsert::make( // PhysicalInsertSelect //===--------------------------------------------------------------------===// Operator PhysicalInsertSelect::make( - std::shared_ptr target_table) { + std::shared_ptr target_table) { PhysicalInsertSelect *insert_op = new PhysicalInsertSelect; insert_op->target_table = target_table; return Operator(insert_op); @@ -857,7 +857,7 @@ Operator PhysicalInsertSelect::make( // PhysicalDelete //===--------------------------------------------------------------------===// Operator PhysicalDelete::make( - std::shared_ptr target_table) { + std::shared_ptr target_table) { PhysicalDelete *delete_op = new PhysicalDelete; delete_op->target_table = target_table; return Operator(delete_op); @@ -867,7 +867,7 @@ Operator PhysicalDelete::make( // PhysicalUpdate //===--------------------------------------------------------------------===// Operator PhysicalUpdate::make( - std::shared_ptr target_table, + std::shared_ptr target_table, const std::vector> * updates) { PhysicalUpdate *update = new PhysicalUpdate; diff --git a/src/optimizer/optimizer.cpp b/src/optimizer/optimizer.cpp index 2525915fcc1..9087f826dae 100644 --- a/src/optimizer/optimizer.cpp +++ b/src/optimizer/optimizer.cpp @@ -165,15 +165,19 @@ unique_ptr Optimizer::HandleDDLStatement( if (create_plan->GetCreateType() == peloton::CreateType::INDEX) { auto create_stmt = (parser::CreateStatement *)tree; auto target_table = catalog::Catalog::GetInstance()->GetTableWithName( - create_stmt->GetDatabaseName(), create_stmt->GetSchemaName(), - create_stmt->GetTableName(), txn); + txn, + create_stmt->GetDatabaseName(), + create_stmt->GetSchemaName(), + create_stmt->GetTableName()); std::vector column_ids; // use catalog object instead of schema to acquire metadata - auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - create_stmt->GetDatabaseName(), create_stmt->GetSchemaName(), - create_stmt->GetTableName(), txn); + auto table_object = + catalog::Catalog::GetInstance()->GetTableCatalogEntry(txn, + create_stmt->GetDatabaseName(), + create_stmt->GetSchemaName(), + create_stmt->GetTableName()); for (auto column_name : create_plan->GetIndexAttributes()) { - auto column_object = table_object->GetColumnObject(column_name); + auto column_object = table_object->GetColumnCatalogEntry(column_name); // Check if column is missing if (column_object == nullptr) throw CatalogException( diff --git a/src/optimizer/plan_generator.cpp b/src/optimizer/plan_generator.cpp index c73cd4721bc..fd1824360e3 100644 --- a/src/optimizer/plan_generator.cpp +++ b/src/optimizer/plan_generator.cpp @@ -383,7 +383,7 @@ void PlanGenerator::Visit(const PhysicalUpdate *op) { // Evaluate update expression and add to target list for (auto &update : *(op->updates)) { auto column_name = update->column; - auto col_id = op->target_table->GetColumnObject(column_name)->GetColumnId(); + auto col_id = op->target_table->GetColumnCatalogEntry(column_name)->GetColumnId(); if (update_col_ids.find(col_id) != update_col_ids.end()) throw SyntaxException("Multiple assignments to same column " + column_name); @@ -395,7 +395,7 @@ void PlanGenerator::Visit(const PhysicalUpdate *op) { } // Add other columns to direct map - for (auto &column_id_obj_pair : op->target_table->GetColumnObjects()) { + for (auto &column_id_obj_pair : op->target_table->GetColumnCatalogEntries()) { auto &col_id = column_id_obj_pair.first; if (update_col_ids.find(col_id) == update_col_ids.end()) dml.emplace_back(col_id, std::pair(0, col_id)); @@ -423,12 +423,12 @@ void PlanGenerator::Visit(const PhysicalExportExternalFile *op) { /************************* Private Functions *******************************/ vector> PlanGenerator::GenerateTableTVExprs( - const std::string &alias, shared_ptr table) { + const std::string &alias, shared_ptr table) { // TODO(boweic): we seems to provide all columns here, in case where there are // a lot of attributes and we're only visiting a few this is not efficient oid_t db_id = table->GetDatabaseOid(); oid_t table_id = table->GetTableOid(); - auto column_objects = table->GetColumnObjects(); + auto column_objects = table->GetColumnCatalogEntries(); vector> exprs( column_objects.size()); for (auto &column_id_object_pair : column_objects) { @@ -466,7 +466,7 @@ vector PlanGenerator::GenerateColumnsForScan() { std::unique_ptr PlanGenerator::GeneratePredicateForScan( const std::shared_ptr predicate_expr, - const std::string &alias, shared_ptr table) { + const std::string &alias, shared_ptr table) { if (predicate_expr == nullptr) { return nullptr; } diff --git a/src/optimizer/query_to_operator_transformer.cpp b/src/optimizer/query_to_operator_transformer.cpp index 97f1365b4c4..c539826ae53 100644 --- a/src/optimizer/query_to_operator_transformer.cpp +++ b/src/optimizer/query_to_operator_transformer.cpp @@ -223,10 +223,11 @@ void QueryToOperatorTransformer::Visit(parser::TableRef *node) { // Single table else { if (node->list.size() == 1) node = node->list.at(0).get(); - std::shared_ptr target_table = - catalog::Catalog::GetInstance()->GetTableObject( - node->GetDatabaseName(), node->GetSchemaName(), - node->GetTableName(), txn_); + std::shared_ptr target_table = + catalog::Catalog::GetInstance()->GetTableCatalogEntry(txn_, + node->GetDatabaseName(), + node->GetSchemaName(), + node->GetTableName()); std::string table_alias = StringUtil::Lower(std::string(node->GetTableAlias())); output_expr_ = std::make_shared(LogicalGet::make( @@ -242,9 +243,11 @@ void QueryToOperatorTransformer::Visit(parser::CreateFunctionStatement *) {} void QueryToOperatorTransformer::Visit( UNUSED_ATTRIBUTE parser::CreateStatement *op) {} void QueryToOperatorTransformer::Visit(parser::InsertStatement *op) { - std::shared_ptr target_table = - catalog::Catalog::GetInstance()->GetTableObject( - op->GetDatabaseName(), op->GetSchemaName(), op->GetTableName(), txn_); + std::shared_ptr target_table = + catalog::Catalog::GetInstance()->GetTableCatalogEntry(txn_, + op->GetDatabaseName(), + op->GetSchemaName(), + op->GetTableName()); if (op->type == InsertType::SELECT) { auto insert_expr = std::make_shared( @@ -256,7 +259,7 @@ void QueryToOperatorTransformer::Visit(parser::InsertStatement *op) { } // column_objects represents the columns for the current table as defined in // its schema - auto column_objects = target_table->GetColumnObjects(); + auto column_objects = target_table->GetColumnCatalogEntries(); // INSERT INTO table_name VALUES (val1, val2, ...), (val_a, val_b, ...), ... if (op->columns.empty()) { for (const auto &values : op->insert_values) { @@ -292,7 +295,7 @@ void QueryToOperatorTransformer::Visit(parser::InsertStatement *op) { // set below contains names of columns mentioned in the insert statement std::unordered_set specified; - auto column_names = target_table->GetColumnNames(); + auto column_names = target_table->GetColumnCatalogEntriesByName(); for (const auto col : op->columns) { if (column_names.find(col) == column_names.end()) { @@ -320,8 +323,11 @@ void QueryToOperatorTransformer::Visit(parser::InsertStatement *op) { } void QueryToOperatorTransformer::Visit(parser::DeleteStatement *op) { - auto target_table = catalog::Catalog::GetInstance()->GetTableObject( - op->GetDatabaseName(), op->GetSchemaName(), op->GetTableName(), txn_); + auto target_table = + catalog::Catalog::GetInstance()->GetTableCatalogEntry(txn_, + op->GetDatabaseName(), + op->GetSchemaName(), + op->GetTableName()); std::shared_ptr table_scan; if (op->expr != nullptr) { std::vector predicates = @@ -346,9 +352,11 @@ void QueryToOperatorTransformer::Visit( void QueryToOperatorTransformer::Visit( UNUSED_ATTRIBUTE parser::TransactionStatement *op) {} void QueryToOperatorTransformer::Visit(parser::UpdateStatement *op) { - auto target_table = catalog::Catalog::GetInstance()->GetTableObject( - op->table->GetDatabaseName(), op->table->GetSchemaName(), - op->table->GetTableName(), txn_); + auto target_table = + catalog::Catalog::GetInstance()->GetTableCatalogEntry(txn_, + op->table->GetDatabaseName(), + op->table->GetSchemaName(), + op->table->GetTableName()); std::shared_ptr table_scan; auto update_expr = std::make_shared( @@ -382,9 +390,9 @@ void QueryToOperatorTransformer::Visit(parser::CopyStatement *op) { auto target_table = catalog::Catalog::GetInstance() - ->GetDatabaseObject(op->table->GetDatabaseName(), txn_) - ->GetTableObject(op->table->GetTableName(), - op->table->GetSchemaName()); + ->GetDatabaseCatalogEntry(txn_, op->table->GetDatabaseName()) + ->GetTableCatalogEntry(op->table->GetTableName(), + op->table->GetSchemaName()); auto insert_expr = std::make_shared( LogicalInsertSelect::make(target_table)); diff --git a/src/optimizer/rule_impls.cpp b/src/optimizer/rule_impls.cpp index 6d5a1a1ebce..8574e00f337 100644 --- a/src/optimizer/rule_impls.cpp +++ b/src/optimizer/rule_impls.cpp @@ -246,7 +246,7 @@ bool GetToIndexScan::Check(std::shared_ptr plan, const LogicalGet *get = plan->Op().As(); bool index_exist = false; if (get != nullptr && get->table != nullptr && - !get->table->GetIndexObjects().empty()) { + !get->table->GetIndexCatalogEntries().empty()) { index_exist = true; } return index_exist; @@ -281,7 +281,7 @@ void GetToIndexScan::Transform( } // Check whether any index can fulfill sort property if (sort_by_asc_base_column) { - for (auto &index_id_object_pair : get->table->GetIndexObjects()) { + for (auto &index_id_object_pair : get->table->GetIndexCatalogEntries()) { auto &index_id = index_id_object_pair.first; auto &index = index_id_object_pair.second; auto &index_col_ids = index->GetKeyAttrs(); @@ -350,7 +350,7 @@ void GetToIndexScan::Transform( auto column_ref = (expression::TupleValueExpression *)tv_expr; std::string col_name(column_ref->GetColumnName()); LOG_TRACE("Column name: %s", col_name.c_str()); - auto column_id = get->table->GetColumnObject(col_name)->GetColumnId(); + auto column_id = get->table->GetColumnCatalogEntry(col_name)->GetColumnId(); key_column_id_list.push_back(column_id); expr_type_list.push_back(expr_type); @@ -374,7 +374,7 @@ void GetToIndexScan::Transform( } // Loop predicates end // Find match index for the predicates - auto index_objects = get->table->GetIndexObjects(); + auto index_objects = get->table->GetIndexCatalogEntries(); for (auto &index_id_object_pair : index_objects) { auto &index_id = index_id_object_pair.first; auto &index_object = index_id_object_pair.second; diff --git a/src/optimizer/stats/stats_storage.cpp b/src/optimizer/stats/stats_storage.cpp index d1b2fed6b12..4231e95ee9e 100644 --- a/src/optimizer/stats/stats_storage.cpp +++ b/src/optimizer/stats/stats_storage.cpp @@ -117,12 +117,20 @@ void StatsStorage::InsertOrUpdateColumnStats( single_statement_txn = true; txn = txn_manager.BeginTransaction(); } - column_stats_catalog->DeleteColumnStats(database_id, table_id, column_id, - txn); - column_stats_catalog->InsertColumnStats( - database_id, table_id, column_id, num_rows, cardinality, frac_null, - most_common_vals, most_common_freqs, histogram_bounds, column_name, - has_index, pool_.get(), txn); + column_stats_catalog->DeleteColumnStats(txn, database_id, table_id, column_id); + column_stats_catalog->InsertColumnStats(txn, + database_id, + table_id, + column_id, + column_name, + num_rows, + frac_null, + most_common_vals, + most_common_freqs, + histogram_bounds, + cardinality, + has_index, + pool_.get()); if (single_statement_txn) { txn_manager.CommitTransaction(txn); @@ -140,8 +148,10 @@ std::shared_ptr StatsStorage::GetColumnStatsByID(oid_t database_id, auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); // std::unique_ptr> column_stats_vector - auto column_stats_vector = column_stats_catalog->GetColumnStats( - database_id, table_id, column_id, txn); + auto column_stats_vector = column_stats_catalog->GetColumnStats(txn, + database_id, + table_id, + column_id); txn_manager.CommitTransaction(txn); return ConvertVectorToColumnStats(database_id, table_id, column_id, @@ -220,7 +230,9 @@ std::shared_ptr StatsStorage::GetTableStats( oid_t database_id, oid_t table_id, concurrency::TransactionContext *txn) { auto column_stats_catalog = catalog::ColumnStatsCatalog::GetInstance(nullptr); std::map>> column_stats_map; - column_stats_catalog->GetTableStats(database_id, table_id, txn, + column_stats_catalog->GetTableStats(txn, + database_id, + table_id, column_stats_map); std::vector> column_stats_ptrs; @@ -244,7 +256,9 @@ std::shared_ptr StatsStorage::GetTableStats( concurrency::TransactionContext *txn) { auto column_stats_catalog = catalog::ColumnStatsCatalog::GetInstance(nullptr); std::map>> column_stats_map; - column_stats_catalog->GetTableStats(database_id, table_id, txn, + column_stats_catalog->GetTableStats(txn, + database_id, + table_id, column_stats_map); std::vector> column_stats_ptrs; diff --git a/src/optimizer/stats/tuple_samples_storage.cpp b/src/optimizer/stats/tuple_samples_storage.cpp index edb41c2f820..64bd55ddb21 100644 --- a/src/optimizer/stats/tuple_samples_storage.cpp +++ b/src/optimizer/stats/tuple_samples_storage.cpp @@ -44,7 +44,7 @@ TupleSamplesStorage::TupleSamplesStorage() { void TupleSamplesStorage::CreateSamplesDatabase() { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(SAMPLES_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, SAMPLES_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -65,13 +65,17 @@ void TupleSamplesStorage::AddSamplesTable( auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateTable(std::string(SAMPLES_DB_NAME), - std::string(DEFAULT_SCHEMA_NAME), samples_table_name, - std::move(schema_ptr), txn, is_catalog); - - auto samples_table = catalog->GetTableWithName( - std::string(SAMPLES_DB_NAME), std::string(DEFAULT_SCHEMA_NAME), - samples_table_name, txn); + catalog->CreateTable(txn, + std::string(SAMPLES_DB_NAME), + std::string(DEFAULT_SCHEMA_NAME), + std::move(schema_ptr), + samples_table_name, + is_catalog); + + auto samples_table = catalog->GetTableWithName(txn, + std::string(SAMPLES_DB_NAME), + std::string(DEFAULT_SCHEMA_NAME), + samples_table_name); for (auto &tuple : sampled_tuples) { InsertSampleTuple(samples_table, std::move(tuple), txn); @@ -93,9 +97,10 @@ ResultType TupleSamplesStorage::DeleteSamplesTable( GenerateSamplesTableName(database_id, table_id); ResultType result = ResultType::FAILURE; try { - result = catalog->DropTable(std::string(SAMPLES_DB_NAME), + result = catalog->DropTable(txn, + std::string(SAMPLES_DB_NAME), std::string(DEFAULT_SCHEMA_NAME), - samples_table_name, txn); + samples_table_name); } catch (CatalogException &e) { // Samples table does not exist, no need to drop } @@ -186,9 +191,10 @@ TupleSamplesStorage::GetTupleSamples(oid_t database_id, oid_t table_id) { GenerateSamplesTableName(database_id, table_id); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - auto data_table = catalog->GetTableWithName(std::string(SAMPLES_DB_NAME), + auto data_table = catalog->GetTableWithName(txn, + std::string(SAMPLES_DB_NAME), std::string(DEFAULT_SCHEMA_NAME), - samples_table_name, txn); + samples_table_name); auto col_count = data_table->GetSchema()->GetColumnCount(); std::vector column_ids; @@ -213,9 +219,10 @@ void TupleSamplesStorage::GetColumnSamples( GenerateSamplesTableName(database_id, table_id); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - auto data_table = catalog->GetTableWithName(std::string(SAMPLES_DB_NAME), + auto data_table = catalog->GetTableWithName(txn, + std::string(SAMPLES_DB_NAME), std::string(DEFAULT_SCHEMA_NAME), - samples_table_name, txn); + samples_table_name); std::vector column_ids({column_id}); auto result_tiles = GetTuplesWithSeqScan(data_table, column_ids, txn); diff --git a/src/planner/analyze_plan.cpp b/src/planner/analyze_plan.cpp index 5de53476b14..faec07c5853 100644 --- a/src/planner/analyze_plan.cpp +++ b/src/planner/analyze_plan.cpp @@ -25,8 +25,10 @@ AnalyzePlan::AnalyzePlan(std::string table_name, std::string schema_name, std::string database_name, concurrency::TransactionContext *txn) : table_name_(table_name) { - target_table_ = catalog::Catalog::GetInstance()->GetTableWithName( - database_name, schema_name, table_name, txn); + target_table_ = catalog::Catalog::GetInstance()->GetTableWithName(txn, + database_name, + schema_name, + table_name); } AnalyzePlan::AnalyzePlan(std::string table_name, std::string schema_name, @@ -34,8 +36,10 @@ AnalyzePlan::AnalyzePlan(std::string table_name, std::string schema_name, std::vector column_names, concurrency::TransactionContext *txn) : table_name_(table_name), column_names_(column_names) { - target_table_ = catalog::Catalog::GetInstance()->GetTableWithName( - database_name, schema_name, table_name, txn); + target_table_ = catalog::Catalog::GetInstance()->GetTableWithName(txn, + database_name, + schema_name, + table_name); } AnalyzePlan::AnalyzePlan(parser::AnalyzeStatement *analyze_stmt, @@ -45,9 +49,10 @@ AnalyzePlan::AnalyzePlan(parser::AnalyzeStatement *analyze_stmt, for (auto &name : analyze_stmt->GetColumnNames()) column_names_.push_back((char *)name.c_str()); if (!table_name_.empty()) { - target_table_ = catalog::Catalog::GetInstance()->GetTableWithName( - analyze_stmt->GetDatabaseName(), analyze_stmt->GetSchemaName(), - table_name_, txn); + target_table_ = catalog::Catalog::GetInstance()->GetTableWithName(txn, + analyze_stmt->GetDatabaseName(), + analyze_stmt->GetSchemaName(), + table_name_); } } diff --git a/src/planner/plan_util.cpp b/src/planner/plan_util.cpp index cb013fb1531..aecedb80486 100644 --- a/src/planner/plan_util.cpp +++ b/src/planner/plan_util.cpp @@ -57,8 +57,8 @@ const std::set PlanUtil::GetAffectedIndexes( schema_name = delete_stmt.GetSchemaName(); } auto indexes_map = catalog_cache.GetDatabaseObject(db_name) - ->GetTableObject(table_name, schema_name) - ->GetIndexObjects(); + ->GetTableCatalogEntry(table_name, schema_name) + ->GetIndexCatalogEntries(); for (auto &index : indexes_map) { index_oids.insert(index.first); } @@ -70,18 +70,19 @@ const std::set PlanUtil::GetAffectedIndexes( table_name = update_stmt.table->GetTableName(); schema_name = update_stmt.table->GetSchemaName(); auto table_object = catalog_cache.GetDatabaseObject(db_name) - ->GetTableObject(table_name, schema_name); + ->GetTableCatalogEntry(table_name, schema_name); auto &update_clauses = update_stmt.updates; std::set update_oids; for (const auto &update_clause : update_clauses) { LOG_TRACE("Affected column name for table(%s) in UPDATE query: %s", table_name.c_str(), update_clause->column.c_str()); - auto col_object = table_object->GetColumnObject(update_clause->column); + auto col_object = + table_object->GetColumnCatalogEntry(update_clause->column); update_oids.insert(col_object->GetColumnId()); } - auto indexes_map = table_object->GetIndexObjects(); + auto indexes_map = table_object->GetIndexCatalogEntries(); for (auto &index : indexes_map) { LOG_TRACE("Checking if UPDATE query affects index: %s", index.second->GetIndexName().c_str()); diff --git a/src/settings/settings_manager.cpp b/src/settings/settings_manager.cpp index 10841886303..18de619defd 100644 --- a/src/settings/settings_manager.cpp +++ b/src/settings/settings_manager.cpp @@ -73,12 +73,18 @@ void SettingsManager::InitializeCatalog() { for (auto s : settings_) { // TODO: Use Update instead Delete & Insert - settings_catalog.DeleteSetting(s.second.name, txn); - if (!settings_catalog.InsertSetting( - s.second.name, s.second.value.ToString(), - s.second.value.GetTypeId(), s.second.desc, "", "", - s.second.default_value.ToString(), s.second.is_mutable, - s.second.is_persistent, pool, txn)) { + settings_catalog.DeleteSetting(txn, s.second.name); + if (!settings_catalog.InsertSetting(txn, + s.second.name, + s.second.value.ToString(), + s.second.value.GetTypeId(), + s.second.desc, + "", + "", + s.second.default_value.ToString(), + s.second.is_mutable, + s.second.is_persistent, + pool)) { txn_manager.AbortTransaction(txn); throw SettingsException("failed to initialize catalog pg_settings on " + s.second.name); @@ -174,11 +180,18 @@ bool SettingsManager::InsertIntoCatalog(const Param ¶m) { auto txn = txn_manager.BeginTransaction(); type::AbstractPool *pool = pool_.get(); // TODO: Use Update instead Delete & Insert - settings_catalog.DeleteSetting(param.name, txn); - if (!settings_catalog.InsertSetting( - param.name, param.value.ToString(), param.value.GetTypeId(), - param.desc, "", "", param.default_value.ToString(), param.is_mutable, - param.is_persistent, pool, txn)) { + settings_catalog.DeleteSetting(txn, param.name); + if (!settings_catalog.InsertSetting(txn, + param.name, + param.value.ToString(), + param.value.GetTypeId(), + param.desc, + "", + "", + param.default_value.ToString(), + param.is_mutable, + param.is_persistent, + pool)) { txn_manager.AbortTransaction(txn); return false; } diff --git a/src/statistics/stats_aggregator.cpp b/src/statistics/stats_aggregator.cpp index 6d4a39847a3..29a710bdd86 100644 --- a/src/statistics/stats_aggregator.cpp +++ b/src/statistics/stats_aggregator.cpp @@ -164,11 +164,21 @@ void StatsAggregator::UpdateQueryMetrics(int64_t time_stamp, catalog::Catalog::GetInstance() ->GetSystemCatalogs(query_metric->GetDatabaseId()) ->GetQueryMetricsCatalog() - ->InsertQueryMetrics( - query_metric->GetName(), query_metric->GetDatabaseId(), num_params, - type_buf, format_buf, value_buf, reads, updates, deletes, inserts, - (int64_t)latency, (int64_t)(cpu_system + cpu_user), time_stamp, - pool_.get(), txn); + ->InsertQueryMetrics(txn, + query_metric->GetName(), + query_metric->GetDatabaseId(), + num_params, + type_buf, + format_buf, + value_buf, + reads, + updates, + deletes, + inserts, + (int64_t) latency, + (int64_t) (cpu_system + cpu_user), + time_stamp, + pool_.get()); LOG_TRACE("Query Metric Tuple inserted"); } @@ -199,7 +209,8 @@ void StatsAggregator::UpdateMetrics() { std::string database_name; try { auto database_object = - catalog::Catalog::GetInstance()->GetDatabaseObject(database_oid, txn); + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, + database_oid); database_name = database_object->GetDatabaseName(); } catch (CatalogException &e) { continue; @@ -211,8 +222,12 @@ void StatsAggregator::UpdateMetrics() { auto txn_committed = database_metric->GetTxnCommitted().GetCounter(); auto txn_aborted = database_metric->GetTxnAborted().GetCounter(); - catalog::DatabaseMetricsCatalog::GetInstance()->InsertDatabaseMetrics( - database_oid, txn_committed, txn_aborted, time_stamp, pool_.get(), txn); + catalog::DatabaseMetricsCatalog::GetInstance()->InsertDatabaseMetrics(txn, + database_oid, + txn_committed, + txn_aborted, + time_stamp, + pool_.get()); LOG_TRACE("DB Metric Tuple inserted"); // Update all the indices of this database @@ -245,9 +260,14 @@ void StatsAggregator::UpdateTableMetrics(storage::Database *database, auto table_metrics_catalog = catalog::Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetTableMetricsCatalog(); - table_metrics_catalog->InsertTableMetrics(table_oid, reads, updates, - deletes, inserts, time_stamp, - pool_.get(), txn); + table_metrics_catalog->InsertTableMetrics(txn, + table_oid, + reads, + updates, + deletes, + inserts, + time_stamp, + pool_.get()); LOG_TRACE("Table Metric Tuple inserted"); UpdateIndexMetrics(database, table, time_stamp, txn); @@ -277,9 +297,14 @@ void StatsAggregator::UpdateIndexMetrics(storage::Database *database, auto index_metrics_catalog = catalog::Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetIndexMetricsCatalog(); - index_metrics_catalog->InsertIndexMetrics(table_oid, index_oid, reads, - deletes, inserts, time_stamp, - pool_.get(), txn); + index_metrics_catalog->InsertIndexMetrics(txn, + table_oid, + index_oid, + reads, + deletes, + inserts, + time_stamp, + pool_.get()); } } diff --git a/src/storage/data_table.cpp b/src/storage/data_table.cpp index 9615691d54f..c292e8d3718 100644 --- a/src/storage/data_table.cpp +++ b/src/storage/data_table.cpp @@ -1391,9 +1391,9 @@ trigger::TriggerList *DataTable::GetTriggerList() { void DataTable::UpdateTriggerListFromCatalog( concurrency::TransactionContext *txn) { trigger_list_ = catalog::Catalog::GetInstance() - ->GetSystemCatalogs(database_oid) - ->GetTriggerCatalog() - ->GetTriggers(table_oid, txn); + ->GetSystemCatalogs(database_oid) + ->GetTriggerCatalog() + ->GetTriggers(txn, table_oid); } hash_t DataTable::Hash() const { diff --git a/src/storage/zone_map_manager.cpp b/src/storage/zone_map_manager.cpp index 2e6269bf170..01f75070aea 100644 --- a/src/storage/zone_map_manager.cpp +++ b/src/storage/zone_map_manager.cpp @@ -144,12 +144,21 @@ void ZoneMapManager::CreateOrUpdateZoneMapInCatalog( single_statement_txn = true; txn = txn_manager.BeginTransaction(); } - stats_catalog->DeleteColumnStatistics(database_id, table_id, tile_group_idx, - column_id, txn); + stats_catalog->DeleteColumnStatistics(txn, + database_id, + table_id, + tile_group_idx, + column_id); - stats_catalog->InsertColumnStatistics(database_id, table_id, tile_group_idx, - column_id, min, max, type, pool_.get(), - txn); + stats_catalog->InsertColumnStatistics(txn, + database_id, + table_id, + tile_group_idx, + column_id, + min, + max, + type, + pool_.get()); if (single_statement_txn) { txn_manager.CommitTransaction(txn); @@ -172,8 +181,11 @@ ZoneMapManager::GetZoneMapFromCatalog(oid_t database_id, oid_t table_id, auto stats_catalog = catalog::ZoneMapCatalog::GetInstance(nullptr); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - auto result_vector = stats_catalog->GetColumnStatistics( - database_id, table_id, tile_group_idx, column_id, txn); + auto result_vector = stats_catalog->GetColumnStatistics(txn, + database_id, + table_id, + tile_group_idx, + column_id); txn_manager.CommitTransaction(txn); if (result_vector == nullptr) { diff --git a/src/traffic_cop/traffic_cop.cpp b/src/traffic_cop/traffic_cop.cpp index 7bfffebb4c0..bbf0846ac9a 100644 --- a/src/traffic_cop/traffic_cop.cpp +++ b/src/traffic_cop/traffic_cop.cpp @@ -420,8 +420,10 @@ void TrafficCop::GetTableColumns(parser::TableRef *from_table, auto columns = static_cast( catalog::Catalog::GetInstance()->GetTableWithName( - from_table->GetDatabaseName(), from_table->GetSchemaName(), - from_table->GetTableName(), GetCurrentTxnState().first)) + GetCurrentTxnState().first, + from_table->GetDatabaseName(), + from_table->GetSchemaName(), + from_table->GetTableName())) ->GetSchema() ->GetColumns(); target_columns.insert(target_columns.end(), columns.begin(), diff --git a/src/trigger/trigger.cpp b/src/trigger/trigger.cpp index cb992d0e06d..e84cf9fdab4 100644 --- a/src/trigger/trigger.cpp +++ b/src/trigger/trigger.cpp @@ -90,10 +90,13 @@ void Trigger::SerializeWhen(SerializeOutput &output, oid_t database_oid, case ExpressionType::VALUE_TUPLE: { auto e = static_cast(expr); - auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - database_oid, table_oid, txn); + auto table_object = + catalog::Catalog::GetInstance()->GetTableCatalogEntry( + txn, + database_oid, + table_oid); auto column_object = - table_object->GetColumnObject(e->GetColumnName()); + table_object->GetColumnCatalogEntry(e->GetColumnName()); output.WriteInt(static_cast(column_object->GetColumnType())); output.WriteInt(static_cast(column_object->GetColumnId())); break; diff --git a/src/tuning/index_tuner.cpp b/src/tuning/index_tuner.cpp index cbd1bd57926..7a20082e252 100644 --- a/src/tuning/index_tuner.cpp +++ b/src/tuning/index_tuner.cpp @@ -597,8 +597,10 @@ void IndexTuner::BootstrapTPCC(const std::string &path) { // Locate table in catalog auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - auto table = catalog->GetTableWithName( - database_name, std::string(DEFAULT_SCHEMA_NAME), table_name, txn); + auto table = catalog->GetTableWithName(txn, + database_name, + std::string(DEFAULT_SCHEMA_NAME), + table_name); txn_manager.CommitTransaction(txn); PELOTON_ASSERT(table != nullptr); for (auto &sample : samples) { diff --git a/src/tuning/layout_tuner.cpp b/src/tuning/layout_tuner.cpp index 5953a4e8dfc..567c8fec5f8 100644 --- a/src/tuning/layout_tuner.cpp +++ b/src/tuning/layout_tuner.cpp @@ -118,7 +118,7 @@ bool LayoutTuner::UpdateDefaultPartition(storage::DataTable *table) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto *txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); - if (catalog->CreateDefaultLayout(database_oid, table_oid, column_map, txn) == + if (catalog->CreateDefaultLayout(txn, database_oid, table_oid, column_map) == nullptr) { txn_manager.AbortTransaction(txn); LOG_DEBUG("Layout Update to failed."); diff --git a/test/binder/binder_test.cpp b/test/binder/binder_test.cpp index b5b266c21cf..e581ad5152f 100644 --- a/test/binder/binder_test.cpp +++ b/test/binder/binder_test.cpp @@ -55,7 +55,7 @@ void SetupTables(std::string database_name) { LOG_INFO("Creating database %s", database_name.c_str()); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(database_name, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, database_name); txn_manager.CommitTransaction(txn); LOG_INFO("database %s created!", database_name.c_str()); @@ -126,14 +126,12 @@ TEST_F(BinderCorrectnessTest, SelectStatementTest) { binder->BindNameToNode(selectStmt); oid_t db_oid = - catalog_ptr->GetDatabaseWithName(default_database_name, txn)->GetOid(); + catalog_ptr->GetDatabaseWithName(txn, default_database_name)->GetOid(); oid_t tableA_oid = catalog_ptr - ->GetTableWithName(default_database_name, - DEFAULT_SCHEMA_NAME, "a", txn) + ->GetTableWithName(txn, default_database_name, DEFAULT_SCHEMA_NAME, "a") ->GetOid(); oid_t tableB_oid = catalog_ptr - ->GetTableWithName(default_database_name, - DEFAULT_SCHEMA_NAME, "b", txn) + ->GetTableWithName(txn, default_database_name, DEFAULT_SCHEMA_NAME, "b") ->GetOid(); txn_manager.CommitTransaction(txn); @@ -242,7 +240,7 @@ TEST_F(BinderCorrectnessTest, SelectStatementTest) { txn_manager.CommitTransaction(txn); // Delete the test database txn = txn_manager.BeginTransaction(); - catalog_ptr->DropDatabaseWithName(default_database_name, txn); + catalog_ptr->DropDatabaseWithName(txn, default_database_name); txn_manager.CommitTransaction(txn); } @@ -259,10 +257,9 @@ TEST_F(BinderCorrectnessTest, DeleteStatementTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); oid_t db_oid = - catalog_ptr->GetDatabaseWithName(default_database_name, txn)->GetOid(); + catalog_ptr->GetDatabaseWithName(txn, default_database_name)->GetOid(); oid_t tableB_oid = catalog_ptr - ->GetTableWithName(default_database_name, - DEFAULT_SCHEMA_NAME, "b", txn) + ->GetTableWithName(txn, default_database_name, DEFAULT_SCHEMA_NAME, "b") ->GetOid(); string deleteSQL = "DELETE FROM b WHERE 1 = b1 AND b2 = 'str'"; @@ -288,7 +285,7 @@ TEST_F(BinderCorrectnessTest, DeleteStatementTest) { // Delete the test database txn = txn_manager.BeginTransaction(); - catalog_ptr->DropDatabaseWithName(default_database_name, txn); + catalog_ptr->DropDatabaseWithName(txn, default_database_name); txn_manager.CommitTransaction(txn); } @@ -378,7 +375,7 @@ TEST_F(BinderCorrectnessTest, BindDepthTest) { // Delete the test database catalog::Catalog *catalog_ptr = catalog::Catalog::GetInstance(); txn = txn_manager.BeginTransaction(); - catalog_ptr->DropDatabaseWithName(default_database_name, txn); + catalog_ptr->DropDatabaseWithName(txn, default_database_name); txn_manager.CommitTransaction(txn); } diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index d99ba49bf25..bda84540f89 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -42,11 +42,13 @@ TEST_F(CatalogTests, BootstrappingCatalog) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); storage::Database *database = - catalog->GetDatabaseWithName(CATALOG_DATABASE_NAME, txn); + catalog->GetDatabaseWithName(txn, CATALOG_DATABASE_NAME); // Check database metric table storage::DataTable *db_metric_table = - catalog->GetTableWithName(CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, - DATABASE_METRICS_CATALOG_NAME, txn); + catalog->GetTableWithName(txn, + CATALOG_DATABASE_NAME, + CATALOG_SCHEMA_NAME, + DATABASE_METRICS_CATALOG_NAME); txn_manager.CommitTransaction(txn); EXPECT_NE(nullptr, database); EXPECT_NE(nullptr, db_metric_table); @@ -55,10 +57,10 @@ TEST_F(CatalogTests, BootstrappingCatalog) { TEST_F(CatalogTests, CreatingDatabase) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase("emp_db", txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, "emp_db"); EXPECT_EQ("emp_db", catalog::Catalog::GetInstance() - ->GetDatabaseWithName("emp_db", txn) - ->GetDBName()); + ->GetDatabaseWithName(txn, "emp_db") + ->GetDBName()); txn_manager.CommitTransaction(txn); } @@ -79,44 +81,72 @@ TEST_F(CatalogTests, CreatingTable) { std::unique_ptr table_schema_3( new catalog::Schema({id_column, name_column})); - catalog::Catalog::GetInstance()->CreateTable( - "emp_db", DEFAULT_SCHEMA_NAME, "emp_table", std::move(table_schema), txn); - catalog::Catalog::GetInstance()->CreateTable("emp_db", DEFAULT_SCHEMA_NAME, + catalog::Catalog::GetInstance()->CreateTable(txn, + "emp_db", + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + "emp_table", + false); + catalog::Catalog::GetInstance()->CreateTable(txn, + "emp_db", + DEFAULT_SCHEMA_NAME, + std::move(table_schema_2), "department_table", - std::move(table_schema_2), txn); - catalog::Catalog::GetInstance()->CreateTable("emp_db", DEFAULT_SCHEMA_NAME, + false); + catalog::Catalog::GetInstance()->CreateTable(txn, + "emp_db", + DEFAULT_SCHEMA_NAME, + std::move(table_schema_3), "salary_table", - std::move(table_schema_3), txn); + false); // insert random tuple into DATABASE_METRICS_CATALOG and check std::unique_ptr pool(new type::EphemeralPool()); - catalog::DatabaseMetricsCatalog::GetInstance()->InsertDatabaseMetrics( - 2, 3, 4, 5, pool.get(), txn); + catalog::DatabaseMetricsCatalog::GetInstance()->InsertDatabaseMetrics(txn, + 2, + 3, + 4, + 5, + pool.get()); // inset meaningless tuple into QUERY_METRICS_CATALOG and check stats::QueryMetric::QueryParamBuf param; param.len = 1; - param.buf = (unsigned char *)pool->Allocate(1); + param.buf = (unsigned char *) pool->Allocate(1); *param.buf = 'a'; auto database_object = - catalog::Catalog::GetInstance()->GetDatabaseObject("emp_db", txn); + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, "emp_db"); catalog::Catalog::GetInstance() ->GetSystemCatalogs(database_object->GetDatabaseOid()) ->GetQueryMetricsCatalog() - ->InsertQueryMetrics("a query", database_object->GetDatabaseOid(), 1, - param, param, param, 1, 1, 1, 1, 1, 1, 1, pool.get(), - txn); + ->InsertQueryMetrics(txn, + "a query", + database_object->GetDatabaseOid(), + 1, + param, + param, + param, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + pool.get()); auto param1 = catalog::Catalog::GetInstance() - ->GetSystemCatalogs(database_object->GetDatabaseOid()) - ->GetQueryMetricsCatalog() - ->GetParamTypes("a query", txn); + ->GetSystemCatalogs(database_object->GetDatabaseOid()) + ->GetQueryMetricsCatalog() + ->GetParamTypes(txn, "a query"); EXPECT_EQ(1, param1.len); EXPECT_EQ('a', *param1.buf); // check colum object EXPECT_EQ("name", catalog::Catalog::GetInstance() - ->GetTableObject("emp_db", DEFAULT_SCHEMA_NAME, - "department_table", txn) - ->GetColumnObject(1) - ->GetColumnName()); + ->GetTableCatalogEntry(txn, + "emp_db", + DEFAULT_SCHEMA_NAME, + "department_table") + ->GetColumnCatalogEntry(1) + ->GetColumnName()); txn_manager.CommitTransaction(txn); } @@ -125,19 +155,23 @@ TEST_F(CatalogTests, TestingCatalogCache) { auto txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); - auto catalog_db_object = catalog->GetDatabaseObject(CATALOG_DATABASE_OID, txn); - auto catalog_table_objects = catalog_db_object->GetTableObjects(); + auto + catalog_db_object = + catalog->GetDatabaseCatalogEntry(txn, CATALOG_DATABASE_OID); + auto catalog_table_objects = catalog_db_object->GetTableCatalogEntries(); EXPECT_NE(0, catalog_table_objects.size()); - auto user_db_object = catalog->GetDatabaseObject("emp_db", txn); + auto user_db_object = catalog->GetDatabaseCatalogEntry(txn, "emp_db"); auto user_database = storage::StorageManager::GetInstance() - ->GetDatabaseWithOid(user_db_object->GetDatabaseOid()); + ->GetDatabaseWithOid(user_db_object->GetDatabaseOid()); // check expected table object is acquired - for (oid_t table_idx = 0; table_idx < user_database->GetTableCount(); table_idx++) { + for (oid_t table_idx = 0; table_idx < user_database->GetTableCount(); + table_idx++) { auto table = user_database->GetTable(table_idx); - auto user_table_object = user_db_object->GetTableObject(table->GetOid()); - EXPECT_EQ(user_db_object->GetDatabaseOid(), + auto user_table_object = + user_db_object->GetTableCatalogEntry(table->GetOid()); + EXPECT_EQ(user_db_object->GetDatabaseOid(), user_table_object->GetDatabaseOid()); } @@ -148,11 +182,13 @@ TEST_F(CatalogTests, TableObject) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - "emp_db", DEFAULT_SCHEMA_NAME, "department_table", txn); + auto table_object = catalog::Catalog::GetInstance()->GetTableCatalogEntry(txn, + "emp_db", + DEFAULT_SCHEMA_NAME, + "department_table"); - auto index_objects = table_object->GetIndexObjects(); - auto column_objects = table_object->GetColumnObjects(); + auto index_objects = table_object->GetIndexCatalogEntries(); + auto column_objects = table_object->GetColumnCatalogEntries(); EXPECT_EQ(1, index_objects.size()); EXPECT_EQ(2, column_objects.size()); @@ -163,7 +199,7 @@ TEST_F(CatalogTests, TableObject) { EXPECT_EQ(0, column_objects[0]->GetColumnOffset()); EXPECT_EQ(type::TypeId::INTEGER, column_objects[0]->GetColumnType()); EXPECT_EQ(type::Type::GetTypeSize(type::TypeId::INTEGER), - column_objects[0]->GetColumnLength()); + column_objects[0]->GetColumnLength()); EXPECT_TRUE(column_objects[0]->IsInlined()); EXPECT_TRUE(column_objects[0]->IsPrimary()); EXPECT_FALSE(column_objects[0]->IsNotNull()); @@ -173,7 +209,7 @@ TEST_F(CatalogTests, TableObject) { EXPECT_EQ(1, column_objects[1]->GetColumnId()); EXPECT_EQ(4, column_objects[1]->GetColumnOffset()); EXPECT_EQ(type::TypeId::VARCHAR, column_objects[1]->GetColumnType()); - EXPECT_EQ(32, column_objects[1]->GetColumnLength()); + EXPECT_EQ(32, column_objects[1]->GetColumnLength()); EXPECT_TRUE(column_objects[1]->IsInlined()); EXPECT_FALSE(column_objects[1]->IsPrimary()); EXPECT_FALSE(column_objects[1]->IsNotNull()); @@ -181,12 +217,14 @@ TEST_F(CatalogTests, TableObject) { // update pg_table SET version_oid = 1 where table_name = department_table oid_t department_table_oid = table_object->GetTableOid(); auto pg_table = catalog::Catalog::GetInstance() - ->GetSystemCatalogs(table_object->GetDatabaseOid()) - ->GetTableCatalog(); - bool update_result = pg_table->UpdateVersionId(1, department_table_oid, txn); + ->GetSystemCatalogs(table_object->GetDatabaseOid()) + ->GetTableCatalog(); + bool update_result = pg_table->UpdateVersionId(txn, department_table_oid, 1); // get version id after update, invalidate old cache - table_object = catalog::Catalog::GetInstance()->GetTableObject( - "emp_db", DEFAULT_SCHEMA_NAME, "department_table", txn); + table_object = catalog::Catalog::GetInstance()->GetTableCatalogEntry(txn, + "emp_db", + DEFAULT_SCHEMA_NAME, + "department_table"); uint32_t version_oid = table_object->GetVersionId(); EXPECT_NE(department_table_oid, INVALID_OID); EXPECT_EQ(update_result, true); @@ -199,7 +237,7 @@ TEST_F(CatalogTests, TestingNamespace) { EXPECT_EQ(ResultType::SUCCESS, TestingSQLUtil::ExecuteSQLQuery("begin;")); // create namespaces emp_ns0 and emp_ns1 EXPECT_EQ(ResultType::SUCCESS, TestingSQLUtil::ExecuteSQLQuery( - "create database default_database;")); + "create database default_database;")); EXPECT_EQ(ResultType::SUCCESS, TestingSQLUtil::ExecuteSQLQuery("create schema emp_ns0;")); EXPECT_EQ(ResultType::SUCCESS, @@ -240,7 +278,7 @@ TEST_F(CatalogTests, TestingNamespace) { EXPECT_EQ(ResultType::SUCCESS, TestingSQLUtil::ExecuteSQLQuery("commit;")); EXPECT_EQ(ResultType::SUCCESS, TestingSQLUtil::ExecuteSQLQuery("begin;")); EXPECT_EQ(ResultType::FAILURE, TestingSQLUtil::ExecuteSQLQuery( - "select * from emp_ns1.emp_table1;")); + "select * from emp_ns1.emp_table1;")); EXPECT_EQ(ResultType::ABORTED, TestingSQLUtil::ExecuteSQLQuery("commit;")); // drop namespace emp_ns0 and emp_ns1 @@ -254,7 +292,7 @@ TEST_F(CatalogTests, TestingNamespace) { EXPECT_EQ(ResultType::FAILURE, TestingSQLUtil::ExecuteSQLQuery("drop schema emp_ns0;")); EXPECT_EQ(ResultType::FAILURE, TestingSQLUtil::ExecuteSQLQuery( - "select * from emp_ns0.emp_table1;")); + "select * from emp_ns0.emp_table1;")); EXPECT_EQ(ResultType::ABORTED, TestingSQLUtil::ExecuteSQLQuery("commit;")); } @@ -267,66 +305,80 @@ TEST_F(CatalogTests, DroppingTable) { oid_t expected_table_count = CATALOG_TABLES_COUNT + 3; EXPECT_EQ( expected_table_count, - (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); + (int) catalog->GetDatabaseCatalogEntry(txn, + "emp_db")->GetTableCatalogEntries().size()); auto database_object = - catalog::Catalog::GetInstance()->GetDatabaseObject("emp_db", txn); + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, "emp_db"); EXPECT_NE(nullptr, database_object); - catalog::Catalog::GetInstance()->DropTable("emp_db", DEFAULT_SCHEMA_NAME, - "department_table", txn); + catalog::Catalog::GetInstance()->DropTable(txn, + "emp_db", + DEFAULT_SCHEMA_NAME, + "department_table"); database_object = - catalog::Catalog::GetInstance()->GetDatabaseObject("emp_db", txn); + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, "emp_db"); EXPECT_NE(nullptr, database_object); auto department_table_object = - database_object->GetTableObject("department_table", DEFAULT_SCHEMA_NAME); + database_object->GetTableCatalogEntry("department_table", + DEFAULT_SCHEMA_NAME); // Decrement expected_table_count to account for the dropped table. expected_table_count--; EXPECT_EQ( expected_table_count, - (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); + (int) catalog->GetDatabaseCatalogEntry(txn, + "emp_db")->GetTableCatalogEntries().size()); txn_manager.CommitTransaction(txn); EXPECT_EQ(nullptr, department_table_object); // Try to drop again txn = txn_manager.BeginTransaction(); - EXPECT_THROW(catalog::Catalog::GetInstance()->DropTable( - "emp_db", DEFAULT_SCHEMA_NAME, "department_table", txn), + EXPECT_THROW(catalog::Catalog::GetInstance()->DropTable(txn, + "emp_db", + DEFAULT_SCHEMA_NAME, + "department_table"), CatalogException); EXPECT_EQ( expected_table_count, - (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); + (int) catalog->GetDatabaseCatalogEntry(txn, + "emp_db")->GetTableCatalogEntries().size()); txn_manager.CommitTransaction(txn); // Drop a table that does not exist txn = txn_manager.BeginTransaction(); - EXPECT_THROW(catalog::Catalog::GetInstance()->DropTable( - "emp_db", DEFAULT_SCHEMA_NAME, "void_table", txn), + EXPECT_THROW(catalog::Catalog::GetInstance()->DropTable(txn, + "emp_db", + DEFAULT_SCHEMA_NAME, + "void_table"), CatalogException); EXPECT_EQ( expected_table_count, - (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); + (int) catalog->GetDatabaseCatalogEntry(txn, + "emp_db")->GetTableCatalogEntries().size()); txn_manager.CommitTransaction(txn); // Drop the other table txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropTable("emp_db", DEFAULT_SCHEMA_NAME, - "emp_table", txn); + catalog::Catalog::GetInstance()->DropTable(txn, + "emp_db", + DEFAULT_SCHEMA_NAME, + "emp_table"); // Account for the dropped table. expected_table_count--; EXPECT_EQ( expected_table_count, - (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); + (int) catalog->GetDatabaseCatalogEntry(txn, + "emp_db")->GetTableCatalogEntries().size()); txn_manager.CommitTransaction(txn); } TEST_F(CatalogTests, DroppingDatabase) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName("emp_db", txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, "emp_db"); EXPECT_THROW( - catalog::Catalog::GetInstance()->GetDatabaseWithName("emp_db", txn), + catalog::Catalog::GetInstance()->GetDatabaseWithName(txn, "emp_db"), CatalogException); txn_manager.CommitTransaction(txn); } @@ -350,7 +402,7 @@ TEST_F(CatalogTests, LayoutCatalogTest) { // Create database. auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - EXPECT_EQ(ResultType::SUCCESS, catalog->CreateDatabase(db_name, txn)); + EXPECT_EQ(ResultType::SUCCESS, catalog->CreateDatabase(txn, db_name)); // Create table. auto val0 = catalog::Column(type::TypeId::INTEGER, @@ -368,18 +420,25 @@ TEST_F(CatalogTests, LayoutCatalogTest) { std::unique_ptr table_schema( new catalog::Schema({val0, val1, val2, val3})); EXPECT_EQ(ResultType::SUCCESS, - catalog->CreateTable(db_name, DEFAULT_SCHEMA_NAME, table_name, - std::move(table_schema), txn)); + catalog->CreateTable(txn, + db_name, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + table_name, + false)); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); auto database_oid = - catalog->GetDatabaseObject(db_name, txn)->GetDatabaseOid(); + catalog->GetDatabaseCatalogEntry(txn, db_name)->GetDatabaseOid(); auto table_object = - catalog->GetTableObject(db_name, DEFAULT_SCHEMA_NAME, table_name, txn); + catalog->GetTableCatalogEntry(txn, + db_name, + DEFAULT_SCHEMA_NAME, + table_name); auto table_oid = table_object->GetTableOid(); auto table = - catalog->GetTableWithName(db_name, DEFAULT_SCHEMA_NAME, table_name, txn); + catalog->GetTableWithName(txn, db_name, DEFAULT_SCHEMA_NAME, table_name); auto pg_layout = catalog->GetSystemCatalogs(database_oid)->GetLayoutCatalog(); txn_manager.CommitTransaction(txn); @@ -395,9 +454,11 @@ TEST_F(CatalogTests, LayoutCatalogTest) { auto first_layout_oid = first_default_layout->GetOid(); EXPECT_EQ( *(first_default_layout.get()), - *(pg_layout->GetLayoutWithOid(table_oid, first_layout_oid, txn).get())); + *(pg_layout->GetLayoutWithOid(txn, table_oid, first_layout_oid).get())); EXPECT_EQ(first_layout_oid, - catalog->GetTableObject(database_oid, table_oid, txn)->GetDefaultLayoutOid()); + catalog->GetTableCatalogEntry(txn, + database_oid, + table_oid)->GetDefaultLayoutOid()); txn_manager.CommitTransaction(txn); // Change default layout. @@ -409,7 +470,7 @@ TEST_F(CatalogTests, LayoutCatalogTest) { txn = txn_manager.BeginTransaction(); auto default_layout = - catalog->CreateDefaultLayout(database_oid, table_oid, default_map, txn); + catalog->CreateDefaultLayout(txn, database_oid, table_oid, default_map); EXPECT_NE(nullptr, default_layout); txn_manager.CommitTransaction(txn); @@ -424,9 +485,11 @@ TEST_F(CatalogTests, LayoutCatalogTest) { txn = txn_manager.BeginTransaction(); EXPECT_EQ( *(default_layout.get()), - *(pg_layout->GetLayoutWithOid(table_oid, default_layout_oid, txn).get())); + *(pg_layout->GetLayoutWithOid(txn, table_oid, default_layout_oid).get())); EXPECT_EQ(default_layout_oid, - catalog->GetTableObject(database_oid, table_oid, txn)->GetDefaultLayoutOid()); + catalog->GetTableCatalogEntry(txn, + database_oid, + table_oid)->GetDefaultLayoutOid()); txn_manager.CommitTransaction(txn); // Create additional layout. @@ -438,7 +501,7 @@ TEST_F(CatalogTests, LayoutCatalogTest) { txn = txn_manager.BeginTransaction(); auto other_layout = - catalog->CreateLayout(database_oid, table_oid, non_default_map, txn); + catalog->CreateLayout(txn, database_oid, table_oid, non_default_map); EXPECT_NE(nullptr, other_layout); txn_manager.CommitTransaction(txn); @@ -452,18 +515,23 @@ TEST_F(CatalogTests, LayoutCatalogTest) { auto other_layout_oid = other_layout->GetOid(); EXPECT_EQ( *(other_layout.get()), - *(pg_layout->GetLayoutWithOid(table_oid, other_layout_oid, txn).get())); + *(pg_layout->GetLayoutWithOid(txn, table_oid, other_layout_oid).get())); // Check that the default layout is still the same. EXPECT_NE(other_layout, table->GetDefaultLayout()); EXPECT_NE(other_layout_oid, - catalog->GetTableObject(database_oid, table_oid, txn)->GetDefaultLayoutOid()); + catalog->GetTableCatalogEntry(txn, + database_oid, + table_oid)->GetDefaultLayoutOid()); txn_manager.CommitTransaction(txn); // Drop the default layout. txn = txn_manager.BeginTransaction(); - EXPECT_EQ(ResultType::SUCCESS, catalog->DropLayout(database_oid, table_oid, - default_layout_oid, txn)); + EXPECT_EQ(ResultType::SUCCESS, + catalog->DropLayout(txn, + database_oid, + table_oid, + default_layout_oid)); txn_manager.CommitTransaction(txn); // Check that default layout is reset and set to row_store. @@ -476,19 +544,21 @@ TEST_F(CatalogTests, LayoutCatalogTest) { // Query pg_layout and pg_table to ensure that the entry is dropped txn = txn_manager.BeginTransaction(); EXPECT_EQ(nullptr, - pg_layout->GetLayoutWithOid(table_oid, default_layout_oid, txn)); + pg_layout->GetLayoutWithOid(txn, table_oid, default_layout_oid)); EXPECT_EQ(ROW_STORE_LAYOUT_OID, - catalog->GetTableObject(database_oid, table_oid, txn)->GetDefaultLayoutOid()); + catalog->GetTableCatalogEntry(txn, + database_oid, + table_oid)->GetDefaultLayoutOid()); // The additional layout must be present in pg_layout EXPECT_EQ( *(other_layout.get()), - *(pg_layout->GetLayoutWithOid(table_oid, other_layout_oid, txn).get())); + *(pg_layout->GetLayoutWithOid(txn, table_oid, other_layout_oid).get())); txn_manager.CommitTransaction(txn); // Drop database txn = txn_manager.BeginTransaction(); - catalog->DropDatabaseWithName(db_name, txn); + catalog->DropDatabaseWithName(txn, db_name); txn_manager.CommitTransaction(txn); } diff --git a/test/catalog/constraints_test.cpp b/test/catalog/constraints_test.cpp index dfd8b015a81..8235e85e9a9 100644 --- a/test/catalog/constraints_test.cpp +++ b/test/catalog/constraints_test.cpp @@ -106,7 +106,7 @@ TEST_F(ConstraintsTests, NOTNULLTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } #endif @@ -236,9 +236,11 @@ TEST_F(ConstraintsTests, UNIQUETest) { std::unique_ptr table_schema( new catalog::Schema({column1, column2})); std::string table_name("TEST_TABLE"); - catalog::Catalog::GetInstance()->CreateTable(DEFAULT_DB_NAME, - DEFAULT_SCHEMA_NAME, table_name, - std::move(table_schema), txn); + catalog::Catalog::GetInstance()->CreateTable(txn, DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + table_name, + false); storage::DataTable *table = catalog::Catalog::GetInstance()->GetTableWithName( DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, table_name, txn); txn_manager.CommitTransaction(txn); diff --git a/test/codegen/bloom_filter_test.cpp b/test/codegen/bloom_filter_test.cpp index ef6bf168c05..7dd0d32a7c1 100644 --- a/test/codegen/bloom_filter_test.cpp +++ b/test/codegen/bloom_filter_test.cpp @@ -42,7 +42,7 @@ class BloomFilterCodegenTest : public PelotonCodeGenTest { // Create test db auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -50,7 +50,7 @@ class BloomFilterCodegenTest : public PelotonCodeGenTest { // Drop test db auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -213,8 +213,10 @@ TEST_F(BloomFilterCodegenTest, PerformanceTest) { int curr_size = 0; std::vector numbers; std::unordered_set number_set; - auto *table1 = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, - table1_name, txn); + auto *table1 = catalog->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + table1_name); while (curr_size < table1_target_size) { // Find a unique random number int random; @@ -234,8 +236,10 @@ TEST_F(BloomFilterCodegenTest, PerformanceTest) { LOG_INFO("Finish populating test1"); // Load the inner table which contains twice tuples as the outer table - auto *table2 = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, - table2_name, txn); + auto *table2 = catalog->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + table2_name); unsigned outer_table_cardinality = numbers.size() * outer_to_inner_ratio; for (unsigned i = 0; i < outer_table_cardinality; i++) { int number; @@ -335,9 +339,12 @@ void BloomFilterCodegenTest::CreateTable(std::string table_name, int tuple_size, curr_size += bigint_size; } auto *catalog = catalog::Catalog::GetInstance(); - catalog->CreateTable( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, table_name, - std::unique_ptr(new catalog::Schema(cols)), txn); + catalog->CreateTable(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::unique_ptr(new catalog::Schema(cols)), + table_name, + false); } // Insert a tuple to specific table diff --git a/test/codegen/table_scan_translator_test.cpp b/test/codegen/table_scan_translator_test.cpp index f1080afda6d..6780aadf852 100644 --- a/test/codegen/table_scan_translator_test.cpp +++ b/test/codegen/table_scan_translator_test.cpp @@ -113,11 +113,17 @@ class TableScanTranslatorTest : public PelotonCodeGenTest { std::unique_ptr schema{new catalog::Schema(cols)}; // Insert table in catalog - catalog->CreateTable(test_db_name, DEFAULT_SCHEMA_NAME, all_cols_table_name, - std::move(schema), txn); - - all_cols_table = catalog->GetTableWithName( - test_db_name, DEFAULT_SCHEMA_NAME, all_cols_table_name, txn); + catalog->CreateTable(txn, + test_db_name, + DEFAULT_SCHEMA_NAME, + std::move(schema), + all_cols_table_name, + false); + + all_cols_table = catalog->GetTableWithName(txn, + test_db_name, + DEFAULT_SCHEMA_NAME, + all_cols_table_name); auto *table_schema = all_cols_table->GetSchema(); // Insert one row where all columns are NULL @@ -702,12 +708,19 @@ TEST_F(TableScanTranslatorTest, MultiLayoutScan) { auto txn = txn_manager.BeginTransaction(); // Insert table in catalog - catalog->CreateTable(test_db_name, DEFAULT_SCHEMA_NAME, table_name, - std::move(table_schema), txn, is_catalog, - tuples_per_tilegroup, LayoutType::ROW); + catalog->CreateTable(txn, + test_db_name, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + table_name, + is_catalog, + tuples_per_tilegroup, + LayoutType::ROW); // Get table reference - auto table = catalog->GetTableWithName(test_db_name, DEFAULT_SCHEMA_NAME, - table_name, txn); + auto table = catalog->GetTableWithName(txn, + test_db_name, + DEFAULT_SCHEMA_NAME, + table_name); txn_manager.CommitTransaction(txn); ///////////////////////////////////////////////////////// @@ -716,8 +729,9 @@ TEST_F(TableScanTranslatorTest, MultiLayoutScan) { txn = txn_manager.BeginTransaction(); table->ResetDefaultLayout(LayoutType::COLUMN); catalog->GetSystemCatalogs(table->GetDatabaseOid())->GetTableCatalog() - ->UpdateDefaultLayoutOid(table->GetDefaultLayout()->GetOid(), - table->GetOid(), txn); + ->UpdateDefaultLayoutOid(txn, + table->GetOid(), + table->GetDefaultLayout()->GetOid()); txn_manager.CommitTransaction(txn); ///////////////////////////////////////////////////////// @@ -766,7 +780,7 @@ TEST_F(TableScanTranslatorTest, MultiLayoutScan) { txn = txn_manager.BeginTransaction(); auto layout = - catalog->CreateDefaultLayout(database_oid, table_oid, column_map, txn); + catalog->CreateDefaultLayout(txn, database_oid, table_oid, column_map); EXPECT_NE(nullptr, layout); txn_manager.CommitTransaction(txn); diff --git a/test/codegen/testing_codegen_util.cpp b/test/codegen/testing_codegen_util.cpp index b587aeac199..98879d6de59 100644 --- a/test/codegen/testing_codegen_util.cpp +++ b/test/codegen/testing_codegen_util.cpp @@ -44,8 +44,8 @@ PelotonCodeGenTest::PelotonCodeGenTest(oid_t tuples_per_tilegroup, auto txn = txn_manager.BeginTransaction(); // create test db - catalog->CreateDatabase(test_db_name, txn); - test_db = catalog->GetDatabaseWithName(test_db_name, txn); + catalog->CreateDatabase(txn, test_db_name); + test_db = catalog->GetDatabaseWithName(txn, test_db_name); // Create test table CreateTestTables(txn, tuples_per_tilegroup, layout_type); @@ -57,7 +57,7 @@ PelotonCodeGenTest::~PelotonCodeGenTest() { auto *catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - auto result = catalog->DropDatabaseWithName(test_db_name, txn); + auto result = catalog->DropDatabaseWithName(txn, test_db_name); txn_manager.CommitTransaction(txn); EXPECT_EQ(ResultType::SUCCESS, result); codegen::QueryCache::Instance().Clear(); @@ -115,24 +115,36 @@ void PelotonCodeGenTest::CreateTestTables(concurrency::TransactionContext *txn, auto *catalog = catalog::Catalog::GetInstance(); for (int i = 0; i < 4; i++) { auto table_schema = CreateTestSchema(); - catalog->CreateTable(test_db_name, DEFAULT_SCHEMA_NAME, test_table_names[i], - std::move(table_schema), txn, false, - tuples_per_tilegroup, layout_type); + catalog->CreateTable(txn, + test_db_name, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + test_table_names[i], + false, + tuples_per_tilegroup, + layout_type); test_table_oids.push_back(catalog - ->GetTableObject(test_db_name, - DEFAULT_SCHEMA_NAME, - test_table_names[i], txn) + ->GetTableCatalogEntry(txn, + test_db_name, + DEFAULT_SCHEMA_NAME, + test_table_names[i]) ->GetTableOid()); } for (int i = 4; i < 5; i++) { auto table_schema = CreateTestSchema(true); - catalog->CreateTable(test_db_name, DEFAULT_SCHEMA_NAME, test_table_names[i], - std::move(table_schema), txn, false, - tuples_per_tilegroup, layout_type); + catalog->CreateTable(txn, + test_db_name, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + test_table_names[i], + false, + tuples_per_tilegroup, + layout_type); test_table_oids.push_back(catalog - ->GetTableObject(test_db_name, - DEFAULT_SCHEMA_NAME, - test_table_names[i], txn) + ->GetTableCatalogEntry(txn, + test_db_name, + DEFAULT_SCHEMA_NAME, + test_table_names[i]) ->GetTableOid()); } } @@ -216,12 +228,19 @@ void PelotonCodeGenTest::CreateAndLoadTableWithLayout( auto txn = txn_manager.BeginTransaction(); // Insert table in catalog - catalog->CreateTable(test_db_name, DEFAULT_SCHEMA_NAME, table_name, - std::move(table_schema), txn, is_catalog, - tuples_per_tilegroup, layout_type); + catalog->CreateTable(txn, + test_db_name, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + table_name, + is_catalog, + tuples_per_tilegroup, + layout_type); // Get table reference - layout_table = catalog->GetTableWithName(test_db_name, DEFAULT_SCHEMA_NAME, - table_name, txn); + layout_table = catalog->GetTableWithName(txn, + test_db_name, + DEFAULT_SCHEMA_NAME, + table_name); txn_manager.EndTransaction(txn); ///////////////////////////////////////////////////////// diff --git a/test/executor/copy_test.cpp b/test/executor/copy_test.cpp index 9b9291f4111..c49e1d3848f 100644 --- a/test/executor/copy_test.cpp +++ b/test/executor/copy_test.cpp @@ -44,7 +44,7 @@ TEST_F(CopyTests, Copying) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); const auto &db_name = "emp_db"; - catalog->CreateDatabase(db_name, txn); + catalog->CreateDatabase(txn, db_name); txn_manager.CommitTransaction(txn); std::unique_ptr optimizer( @@ -158,7 +158,7 @@ TEST_F(CopyTests, Copying) { txn_manager.CommitTransaction(txn); // free the database just created txn = txn_manager.BeginTransaction(); - catalog->DropDatabaseWithName("emp_db", txn); + catalog->DropDatabaseWithName(txn, "emp_db"); txn_manager.CommitTransaction(txn); } diff --git a/test/executor/create_index_test.cpp b/test/executor/create_index_test.cpp index 9d53642935e..4068113c1a1 100644 --- a/test/executor/create_index_test.cpp +++ b/test/executor/create_index_test.cpp @@ -49,7 +49,7 @@ TEST_F(CreateIndexTests, CreatingIndex) { LOG_INFO("Bootstrapping..."); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_INFO("Bootstrapping completed!"); @@ -204,13 +204,15 @@ TEST_F(CreateIndexTests, CreatingIndex) { traffic_cop.CommitQueryHelper(); txn = txn_manager.BeginTransaction(); - auto target_table_ = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", txn); + auto target_table_ = catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "department_table"); // Expected 2 , Primary key index + created index EXPECT_EQ(target_table_->GetIndexCount(), 2); // free the database just created - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/executor/create_test.cpp b/test/executor/create_test.cpp index 214f32fa44d..55d90a727cb 100644 --- a/test/executor/create_test.cpp +++ b/test/executor/create_test.cpp @@ -58,7 +58,7 @@ TEST_F(CreateTests, CreatingDB) { executor.Execute(); // Check if the database exists in the same txn EXPECT_EQ(0, catalog::Catalog::GetInstance() - ->GetDatabaseObject("pelotondb", txn) + ->GetDatabaseCatalogEntry(txn, "pelotondb") ->GetDatabaseName() .compare("pelotondb")); @@ -68,12 +68,12 @@ TEST_F(CreateTests, CreatingDB) { txn = txn_manager.BeginTransaction(); // Check if the database exists in a new txn EXPECT_EQ(0, catalog::Catalog::GetInstance() - ->GetDatabaseObject("pelotondb", txn) + ->GetDatabaseCatalogEntry(txn, "pelotondb") ->GetDatabaseName() .compare("pelotondb")); // free the database just created - catalog::Catalog::GetInstance()->DropDatabaseWithName("pelotondb", txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, "pelotondb"); txn_manager.CommitTransaction(txn); } @@ -82,7 +82,7 @@ TEST_F(CreateTests, CreatingTable) { // Bootstrap auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); // Insert a table first auto id_column = catalog::Column( @@ -113,7 +113,7 @@ TEST_F(CreateTests, CreatingTable) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -124,7 +124,7 @@ TEST_F(CreateTests, CreatingUDFs) { // catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); auto catalog = catalog::Catalog::GetInstance(); catalog->Bootstrap(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); // Insert a table first auto id_column = catalog::Column( @@ -205,7 +205,7 @@ TEST_F(CreateTests, CreatingUDFs) { std::string func_name = "increment"; std::vector arg_types{type::TypeId::DECIMAL}; - auto inserted_proc = pg_proc.GetProcByName(func_name, arg_types, txn); + auto inserted_proc = pg_proc.GetProcByName(txn, func_name, arg_types); EXPECT_NE(nullptr, inserted_proc); type::TypeId ret_type = inserted_proc->GetRetType(); EXPECT_EQ(type::TypeId::DECIMAL, ret_type); @@ -218,7 +218,7 @@ TEST_F(CreateTests, CreatingUDFs) { EXPECT_NE(nullptr, func_data.func_context_); txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -226,7 +226,7 @@ TEST_F(CreateTests, CreatingTrigger) { // Bootstrap auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); // Insert a table first auto id_column = catalog::Column( @@ -332,8 +332,10 @@ TEST_F(CreateTests, CreatingTrigger) { // Check the effect of creation storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "accounts", txn); + catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "accounts"); txn_manager.CommitTransaction(txn); EXPECT_EQ(1, target_table->GetTriggerNumber()); trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); @@ -345,7 +347,7 @@ TEST_F(CreateTests, CreatingTrigger) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -356,7 +358,7 @@ TEST_F(CreateTests, CreatingTriggerWithoutWhen) { // Bootstrap auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); // Insert a table first auto id_column = catalog::Column( @@ -420,8 +422,10 @@ TEST_F(CreateTests, CreatingTriggerWithoutWhen) { // Check the effect of creation storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "accounts", txn); + catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "accounts"); txn_manager.CommitTransaction(txn); EXPECT_EQ(1, target_table->GetTriggerNumber()); trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); @@ -433,7 +437,7 @@ TEST_F(CreateTests, CreatingTriggerWithoutWhen) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -445,7 +449,7 @@ TEST_F(CreateTests, CreatingTriggerInCatalog) { // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests // you can only call it once! // catalog->Bootstrap(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); // Insert a table first auto id_column = catalog::Column( @@ -501,16 +505,18 @@ TEST_F(CreateTests, CreatingTriggerInCatalog) { createTriggerExecutor.Execute(); // check whether the trigger catalog table contains this new trigger - auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "accounts", txn); + auto table_object = catalog::Catalog::GetInstance()->GetTableCatalogEntry(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "accounts"); auto trigger_list = catalog::Catalog::GetInstance() ->GetSystemCatalogs(table_object->GetDatabaseOid()) ->GetTriggerCatalog() - ->GetTriggersByType( - table_object->GetTableOid(), - (TRIGGER_TYPE_ROW | TRIGGER_TYPE_BEFORE | TRIGGER_TYPE_UPDATE), - txn); + ->GetTriggersByType(txn, + table_object->GetTableOid(), + (TRIGGER_TYPE_ROW | TRIGGER_TYPE_BEFORE + | TRIGGER_TYPE_UPDATE)); txn_manager.CommitTransaction(txn); @@ -519,7 +525,7 @@ TEST_F(CreateTests, CreatingTriggerInCatalog) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/executor/drop_test.cpp b/test/executor/drop_test.cpp index f7451d3dd8d..2c1b9e5d1fb 100644 --- a/test/executor/drop_test.cpp +++ b/test/executor/drop_test.cpp @@ -45,11 +45,11 @@ TEST_F(DropTests, DroppingDatabase) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(TEST_DB_NAME, txn); + catalog->CreateDatabase(txn, TEST_DB_NAME); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - EXPECT_TRUE(catalog->GetDatabaseObject(TEST_DB_NAME, txn).get() != NULL); + EXPECT_TRUE(catalog->GetDatabaseCatalogEntry(txn, TEST_DB_NAME).get() != NULL); txn_manager.CommitTransaction(txn); parser::DropStatement drop_statement( @@ -70,7 +70,7 @@ TEST_F(DropTests, DroppingDatabase) { // The database should be deleted now txn = txn_manager.BeginTransaction(); - EXPECT_ANY_THROW(catalog->GetDatabaseObject(TEST_DB_NAME, txn);); + EXPECT_ANY_THROW(catalog->GetDatabaseCatalogEntry(txn, TEST_DB_NAME);); txn_manager.CommitTransaction(txn); } @@ -93,40 +93,50 @@ TEST_F(DropTests, DroppingTable) { std::unique_ptr table_schema2( new catalog::Schema({id_column, name_column})); - catalog->CreateDatabase(TEST_DB_NAME, txn); + catalog->CreateDatabase(txn, TEST_DB_NAME); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", - std::move(table_schema), txn); + catalog->CreateTable(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + "department_table", + false); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table_2", - std::move(table_schema2), txn); + catalog->CreateTable(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::move(table_schema2), + "department_table_2", + false); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); // NOTE: everytime we create a database, there will be 9 catalog tables // inside. In this test case, we have created two additional tables. oid_t expeected_table_count = CATALOG_TABLES_COUNT + 2; - EXPECT_EQ((int)catalog->GetDatabaseObject(TEST_DB_NAME, txn) - ->GetTableObjects() - .size(), + EXPECT_EQ((int) catalog->GetDatabaseCatalogEntry(txn, TEST_DB_NAME) + ->GetTableCatalogEntries() + .size(), expeected_table_count); // Now dropping the table using the executor - catalog->DropTable(TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", - txn); + catalog->DropTable(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + "department_table"); // Account for the dropped table. expeected_table_count--; - EXPECT_EQ((int)catalog->GetDatabaseObject(TEST_DB_NAME, txn) - ->GetTableObjects() - .size(), + EXPECT_EQ((int) catalog->GetDatabaseCatalogEntry(txn, TEST_DB_NAME) + ->GetTableCatalogEntries() + .size(), expeected_table_count); // free the database just created - catalog->DropDatabaseWithName(TEST_DB_NAME, txn); + catalog->DropDatabaseWithName(txn, TEST_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -149,12 +159,16 @@ TEST_F(DropTests, DroppingTrigger) { std::unique_ptr table_schema( new catalog::Schema({id_column, name_column})); - catalog->CreateDatabase(TEST_DB_NAME, txn); + catalog->CreateDatabase(txn, TEST_DB_NAME); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", - std::move(table_schema), txn); + catalog->CreateTable(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + "department_table", + false); txn_manager.CommitTransaction(txn); // Create a trigger @@ -184,8 +198,10 @@ TEST_F(DropTests, DroppingTrigger) { // Check the effect of creation storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName( - TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", txn); + catalog::Catalog::GetInstance()->GetTableWithName(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + "department_table"); txn_manager.CommitTransaction(txn); EXPECT_EQ(1, target_table->GetTriggerNumber()); trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); @@ -217,17 +233,19 @@ TEST_F(DropTests, DroppingTrigger) { // Now dropping the table using the executer txn = txn_manager.BeginTransaction(); - catalog->DropTable(TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", - txn); - EXPECT_EQ(CATALOG_TABLES_COUNT, (int)catalog::Catalog::GetInstance() - ->GetDatabaseObject(TEST_DB_NAME, txn) - ->GetTableObjects() - .size()); + catalog->DropTable(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + "department_table"); + EXPECT_EQ(CATALOG_TABLES_COUNT, (int) catalog::Catalog::GetInstance() + ->GetDatabaseCatalogEntry(txn, TEST_DB_NAME) + ->GetTableCatalogEntries() + .size()); txn_manager.CommitTransaction(txn); // free the database just created txn = txn_manager.BeginTransaction(); - catalog->DropDatabaseWithName(TEST_DB_NAME, txn); + catalog->DropDatabaseWithName(txn, TEST_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -240,7 +258,7 @@ TEST_F(DropTests, DroppingIndexByName) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); // create database - catalog->CreateDatabase(TEST_DB_NAME, txn); + catalog->CreateDatabase(txn, TEST_DB_NAME); // Insert a table first auto id_column = catalog::Column( type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER), @@ -255,60 +273,81 @@ TEST_F(DropTests, DroppingIndexByName) { txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table_01", - std::move(table_schema), txn); + catalog->CreateTable(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + "department_table_01", + false); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - auto source_table = catalog->GetTableWithName( - TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table_01", txn); + auto source_table = catalog->GetTableWithName(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + "department_table_01"); oid_t col_id = source_table->GetSchema()->GetColumnID(id_column.column_name); std::vector source_col_ids; source_col_ids.push_back(col_id); std::string index_name1 = "Testing_Drop_Index_By_Name"; - catalog->CreateIndex(TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table_01", - source_col_ids, index_name1, false, IndexType::BWTREE, - txn); + catalog->CreateIndex(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + "department_table_01", + index_name1, + source_col_ids, + false, + IndexType::BWTREE); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); // retrieve pg_index catalog table auto database_object = - catalog::Catalog::GetInstance()->GetDatabaseObject(TEST_DB_NAME, txn); + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, + TEST_DB_NAME); EXPECT_NE(nullptr, database_object); auto pg_index = catalog::Catalog::GetInstance() - ->GetSystemCatalogs(database_object->GetDatabaseOid()) - ->GetIndexCatalog(); + ->GetSystemCatalogs(database_object->GetDatabaseOid()) + ->GetIndexCatalog(); auto index_object = - pg_index->GetIndexObject(database_object->GetDatabaseName(), - index_name1, DEFAULT_SCHEMA_NAME, txn); + pg_index->GetIndexCatalogEntry(txn, + database_object->GetDatabaseName(), + DEFAULT_SCHEMA_NAME, + index_name1); EXPECT_NE(nullptr, index_object); // Check the effect of drop // Most major check in this test case // Now dropping the index using the DropIndex functionality - catalog->DropIndex(database_object->GetDatabaseOid(), - index_object->GetIndexOid(), txn); - EXPECT_EQ(pg_index->GetIndexObject(database_object->GetDatabaseName(), - index_name1, DEFAULT_SCHEMA_NAME, txn), + catalog->DropIndex(txn, + database_object->GetDatabaseOid(), + index_object->GetIndexOid()); + EXPECT_EQ(pg_index->GetIndexCatalogEntry(txn, + database_object->GetDatabaseName(), + DEFAULT_SCHEMA_NAME, + index_name1), nullptr); txn_manager.CommitTransaction(txn); // Drop the table just created txn = txn_manager.BeginTransaction(); // Check the effect of drop index - EXPECT_EQ(pg_index->GetIndexObject(database_object->GetDatabaseName(), - index_name1, DEFAULT_SCHEMA_NAME, txn), + EXPECT_EQ(pg_index->GetIndexCatalogEntry(txn, + database_object->GetDatabaseName(), + DEFAULT_SCHEMA_NAME, + index_name1), nullptr); // Now dropping the table - catalog->DropTable(TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table_01", - txn); + catalog->DropTable(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + "department_table_01"); txn_manager.CommitTransaction(txn); // free the database just created txn = txn_manager.BeginTransaction(); - catalog->DropDatabaseWithName(TEST_DB_NAME, txn); + catalog->DropDatabaseWithName(txn, TEST_DB_NAME); txn_manager.CommitTransaction(txn); } } // namespace test diff --git a/test/executor/insert_test.cpp b/test/executor/insert_test.cpp index 489b871121d..a76050b3e53 100644 --- a/test/executor/insert_test.cpp +++ b/test/executor/insert_test.cpp @@ -48,16 +48,21 @@ TEST_F(InsertTests, InsertRecord) { std::unique_ptr table_schema( new catalog::Schema({id_column, name_column})); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateTable( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "TEST_TABLE", - std::move(table_schema), txn); - - auto table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "TEST_TABLE", txn); + catalog::Catalog::GetInstance()->CreateTable(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + "TEST_TABLE", + false); + + auto table = catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "TEST_TABLE"); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); @@ -141,7 +146,7 @@ TEST_F(InsertTests, InsertRecord) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/executor/testing_executor_util.cpp b/test/executor/testing_executor_util.cpp index 455cf33e5e7..eeb9c88095d 100644 --- a/test/executor/testing_executor_util.cpp +++ b/test/executor/testing_executor_util.cpp @@ -52,9 +52,9 @@ storage::Database *TestingExecutorUtil::InitializeDatabase( auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - auto result = catalog->CreateDatabase(db_name, txn); + auto result = catalog->CreateDatabase(txn, db_name); EXPECT_EQ(ResultType::SUCCESS, result); - auto database = catalog->GetDatabaseWithName(db_name, txn); + auto database = catalog->GetDatabaseWithName(txn, db_name); txn_manager.CommitTransaction(txn); return (database); } @@ -63,7 +63,7 @@ void TestingExecutorUtil::DeleteDatabase(const std::string &db_name) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - auto result = catalog->DropDatabaseWithName(db_name, txn); + auto result = catalog->DropDatabaseWithName(txn, db_name); txn_manager.CommitTransaction(txn); EXPECT_EQ(ResultType::SUCCESS, result); } @@ -433,14 +433,18 @@ storage::DataTable *TestingExecutorUtil::CreateTableUpdateCatalog( auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); // Insert table in catalog - catalog->CreateTable(db_name, DEFAULT_SCHEMA_NAME, table_name, - std::move(table_schema), txn, is_catalog, + catalog->CreateTable(txn, + db_name, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + table_name, + is_catalog, tuples_per_tilegroup_count); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); auto table = - catalog->GetTableWithName(db_name, DEFAULT_SCHEMA_NAME, table_name, txn); + catalog->GetTableWithName(txn, db_name, DEFAULT_SCHEMA_NAME, table_name); txn_manager.CommitTransaction(txn); return table; diff --git a/test/executor/update_test.cpp b/test/executor/update_test.cpp index faa5526efea..80cbc4bce7c 100644 --- a/test/executor/update_test.cpp +++ b/test/executor/update_test.cpp @@ -159,7 +159,7 @@ TEST_F(UpdateTests, UpdatingOld) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); LOG_INFO("Bootstrapping completed!"); std::unique_ptr optimizer( @@ -193,8 +193,10 @@ TEST_F(UpdateTests, UpdatingOld) { LOG_INFO("Table created!"); - storage::DataTable *table = catalog->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", txn); + storage::DataTable *table = catalog->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "department_table"); txn_manager.CommitTransaction(txn); // Inserting a tuple end-to-end @@ -420,7 +422,7 @@ TEST_F(UpdateTests, UpdatingOld) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } } // namespace diff --git a/test/function/functions_test.cpp b/test/function/functions_test.cpp index 25b56ab5823..a20d24c40fa 100644 --- a/test/function/functions_test.cpp +++ b/test/function/functions_test.cpp @@ -44,23 +44,23 @@ TEST_F(FunctionsTests, CatalogTest) { auto &pg_language = catalog::LanguageCatalog::GetInstance(); // Test "internal" language auto txn = txn_manager.BeginTransaction(); - auto internal_lang = pg_language.GetLanguageByName("internal", txn); + auto internal_lang = pg_language.GetLanguageByName(txn, "internal"); EXPECT_NE(nullptr, internal_lang); - internal_lang = pg_language.GetLanguageByOid(internal_lang->GetOid(), txn); + internal_lang = pg_language.GetLanguageByOid(txn, internal_lang->GetOid()); EXPECT_NE(nullptr, internal_lang); EXPECT_EQ("internal", internal_lang->GetName()); // test add/del language type::EphemeralPool pool; std::string lanname = "foo_lang"; - pg_language.InsertLanguage(lanname, &pool, txn); - auto inserted_lang = pg_language.GetLanguageByName(lanname, txn); + pg_language.InsertLanguage(txn, lanname, &pool); + auto inserted_lang = pg_language.GetLanguageByName(txn, lanname); EXPECT_NE(nullptr, inserted_lang); - inserted_lang = pg_language.GetLanguageByOid(inserted_lang->GetOid(), txn); + inserted_lang = pg_language.GetLanguageByOid(txn, inserted_lang->GetOid()); EXPECT_NE(nullptr, inserted_lang); EXPECT_EQ(lanname, inserted_lang->GetName()); - pg_language.DeleteLanguage(lanname, txn); - inserted_lang = pg_language.GetLanguageByName(lanname, txn); + pg_language.DeleteLanguage(txn, lanname); + inserted_lang = pg_language.GetLanguageByName(txn, lanname); EXPECT_EQ(nullptr, inserted_lang); txn_manager.CommitTransaction(txn); @@ -72,11 +72,16 @@ TEST_F(FunctionsTests, CatalogTest) { std::vector arg_types{type::TypeId::VARCHAR, type::TypeId::INTEGER}; - catalog->AddBuiltinFunction( - func_name, arg_types, type::TypeId::INTEGER, internal_lang->GetOid(), - "TestFunc", function::BuiltInFuncType{OperatorId::Add, TestFunc}, txn); + catalog->AddBuiltinFunction(txn, + func_name, + function::BuiltInFuncType{OperatorId::Add, + TestFunc}, + "TestFunc", + type::TypeId::INTEGER, + arg_types, + internal_lang->GetOid()); - auto inserted_proc = pg_proc.GetProcByName(func_name, arg_types, txn); + auto inserted_proc = pg_proc.GetProcByName(txn, func_name, arg_types); EXPECT_NE(nullptr, inserted_proc); EXPECT_EQ(internal_lang->GetOid(), inserted_proc->GetLangOid()); type::TypeId ret_type = inserted_proc->GetRetType(); @@ -94,7 +99,7 @@ TEST_F(FunctionsTests, CatalogTest) { TEST_F(FunctionsTests, FuncCallTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); TestingSQLUtil::ExecuteSQLQuery( @@ -123,14 +128,14 @@ TEST_F(FunctionsTests, FuncCallTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(FunctionsTests, SubstrFuncCallTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); TestingSQLUtil::ExecuteSQLQuery("CREATE TABLE test(a DECIMAL, s VARCHAR);"); @@ -148,7 +153,7 @@ TEST_F(FunctionsTests, SubstrFuncCallTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/gc/garbage_collection_test.cpp b/test/gc/garbage_collection_test.cpp index d3b24b878fc..886131e5fb0 100644 --- a/test/gc/garbage_collection_test.cpp +++ b/test/gc/garbage_collection_test.cpp @@ -200,7 +200,8 @@ TEST_F(GarbageCollectionTests, UpdateTest) { TestingExecutorUtil::DeleteDatabase("update_db"); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - EXPECT_THROW(catalog::Catalog::GetInstance()->GetDatabaseObject(db_id, txn), + EXPECT_THROW(catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, + db_id), CatalogException); txn_manager.CommitTransaction(txn); // EXPECT_FALSE(storage_manager->HasDatabase(db_id)); @@ -299,7 +300,7 @@ TEST_F(GarbageCollectionTests, DeleteTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); EXPECT_THROW( - catalog::Catalog::GetInstance()->GetDatabaseObject("DATABASE0", txn), + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, "DATABASE0"), CatalogException); txn_manager.CommitTransaction(txn); // EXPECT_FALSE(storage_manager->HasDatabase(db_id)); diff --git a/test/gc/transaction_level_gc_manager_test.cpp b/test/gc/transaction_level_gc_manager_test.cpp index cef62e0cf73..e574f5bd4d8 100644 --- a/test/gc/transaction_level_gc_manager_test.cpp +++ b/test/gc/transaction_level_gc_manager_test.cpp @@ -205,7 +205,7 @@ TEST_F(TransactionLevelGCManagerTests, UpdateDeleteTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); EXPECT_THROW( - catalog::Catalog::GetInstance()->GetDatabaseObject("database0", txn), + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, "database0"), CatalogException); txn_manager.CommitTransaction(txn); // EXPECT_FALSE(storage_manager->HasDatabase(db_id)); @@ -368,7 +368,7 @@ TEST_F(TransactionLevelGCManagerTests, ReInsertTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); EXPECT_THROW( - catalog::Catalog::GetInstance()->GetDatabaseObject("database0", txn), + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, "database0"), CatalogException); txn_manager.CommitTransaction(txn); // EXPECT_FALSE(storage_manager->HasDatabase(db_id)); @@ -481,7 +481,8 @@ TEST_F(TransactionLevelGCManagerTests, ImmutabilityTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); EXPECT_THROW( - catalog::Catalog::GetInstance()->GetDatabaseObject("immutabilitydb", txn), + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, + "immutabilitydb"), CatalogException); txn_manager.CommitTransaction(txn); } diff --git a/test/include/catalog/testing_constraints_util.h b/test/include/catalog/testing_constraints_util.h index 1c96b995fa9..ab39e311bd1 100644 --- a/test/include/catalog/testing_constraints_util.h +++ b/test/include/catalog/testing_constraints_util.h @@ -116,7 +116,7 @@ class TestingConstraintsUtil { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // First populate the list of catalog::Columns that we @@ -132,14 +132,14 @@ class TestingConstraintsUtil { // Create table. txn = txn_manager.BeginTransaction(); auto result = - catalog->CreateTable(DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, table_name, - std::move(table_schema), txn, false); + catalog->CreateTable(txn, DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, + std::move(table_schema), table_name, false); txn_manager.CommitTransaction(txn); EXPECT_EQ(ResultType::SUCCESS, result); txn = txn_manager.BeginTransaction(); - auto table = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, - table_name, txn); + auto table = catalog->GetTableWithName(txn, DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, + table_name); txn_manager.CommitTransaction(txn); EXPECT_NE(nullptr, table); diff --git a/test/optimizer/old_optimizer_test.cpp b/test/optimizer/old_optimizer_test.cpp index 92949cc8521..348c5bbdf52 100644 --- a/test/optimizer/old_optimizer_test.cpp +++ b/test/optimizer/old_optimizer_test.cpp @@ -44,7 +44,7 @@ TEST_F(OldOptimizerTests, UpdateDelWithIndexScanTest) { LOG_TRACE("Bootstrapping..."); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_TRACE("Bootstrapping completed!"); @@ -170,8 +170,10 @@ TEST_F(OldOptimizerTests, UpdateDelWithIndexScanTest) { traffic_cop.CommitQueryHelper(); txn = txn_manager.BeginTransaction(); - auto target_table_ = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", txn); + auto target_table_ = catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "department_table"); // Expected 1 , Primary key index + created index EXPECT_EQ(target_table_->GetIndexCount(), 2); txn_manager.CommitTransaction(txn); @@ -247,7 +249,7 @@ TEST_F(OldOptimizerTests, UpdateDelWithIndexScanTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/optimizer/operator_transformer_test.cpp b/test/optimizer/operator_transformer_test.cpp index f1d5229798c..b1b466991f0 100644 --- a/test/optimizer/operator_transformer_test.cpp +++ b/test/optimizer/operator_transformer_test.cpp @@ -39,7 +39,7 @@ class OperatorTransformerTests : public PelotonTest { // Create test database auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create table @@ -94,7 +94,7 @@ class OperatorTransformerTests : public PelotonTest { // Destroy test database auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Call parent virtual function diff --git a/test/optimizer/optimizer_test.cpp b/test/optimizer/optimizer_test.cpp index 50696017bb5..f1ffd6add66 100644 --- a/test/optimizer/optimizer_test.cpp +++ b/test/optimizer/optimizer_test.cpp @@ -61,7 +61,7 @@ class OptimizerTests : public PelotonTest { // Destroy test database auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Call parent virtual function @@ -75,7 +75,7 @@ TEST_F(OptimizerTests, HashJoinTest) { LOG_INFO("Bootstrapping..."); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_INFO("Bootstrapping completed!"); @@ -125,7 +125,7 @@ TEST_F(OptimizerTests, HashJoinTest) { oid_t expected_table_count = CATALOG_TABLES_COUNT + 1; txn = txn_manager.BeginTransaction(); EXPECT_EQ(catalog::Catalog::GetInstance() - ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) + ->GetDatabaseWithName(txn, DEFAULT_DB_NAME) ->GetTableCount(), expected_table_count); @@ -162,7 +162,7 @@ TEST_F(OptimizerTests, HashJoinTest) { expected_table_count++; txn = txn_manager.BeginTransaction(); EXPECT_EQ(catalog::Catalog::GetInstance() - ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) + ->GetDatabaseWithName(txn, DEFAULT_DB_NAME) ->GetTableCount(), expected_table_count); @@ -261,7 +261,7 @@ TEST_F(OptimizerTests, HashJoinTest) { TEST_F(OptimizerTests, PredicatePushDownTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); TestingSQLUtil::ExecuteSQLQuery( @@ -315,7 +315,7 @@ TEST_F(OptimizerTests, PredicatePushDownTest) { TEST_F(OptimizerTests, PushFilterThroughJoinTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); TestingSQLUtil::ExecuteSQLQuery( @@ -397,7 +397,7 @@ TEST_F(OptimizerTests, PushFilterThroughJoinTest) { TEST_F(OptimizerTests, PredicatePushDownRewriteTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); TestingSQLUtil::ExecuteSQLQuery( @@ -479,7 +479,7 @@ TEST_F(OptimizerTests, ExecuteTaskStackTest) { // Currently need database for test teardown auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); const auto num_tasks = 2; diff --git a/test/optimizer/selectivity_test.cpp b/test/optimizer/selectivity_test.cpp index cbb8df08d2c..6794fa29b9f 100644 --- a/test/optimizer/selectivity_test.cpp +++ b/test/optimizer/selectivity_test.cpp @@ -56,7 +56,7 @@ void ExpectSelectivityEqual(double actual, double expected, TEST_F(SelectivityTests, RangeSelectivityTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -71,9 +71,11 @@ TEST_F(SelectivityTests, RangeSelectivityTest) { txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); - auto database = catalog->GetDatabaseWithName(DEFAULT_DB_NAME, txn); - auto table = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, - TEST_TABLE_NAME, txn); + auto database = catalog->GetDatabaseWithName(txn, DEFAULT_DB_NAME); + auto table = catalog->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + TEST_TABLE_NAME); txn_manager.CommitTransaction(txn); oid_t db_id = database->GetOid(); oid_t table_id = table->GetOid(); @@ -109,7 +111,7 @@ TEST_F(SelectivityTests, RangeSelectivityTest) { // Free the database txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -165,7 +167,7 @@ TEST_F(SelectivityTests, LikeSelectivityTest) { TEST_F(SelectivityTests, EqualSelectivityTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -180,9 +182,11 @@ TEST_F(SelectivityTests, EqualSelectivityTest) { txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); - auto database = catalog->GetDatabaseWithName(DEFAULT_DB_NAME, txn); - auto table = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, - TEST_TABLE_NAME, txn); + auto database = catalog->GetDatabaseWithName(txn, DEFAULT_DB_NAME); + auto table = catalog->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + TEST_TABLE_NAME); txn_manager.CommitTransaction(txn); oid_t db_id = database->GetOid(); oid_t table_id = table->GetOid(); @@ -258,7 +262,7 @@ TEST_F(SelectivityTests, EqualSelectivityTest) { // Free the database txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/optimizer/table_stats_collector_test.cpp b/test/optimizer/table_stats_collector_test.cpp index e98f1a54bf9..fcce0079777 100644 --- a/test/optimizer/table_stats_collector_test.cpp +++ b/test/optimizer/table_stats_collector_test.cpp @@ -48,7 +48,7 @@ TEST_F(TableStatsCollectorTests, SingleColumnTableTest) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); TestingSQLUtil::ExecuteSQLQuery("CREATE TABLE test(id integer);"); @@ -60,8 +60,10 @@ TEST_F(TableStatsCollectorTests, SingleColumnTableTest) { } txn = txn_manager.BeginTransaction(); - auto table = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, - "test", txn); + auto table = catalog->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "test"); txn_manager.CommitTransaction(txn); TableStatsCollector stats{table}; stats.CollectColumnStats(); @@ -80,7 +82,7 @@ TEST_F(TableStatsCollectorTests, SingleColumnTableTest) { // Free the database txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -91,7 +93,7 @@ TEST_F(TableStatsCollectorTests, MultiColumnTableTest) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); TestingSQLUtil::ExecuteSQLQuery( @@ -111,8 +113,10 @@ TEST_F(TableStatsCollectorTests, MultiColumnTableTest) { } txn = txn_manager.BeginTransaction(); - auto table = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, - "test", txn); + auto table = catalog->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "test"); txn_manager.CommitTransaction(txn); TableStatsCollector stats{table}; stats.CollectColumnStats(); @@ -141,7 +145,7 @@ TEST_F(TableStatsCollectorTests, MultiColumnTableTest) { // Free the database txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/optimizer/tuple_samples_storage_test.cpp b/test/optimizer/tuple_samples_storage_test.cpp index 72ed769f270..62e2b595d95 100644 --- a/test/optimizer/tuple_samples_storage_test.cpp +++ b/test/optimizer/tuple_samples_storage_test.cpp @@ -46,7 +46,7 @@ TEST_F(TupleSamplesStorageTests, SamplesDBTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); storage::Database *samples_db = - catalog->GetDatabaseWithName(SAMPLES_DB_NAME, txn); + catalog->GetDatabaseWithName(txn, SAMPLES_DB_NAME); txn_manager.CommitTransaction(txn); EXPECT_TRUE(samples_db != nullptr); EXPECT_EQ(samples_db->GetDBName(), SAMPLES_DB_NAME); @@ -84,8 +84,10 @@ TEST_F(TupleSamplesStorageTests, AddSamplesTableTest) { tuple_samples_storage->GenerateSamplesTableName( data_table->GetDatabaseOid(), data_table->GetOid()); txn = txn_manager.BeginTransaction(); - storage::DataTable *samples_table = catalog->GetTableWithName( - SAMPLES_DB_NAME, DEFAULT_SCHEMA_NAME, samples_table_name, txn); + storage::DataTable *samples_table = catalog->GetTableWithName(txn, + SAMPLES_DB_NAME, + DEFAULT_SCHEMA_NAME, + samples_table_name); txn_manager.CommitTransaction(txn); EXPECT_TRUE(samples_table != nullptr); diff --git a/test/planner/plan_util_test.cpp b/test/planner/plan_util_test.cpp index 77df6f54e88..6130d29d260 100644 --- a/test/planner/plan_util_test.cpp +++ b/test/planner/plan_util_test.cpp @@ -39,7 +39,7 @@ TEST_F(PlanUtilTests, GetAffectedIndexesTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(TEST_DB_NAME, txn); + catalog->CreateDatabase(txn, TEST_DB_NAME); // Insert a table first auto id_column = catalog::Column( type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER), @@ -54,10 +54,16 @@ TEST_F(PlanUtilTests, GetAffectedIndexesTest) { txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "test_table", - std::move(table_schema), txn); - auto source_table = catalog->GetTableWithName( - TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "test_table", txn); + catalog->CreateTable(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + "test_table", + false); + auto source_table = catalog->GetTableWithName(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + "test_table"); EXPECT_NE(source_table, nullptr); txn_manager.CommitTransaction(txn); @@ -67,35 +73,45 @@ TEST_F(PlanUtilTests, GetAffectedIndexesTest) { source_col_ids.push_back(col_id); // create index on 'id' - catalog->CreateIndex(TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "test_table", - source_col_ids, "test_id_idx", false, IndexType::BWTREE, - txn); + catalog->CreateIndex(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + "test_table", + "test_id_idx", + source_col_ids, + false, + IndexType::BWTREE); // create index on 'id' and 'first_name' col_id = source_table->GetSchema()->GetColumnID(fname_column.column_name); source_col_ids.push_back(col_id); - catalog->CreateIndex(TEST_DB_NAME, DEFAULT_SCHEMA_NAME, "test_table", - source_col_ids, "test_fname_idx", false, - IndexType::BWTREE, txn); + catalog->CreateIndex(txn, + TEST_DB_NAME, + DEFAULT_SCHEMA_NAME, + "test_table", + "test_fname_idx", + source_col_ids, + false, + IndexType::BWTREE); txn_manager.CommitTransaction(txn); // dummy txn to get the catalog_cache object txn = txn_manager.BeginTransaction(); // This is also required so that database objects are cached - auto db_object = catalog->GetDatabaseObject(TEST_DB_NAME, txn); + auto db_object = catalog->GetDatabaseCatalogEntry(txn, TEST_DB_NAME); // Till now, we have a table : id, first_name, last_name // And two indexes on following columns: // 1) id // 2) id and first_name auto table_object = - db_object->GetTableObject("test_table", DEFAULT_SCHEMA_NAME); + db_object->GetTableCatalogEntry("test_table", DEFAULT_SCHEMA_NAME); EXPECT_NE(table_object, nullptr); - oid_t id_idx_oid = table_object->GetIndexObject("test_id_idx")->GetIndexOid(); + oid_t id_idx_oid = table_object->GetIndexCatalogEntry("test_id_idx")->GetIndexOid(); oid_t fname_idx_oid = - table_object->GetIndexObject("test_fname_idx")->GetIndexOid(); + table_object->GetIndexCatalogEntry("test_fname_idx")->GetIndexOid(); // An update query affecting both indexes std::string query_string = "UPDATE test_table SET id = 0;"; @@ -178,11 +194,11 @@ TEST_F(PlanUtilTests, GetIndexableColumnsTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(TEST_DB_COLUMNS, txn); - auto db = catalog->GetDatabaseWithName(TEST_DB_COLUMNS, txn); + catalog->CreateDatabase(txn, TEST_DB_COLUMNS); + auto db = catalog->GetDatabaseWithName(txn, TEST_DB_COLUMNS); oid_t database_id = db->GetOid(); - auto db_object = catalog->GetDatabaseObject(TEST_DB_COLUMNS, txn); - int table_count = db_object->GetTableObjects().size(); + auto db_object = catalog->GetDatabaseCatalogEntry(txn, TEST_DB_COLUMNS); + int table_count = db_object->GetTableCatalogEntries().size(); txn_manager.CommitTransaction(txn); // Insert a 'test_table' with 'id', 'first_name' and 'last_name' @@ -198,14 +214,20 @@ TEST_F(PlanUtilTests, GetIndexableColumnsTest) { new catalog::Schema({id_column, fname_column, lname_column})); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_COLUMNS, DEFAULT_SCHEMA_NAME, "test_table", - std::move(table_schema), txn); + catalog->CreateTable(txn, + TEST_DB_COLUMNS, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + "test_table", + false); txn_manager.CommitTransaction(txn); // Obtain ids for the table and columns txn = txn_manager.BeginTransaction(); - auto source_table = catalog->GetTableWithName( - TEST_DB_COLUMNS, DEFAULT_SCHEMA_NAME, "test_table", txn); + auto source_table = catalog->GetTableWithName(txn, + TEST_DB_COLUMNS, + DEFAULT_SCHEMA_NAME, + "test_table"); txn_manager.CommitTransaction(txn); oid_t table_id = source_table->GetOid(); @@ -228,14 +250,20 @@ TEST_F(PlanUtilTests, GetIndexableColumnsTest) { std::unique_ptr job_table_schema( new catalog::Schema({age_column, job_column, pid_column})); - catalog->CreateTable(TEST_DB_COLUMNS, DEFAULT_SCHEMA_NAME, "test_table_job", - std::move(job_table_schema), txn); + catalog->CreateTable(txn, + TEST_DB_COLUMNS, + DEFAULT_SCHEMA_NAME, + std::move(job_table_schema), + "test_table_job", + false); txn_manager.CommitTransaction(txn); // Obtain ids for the table and columns txn = txn_manager.BeginTransaction(); - auto source_table_job = catalog->GetTableWithName( - TEST_DB_COLUMNS, DEFAULT_SCHEMA_NAME, "test_table_job", txn); + auto source_table_job = catalog->GetTableWithName(txn, + TEST_DB_COLUMNS, + DEFAULT_SCHEMA_NAME, + "test_table_job"); oid_t table_job_id = source_table_job->GetOid(); oid_t age_col_oid = source_table_job->GetSchema()->GetColumnID(age_column.column_name); @@ -247,9 +275,9 @@ TEST_F(PlanUtilTests, GetIndexableColumnsTest) { txn = txn_manager.BeginTransaction(); // This is required so that database objects are cached - db_object = catalog->GetDatabaseObject(TEST_DB_COLUMNS, txn); + db_object = catalog->GetDatabaseCatalogEntry(txn, TEST_DB_COLUMNS); EXPECT_EQ( - 2, static_cast(db_object->GetTableObjects().size()) - table_count); + 2, static_cast(db_object->GetTableCatalogEntries().size()) - table_count); // ====== UPDATE statements check === // id and first_name in test_table are affected diff --git a/test/planner/planner_equality_test.cpp b/test/planner/planner_equality_test.cpp index fe109bc9dff..dbb9feb6c58 100644 --- a/test/planner/planner_equality_test.cpp +++ b/test/planner/planner_equality_test.cpp @@ -35,7 +35,7 @@ class PlannerEqualityTest : public PelotonTest { // Destroy test database auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Call parent virtual function @@ -46,7 +46,7 @@ class PlannerEqualityTest : public PelotonTest { // Create database auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create a table 'test' diff --git a/test/planner/planner_test.cpp b/test/planner/planner_test.cpp index 5fd1709eaca..19304048dd9 100644 --- a/test/planner/planner_test.cpp +++ b/test/planner/planner_test.cpp @@ -72,7 +72,7 @@ TEST_F(PlannerTest, DeletePlanTestParameter) { // Bootstrapping peloton auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create table @@ -84,9 +84,12 @@ TEST_F(PlannerTest, DeletePlanTestParameter) { std::unique_ptr table_schema( new catalog::Schema({id_column, name_column})); - catalog::Catalog::GetInstance()->CreateTable( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", - std::move(table_schema), txn); + catalog::Catalog::GetInstance()->CreateTable(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + "department_table", + false); txn_manager.CommitTransaction(txn); // DELETE FROM department_table WHERE id = $0 @@ -99,8 +102,10 @@ TEST_F(PlannerTest, DeletePlanTestParameter) { auto *scan_expr = new expression::ComparisonExpression( ExpressionType::COMPARE_EQUAL, tuple_expr, parameter_expr); - auto target_table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", txn); + auto target_table = catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "department_table"); // Create delete plan std::unique_ptr delete_plan( @@ -128,7 +133,7 @@ TEST_F(PlannerTest, DeletePlanTestParameter) { delete_plan->SetParameterValues(&values); // free the database just created - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -136,7 +141,7 @@ TEST_F(PlannerTest, UpdatePlanTestParameter) { // Bootstrapping peloton auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create table @@ -148,9 +153,12 @@ TEST_F(PlannerTest, UpdatePlanTestParameter) { std::unique_ptr table_schema( new catalog::Schema({id_column, name_column})); - catalog::Catalog::GetInstance()->CreateTable( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", - std::move(table_schema), txn); + catalog::Catalog::GetInstance()->CreateTable(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + "department_table", + false); txn_manager.CommitTransaction(txn); // UPDATE department_table SET name = $0 WHERE id = $1 @@ -158,8 +166,10 @@ TEST_F(PlannerTest, UpdatePlanTestParameter) { auto table_name = std::string("department_table"); auto database_name = DEFAULT_DB_NAME; - auto target_table = catalog::Catalog::GetInstance()->GetTableWithName( - database_name, DEFAULT_SCHEMA_NAME, table_name, txn); + auto target_table = catalog::Catalog::GetInstance()->GetTableWithName(txn, + database_name, + DEFAULT_SCHEMA_NAME, + table_name); auto schema = target_table->GetSchema(); TargetList tlist; @@ -225,7 +235,7 @@ TEST_F(PlannerTest, UpdatePlanTestParameter) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -233,7 +243,7 @@ TEST_F(PlannerTest, InsertPlanTestParameter) { // Bootstrapping peloton auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create table @@ -245,9 +255,12 @@ TEST_F(PlannerTest, InsertPlanTestParameter) { std::unique_ptr table_schema( new catalog::Schema({id_column, name_column})); - auto ret = catalog::Catalog::GetInstance()->CreateTable( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", - std::move(table_schema), txn); + auto ret = catalog::Catalog::GetInstance()->CreateTable(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + "department_table", + false); if (ret != ResultType::SUCCESS) LOG_TRACE("create table failed"); txn_manager.CommitTransaction(txn); @@ -275,8 +288,10 @@ TEST_F(PlannerTest, InsertPlanTestParameter) { parameter_exprs.push_back( std::unique_ptr(parameter_expr_2)); - auto target_table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", txn); + auto target_table = catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "department_table"); std::unique_ptr insert_plan( new planner::InsertPlan(target_table, &insert_statement->columns, @@ -299,7 +314,7 @@ TEST_F(PlannerTest, InsertPlanTestParameter) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -307,7 +322,7 @@ TEST_F(PlannerTest, InsertPlanTestParameterColumns) { // Bootstrapping peloton auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create table @@ -319,9 +334,12 @@ TEST_F(PlannerTest, InsertPlanTestParameterColumns) { std::unique_ptr table_schema( new catalog::Schema({id_column, name_column})); - catalog::Catalog::GetInstance()->CreateTable( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", - std::move(table_schema), txn); + catalog::Catalog::GetInstance()->CreateTable(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::move(table_schema), + "department_table", + false); txn_manager.CommitTransaction(txn); // INSERT INTO department_table VALUES (1, $1) @@ -353,8 +371,10 @@ TEST_F(PlannerTest, InsertPlanTestParameterColumns) { exprs.push_back( std::unique_ptr(parameter_expr_2)); - auto target_table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", txn); + auto target_table = catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "department_table"); std::unique_ptr insert_plan( new planner::InsertPlan(target_table, &insert_statement->columns, @@ -375,7 +395,7 @@ TEST_F(PlannerTest, InsertPlanTestParameterColumns) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/settings/settings_manager_test.cpp b/test/settings/settings_manager_test.cpp index e9e00162259..251b057648a 100644 --- a/test/settings/settings_manager_test.cpp +++ b/test/settings/settings_manager_test.cpp @@ -35,7 +35,7 @@ TEST_F(SettingsManagerTests, InitializationTest) { auto txn = txn_manager.BeginTransaction(); int32_t port = settings::SettingsManager::GetInt(settings::SettingId::port); int32_t port_default = - atoi(settings_catalog.GetDefaultValue("port", txn).c_str()); + atoi(settings_catalog.GetDefaultValue(txn, "port").c_str()); txn_manager.CommitTransaction(txn); EXPECT_EQ(port, port_default); @@ -44,7 +44,7 @@ TEST_F(SettingsManagerTests, InitializationTest) { std::string socket_family = settings::SettingsManager::GetString(settings::SettingId::socket_family); std::string socket_family_default = - settings_catalog.GetDefaultValue("socket_family", txn); + settings_catalog.GetDefaultValue(txn, "socket_family"); txn_manager.CommitTransaction(txn); EXPECT_EQ(socket_family, socket_family_default); @@ -53,7 +53,7 @@ TEST_F(SettingsManagerTests, InitializationTest) { bool index_tuner = settings::SettingsManager::GetBool(settings::SettingId::index_tuner); bool index_tuner_default = - ("true" == settings_catalog.GetDefaultValue("index_tuner", txn)); + ("true" == settings_catalog.GetDefaultValue(txn, "index_tuner")); txn_manager.CommitTransaction(txn); EXPECT_EQ(index_tuner, index_tuner_default); } @@ -71,7 +71,7 @@ TEST_F(SettingsManagerTests, ModificationTest) { // modify int auto txn = txn_manager.BeginTransaction(); int32_t value1 = settings::SettingsManager::GetInt(settings::SettingId::port); - int32_t value2 = atoi(settings_catalog.GetSettingValue("port", txn).c_str()); + int32_t value2 = atoi(settings_catalog.GetSettingValue(txn, "port").c_str()); EXPECT_EQ(value1, value2); txn_manager.CommitTransaction(txn); @@ -79,7 +79,7 @@ TEST_F(SettingsManagerTests, ModificationTest) { txn = txn_manager.BeginTransaction(); int32_t value3 = settings::SettingsManager::GetInt(settings::SettingId::port); - int32_t value4 = atoi(settings_catalog.GetSettingValue("port", txn).c_str()); + int32_t value4 = atoi(settings_catalog.GetSettingValue(txn, "port").c_str()); EXPECT_EQ(value3, 12345); EXPECT_EQ(value3, value4); txn_manager.CommitTransaction(txn); @@ -89,7 +89,7 @@ TEST_F(SettingsManagerTests, ModificationTest) { bool value5 = settings::SettingsManager::GetBool(settings::SettingId::index_tuner); bool value6 = - ("true" == settings_catalog.GetSettingValue("index_tuner", txn)); + ("true" == settings_catalog.GetSettingValue(txn, "index_tuner")); EXPECT_EQ(value5, value6); txn_manager.CommitTransaction(txn); @@ -99,7 +99,7 @@ TEST_F(SettingsManagerTests, ModificationTest) { bool value7 = settings::SettingsManager::GetBool(settings::SettingId::index_tuner); bool value8 = - ("true" == settings_catalog.GetSettingValue("index_tuner", txn)); + ("true" == settings_catalog.GetSettingValue(txn, "index_tuner")); EXPECT_TRUE(value7); EXPECT_EQ(value7, value8); txn_manager.CommitTransaction(txn); @@ -108,7 +108,7 @@ TEST_F(SettingsManagerTests, ModificationTest) { txn = txn_manager.BeginTransaction(); std::string value9 = settings::SettingsManager::GetString(settings::SettingId::socket_family); - std::string value10 = settings_catalog.GetSettingValue("socket_family", txn); + std::string value10 = settings_catalog.GetSettingValue(txn, "socket_family"); EXPECT_EQ(value9, value10); txn_manager.CommitTransaction(txn); @@ -118,7 +118,7 @@ TEST_F(SettingsManagerTests, ModificationTest) { txn = txn_manager.BeginTransaction(); std::string value11 = settings::SettingsManager::GetString(settings::SettingId::socket_family); - std::string value12 = settings_catalog.GetSettingValue("socket_family", txn); + std::string value12 = settings_catalog.GetSettingValue(txn, "socket_family"); EXPECT_EQ(value11, "test"); EXPECT_EQ(value11, value12); txn_manager.CommitTransaction(txn); diff --git a/test/sql/aggregate_groupby_sql_test.cpp b/test/sql/aggregate_groupby_sql_test.cpp index 527ede393ca..198156cc6b7 100644 --- a/test/sql/aggregate_groupby_sql_test.cpp +++ b/test/sql/aggregate_groupby_sql_test.cpp @@ -42,7 +42,7 @@ class AggregateGroupBySQLTests : public PelotonTest { TEST_F(AggregateGroupBySQLTests, AggregateGroupByManyAVGsSQLTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -53,14 +53,14 @@ TEST_F(AggregateGroupBySQLTests, AggregateGroupByManyAVGsSQLTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(AggregateGroupBySQLTests, AggregateGroupByMixedAVGsSQLTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -73,14 +73,14 @@ TEST_F(AggregateGroupBySQLTests, AggregateGroupByMixedAVGsSQLTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(AggregateGroupBySQLTests, AggregateGroupByAllAggregationsSQLTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -91,14 +91,14 @@ TEST_F(AggregateGroupBySQLTests, AggregateGroupByAllAggregationsSQLTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(AggregateGroupBySQLTests, AggregateGroupBySingleRowPerGroupSQLTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -110,7 +110,7 @@ TEST_F(AggregateGroupBySQLTests, AggregateGroupBySingleRowPerGroupSQLTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/aggregate_sql_test.cpp b/test/sql/aggregate_sql_test.cpp index 62fcaddea8a..d240b72da3e 100644 --- a/test/sql/aggregate_sql_test.cpp +++ b/test/sql/aggregate_sql_test.cpp @@ -29,7 +29,7 @@ TEST_F(AggregateSQLTests, EmptyTableTest) { PELOTON_ASSERT(&TestingSQLUtil::traffic_cop_); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create a table first @@ -200,7 +200,7 @@ TEST_F(AggregateSQLTests, MinMaxTest) { // free the database just created auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_DEBUG("Finish test"); } diff --git a/test/sql/analyze_sql_test.cpp b/test/sql/analyze_sql_test.cpp index 16191ec000d..2504b839342 100644 --- a/test/sql/analyze_sql_test.cpp +++ b/test/sql/analyze_sql_test.cpp @@ -44,7 +44,7 @@ void CreateAndLoadTable() { TEST_F(AnalyzeSQLTests, AnalyzeAllTablesTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -54,14 +54,14 @@ TEST_F(AnalyzeSQLTests, AnalyzeAllTablesTest) { // Free the database txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(AnalyzeSQLTests, AnalyzeSingleTableTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -74,20 +74,22 @@ TEST_F(AnalyzeSQLTests, AnalyzeSingleTableTest) { txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); storage::DataTable *db_column_stats_collector_table = - catalog->GetTableWithName(CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, - COLUMN_STATS_CATALOG_NAME, txn); + catalog->GetTableWithName(txn, + CATALOG_DATABASE_NAME, + CATALOG_SCHEMA_NAME, + COLUMN_STATS_CATALOG_NAME); EXPECT_NE(db_column_stats_collector_table, nullptr); EXPECT_EQ(db_column_stats_collector_table->GetTupleCount(), 4); // Free the database - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(AnalyzeSQLTests, AnalyzeTableWithColumnsTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -97,7 +99,7 @@ TEST_F(AnalyzeSQLTests, AnalyzeTableWithColumnsTest) { // Free the database txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/case_sql_test.cpp b/test/sql/case_sql_test.cpp index 7fe464b2974..7d0078d1383 100644 --- a/test/sql/case_sql_test.cpp +++ b/test/sql/case_sql_test.cpp @@ -43,7 +43,7 @@ TEST_F(CaseSQLTests, Simple) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -72,7 +72,7 @@ TEST_F(CaseSQLTests, Simple) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -81,7 +81,7 @@ TEST_F(CaseSQLTests, SimpleWithArg) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -109,7 +109,7 @@ TEST_F(CaseSQLTests, SimpleWithArg) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -118,7 +118,7 @@ TEST_F(CaseSQLTests, SimpleWithArgStringResult) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -146,7 +146,7 @@ TEST_F(CaseSQLTests, SimpleWithArgStringResult) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -156,7 +156,7 @@ TEST_F(CaseSQLTests, SimpleMultipleWhen) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -184,7 +184,7 @@ TEST_F(CaseSQLTests, SimpleMultipleWhen) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -194,7 +194,7 @@ TEST_F(CaseSQLTests, SimpleMultipleWhenWithoutElse) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -222,7 +222,7 @@ TEST_F(CaseSQLTests, SimpleMultipleWhenWithoutElse) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/decimal_functions_sql_test.cpp b/test/sql/decimal_functions_sql_test.cpp index 850e075a62c..366d2b2f781 100644 --- a/test/sql/decimal_functions_sql_test.cpp +++ b/test/sql/decimal_functions_sql_test.cpp @@ -32,7 +32,7 @@ class DecimalSQLTestsBase : public PelotonTest { // Create database auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -50,7 +50,7 @@ class DecimalSQLTestsBase : public PelotonTest { // Destroy test database auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Call parent virtual function @@ -63,7 +63,7 @@ class DecimalFunctionsSQLTest : public PelotonTest {}; TEST_F(DecimalFunctionsSQLTest, FloorTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); catalog::Catalog::GetInstance()->Bootstrap(); txn_manager.CommitTransaction(txn); @@ -107,7 +107,7 @@ TEST_F(DecimalFunctionsSQLTest, FloorTest) { } // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -297,7 +297,7 @@ TEST_F(DecimalSQLTestsBase, DecimalAbsTest) { TEST_F(DecimalFunctionsSQLTest, CeilTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests // you can only call it once! // catalog::Catalog::GetInstance()->Bootstrap(); @@ -360,7 +360,7 @@ TEST_F(DecimalFunctionsSQLTest, CeilTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/delete_sql_test.cpp b/test/sql/delete_sql_test.cpp index 1648e0a3b1b..eefbc22ba1c 100644 --- a/test/sql/delete_sql_test.cpp +++ b/test/sql/delete_sql_test.cpp @@ -28,7 +28,7 @@ TEST_F(DeleteSQLTests, SimpleDeleteSQLTest) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_DEBUG("Bootstrapping completed!"); @@ -118,7 +118,7 @@ TEST_F(DeleteSQLTests, SimpleDeleteSQLTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/distinct_aggregate_sql_test.cpp b/test/sql/distinct_aggregate_sql_test.cpp index a48412e0b68..ae4ba2fc2e2 100644 --- a/test/sql/distinct_aggregate_sql_test.cpp +++ b/test/sql/distinct_aggregate_sql_test.cpp @@ -87,7 +87,7 @@ class DistinctAggregateSQLTests : public PelotonTest { TEST_F(DistinctAggregateSQLTests, DistinctAggregateCountTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -100,14 +100,14 @@ TEST_F(DistinctAggregateSQLTests, DistinctAggregateCountTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctAggregateSQLTests, DistinctAggregateMaxTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -120,14 +120,14 @@ TEST_F(DistinctAggregateSQLTests, DistinctAggregateMaxTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctAggregateSQLTests, DistinctAggregateMinTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -140,14 +140,14 @@ TEST_F(DistinctAggregateSQLTests, DistinctAggregateMinTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctAggregateSQLTests, DistinctAggregateAvgTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -159,14 +159,14 @@ TEST_F(DistinctAggregateSQLTests, DistinctAggregateAvgTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctAggregateSQLTests, DistinctAggregateSumTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -178,14 +178,14 @@ TEST_F(DistinctAggregateSQLTests, DistinctAggregateSumTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctAggregateSQLTests, DistinctAggregateGroupByCountTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -198,14 +198,14 @@ TEST_F(DistinctAggregateSQLTests, DistinctAggregateGroupByCountTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctAggregateSQLTests, DistinctAggregateGroupByMaxTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -220,14 +220,14 @@ TEST_F(DistinctAggregateSQLTests, DistinctAggregateGroupByMaxTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctAggregateSQLTests, DistinctAggregateGroupByMinTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -242,14 +242,14 @@ TEST_F(DistinctAggregateSQLTests, DistinctAggregateGroupByMinTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctAggregateSQLTests, DistinctAggregateGroupByAvgTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -261,14 +261,14 @@ TEST_F(DistinctAggregateSQLTests, DistinctAggregateGroupByAvgTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctAggregateSQLTests, DistinctAggregateGroupBySumTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -280,7 +280,7 @@ TEST_F(DistinctAggregateSQLTests, DistinctAggregateGroupBySumTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/distinct_sql_test.cpp b/test/sql/distinct_sql_test.cpp index d2bfa637ddf..86520d28474 100644 --- a/test/sql/distinct_sql_test.cpp +++ b/test/sql/distinct_sql_test.cpp @@ -81,7 +81,7 @@ class DistinctSQLTests : public PelotonTest { TEST_F(DistinctSQLTests, DistinctIntTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -91,14 +91,14 @@ TEST_F(DistinctSQLTests, DistinctIntTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctSQLTests, DistinctVarcharTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -108,14 +108,14 @@ TEST_F(DistinctSQLTests, DistinctVarcharTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctSQLTests, DistinctTupleTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -126,14 +126,14 @@ TEST_F(DistinctSQLTests, DistinctTupleTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctSQLTests, DistinctStarTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); TestingSQLUtil::ExecuteSQLQuery( @@ -153,14 +153,14 @@ TEST_F(DistinctSQLTests, DistinctStarTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DistinctSQLTests, DistinctDateTimeTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); TestingSQLUtil::ExecuteSQLQuery( @@ -180,7 +180,7 @@ TEST_F(DistinctSQLTests, DistinctDateTimeTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/drop_sql_test.cpp b/test/sql/drop_sql_test.cpp index 2e0dccc63f7..b541437ba71 100644 --- a/test/sql/drop_sql_test.cpp +++ b/test/sql/drop_sql_test.cpp @@ -29,7 +29,7 @@ class DropSQLTests : public PelotonTest {}; TEST_F(DropSQLTests, DropTableTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create a table first @@ -40,8 +40,10 @@ TEST_F(DropSQLTests, DropTableTest) { storage::DataTable *table; txn = txn_manager.BeginTransaction(); try { - table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "test", txn); + table = catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "test"); } catch (CatalogException &e) { table = nullptr; } @@ -76,8 +78,10 @@ TEST_F(DropSQLTests, DropTableTest) { // Check the table does not exist txn = txn_manager.BeginTransaction(); try { - table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "test", txn); + table = catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "test"); } catch (CatalogException &e) { txn_manager.CommitTransaction(txn); table = nullptr; @@ -86,16 +90,17 @@ TEST_F(DropSQLTests, DropTableTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(DropSQLTests, DropIndexTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); auto database_object = - catalog::Catalog::GetInstance()->GetDatabaseObject(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, + DEFAULT_DB_NAME); EXPECT_NE(nullptr, database_object); txn_manager.CommitTransaction(txn); @@ -111,11 +116,13 @@ TEST_F(DropSQLTests, DropIndexTest) { ->GetIndexCatalog(); EXPECT_NE(nullptr, pg_index); // Check if the index is in catalog - std::shared_ptr index; + std::shared_ptr index; txn = txn_manager.BeginTransaction(); try { - index = pg_index->GetIndexObject(database_object->GetDatabaseName(), - "idx", DEFAULT_SCHEMA_NAME, txn); + index = pg_index->GetIndexCatalogEntry(txn, + database_object->GetDatabaseName(), + DEFAULT_SCHEMA_NAME, + "idx"); } catch (CatalogException &e) { index = nullptr; @@ -129,12 +136,14 @@ TEST_F(DropSQLTests, DropIndexTest) { // Check if index is not in catalog txn = txn_manager.BeginTransaction(); - index = pg_index->GetIndexObject(database_object->GetDatabaseName(), - "idx", DEFAULT_SCHEMA_NAME, txn); + index = pg_index->GetIndexCatalogEntry(txn, + database_object->GetDatabaseName(), + DEFAULT_SCHEMA_NAME, + "idx"); EXPECT_EQ(index, nullptr); // Free the database just created - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/foreign_key_sql_test.cpp b/test/sql/foreign_key_sql_test.cpp index da29b9883b7..ade6ef7bc05 100644 --- a/test/sql/foreign_key_sql_test.cpp +++ b/test/sql/foreign_key_sql_test.cpp @@ -17,7 +17,7 @@ TEST_F(ForeignKeySQLTests, NoActionTest) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); TestingSQLUtil::ExecuteSQLQuery( @@ -43,7 +43,7 @@ TEST_F(ForeignKeySQLTests, NoActionTest) { "DELETE FROM tb1 WHERE id = 1;"), ResultType::SUCCESS); txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -51,7 +51,7 @@ TEST_F(ForeignKeySQLTests, CascadeTest) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); TestingSQLUtil::ExecuteSQLQuery( @@ -78,7 +78,7 @@ TEST_F(ForeignKeySQLTests, CascadeTest) { true); txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/index_scan_sql_test.cpp b/test/sql/index_scan_sql_test.cpp index a0d6df7e3ba..e6929118080 100644 --- a/test/sql/index_scan_sql_test.cpp +++ b/test/sql/index_scan_sql_test.cpp @@ -41,7 +41,7 @@ void CreateAndLoadTable() { TEST_F(IndexScanSQLTests, CreateIndexAfterInsertTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -65,14 +65,14 @@ TEST_F(IndexScanSQLTests, CreateIndexAfterInsertTest) { EXPECT_EQ("33", TestingSQLUtil::GetResultValueAsString(result, 1)); // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(IndexScanSQLTests, CreateIndexAfterInsertOnMultipleColumnsTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -96,14 +96,14 @@ TEST_F(IndexScanSQLTests, CreateIndexAfterInsertOnMultipleColumnsTest) { EXPECT_EQ("3", TestingSQLUtil::GetResultValueAsString(result, 1)); // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(IndexScanSQLTests, SQLTest) { LOG_INFO("Bootstrapping..."); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_INFO("Bootstrapping completed!"); @@ -227,7 +227,7 @@ TEST_F(IndexScanSQLTests, SQLTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/insert_sql_test.cpp b/test/sql/insert_sql_test.cpp index 74b767bfa5c..9d57ced992c 100644 --- a/test/sql/insert_sql_test.cpp +++ b/test/sql/insert_sql_test.cpp @@ -113,7 +113,7 @@ void CreateAndLoadTable8() { TEST_F(InsertSQLTests, InsertOneValue) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -149,14 +149,14 @@ TEST_F(InsertSQLTests, InsertOneValue) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(InsertSQLTests, InsertMultipleValues) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -201,14 +201,14 @@ TEST_F(InsertSQLTests, InsertMultipleValues) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(InsertSQLTests, InsertSpecifyColumns) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable8(); @@ -245,14 +245,14 @@ TEST_F(InsertSQLTests, InsertSpecifyColumns) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(InsertSQLTests, InsertTooLargeVarchar) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable3(); @@ -288,14 +288,14 @@ TEST_F(InsertSQLTests, InsertTooLargeVarchar) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(InsertSQLTests, InsertIntoSelectSimple) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -363,14 +363,14 @@ TEST_F(InsertSQLTests, InsertIntoSelectSimple) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(InsertSQLTests, InsertIntoSelectSimpleAllType) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable4(); @@ -451,14 +451,14 @@ TEST_F(InsertSQLTests, InsertIntoSelectSimpleAllType) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(InsertSQLTests, InsertIntoSelectColumn) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable6(); @@ -526,14 +526,14 @@ TEST_F(InsertSQLTests, InsertIntoSelectColumn) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(InsertSQLTests, UniqueColumn) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); std::string create_table( @@ -571,14 +571,14 @@ TEST_F(InsertSQLTests, UniqueColumn) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(InsertSQLTests, BadTypes) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); std::string error_message; std::unique_ptr optimizer( @@ -610,14 +610,14 @@ TEST_F(InsertSQLTests, BadTypes) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(InsertSQLTests, NonExistentTable) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); std::string error_message; std::unique_ptr optimizer( @@ -631,14 +631,14 @@ TEST_F(InsertSQLTests, NonExistentTable) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(InsertSQLTests, BadInserts) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable8(); @@ -707,7 +707,7 @@ TEST_F(InsertSQLTests, BadInserts) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/is_null_sql_test.cpp b/test/sql/is_null_sql_test.cpp index 6e7d1eaab20..c4121a2efd1 100644 --- a/test/sql/is_null_sql_test.cpp +++ b/test/sql/is_null_sql_test.cpp @@ -54,7 +54,7 @@ TEST_F(IsNullSqlTests, InsertNullTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_TRACE("Bootstrapping completed!"); @@ -77,7 +77,7 @@ TEST_F(IsNullSqlTests, InsertNullTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -87,7 +87,7 @@ TEST_F(IsNullSqlTests, IsNullWhereTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_TRACE("Bootstrapping completed!"); @@ -117,7 +117,7 @@ TEST_F(IsNullSqlTests, IsNullWhereTest) { TestingSQLUtil::GetResultValueAsString(result, 1).c_str()); // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -127,7 +127,7 @@ TEST_F(IsNullSqlTests, IsNotNullWhereTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_TRACE("Bootstrapping completed!"); @@ -156,7 +156,7 @@ TEST_F(IsNullSqlTests, IsNotNullWhereTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/optimizer_sql_test.cpp b/test/sql/optimizer_sql_test.cpp index 3855c015e20..9ebd230346c 100644 --- a/test/sql/optimizer_sql_test.cpp +++ b/test/sql/optimizer_sql_test.cpp @@ -45,7 +45,7 @@ class OptimizerSQLTests : public PelotonTest { // Destroy test database auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Call parent virtual function @@ -57,7 +57,7 @@ class OptimizerSQLTests : public PelotonTest { // Create database auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create a table first @@ -331,8 +331,10 @@ TEST_F(OptimizerSQLTests, DDLSqlTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); // using transaction to get table from catalog - auto table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "test2", txn); + auto table = catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "test2"); EXPECT_NE(nullptr, table); auto cols = table->GetSchema()->GetColumns(); EXPECT_EQ(3, cols.size()); @@ -353,8 +355,10 @@ TEST_F(OptimizerSQLTests, DDLSqlTest) { LOG_DEBUG("here"); txn = txn_manager.BeginTransaction(); - EXPECT_THROW(catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "test2", txn), + EXPECT_THROW(catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "test2"), peloton::Exception); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/order_by_sql_test.cpp b/test/sql/order_by_sql_test.cpp index f3643389bfd..b0abed429dd 100644 --- a/test/sql/order_by_sql_test.cpp +++ b/test/sql/order_by_sql_test.cpp @@ -41,7 +41,7 @@ void CreateAndLoadTable() { TEST_F(OrderBySQLTests, PerformanceTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create a table first @@ -108,14 +108,14 @@ TEST_F(OrderBySQLTests, PerformanceTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithColumnsTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -138,14 +138,14 @@ TEST_F(OrderBySQLTests, OrderByWithColumnsTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithColumnsDescTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -168,14 +168,14 @@ TEST_F(OrderBySQLTests, OrderByWithColumnsDescTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithoutColumnsTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -198,14 +198,14 @@ TEST_F(OrderBySQLTests, OrderByWithoutColumnsTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithoutColumnsDescTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -228,14 +228,14 @@ TEST_F(OrderBySQLTests, OrderByWithoutColumnsDescTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithColumnsAndLimitTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -259,14 +259,14 @@ TEST_F(OrderBySQLTests, OrderByWithColumnsAndLimitTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithColumnsAndLimitDescTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -290,14 +290,14 @@ TEST_F(OrderBySQLTests, OrderByWithColumnsAndLimitDescTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithoutColumnsAndLimitTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -321,14 +321,14 @@ TEST_F(OrderBySQLTests, OrderByWithoutColumnsAndLimitTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithoutColumnsAndLimitDescTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -352,14 +352,14 @@ TEST_F(OrderBySQLTests, OrderByWithoutColumnsAndLimitDescTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByStar) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -385,14 +385,14 @@ TEST_F(OrderBySQLTests, OrderByStar) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByStarDesc) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -418,14 +418,14 @@ TEST_F(OrderBySQLTests, OrderByStarDesc) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByStarWithLimit) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -450,14 +450,14 @@ TEST_F(OrderBySQLTests, OrderByStarWithLimit) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByStarWithLimitDesc) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -482,14 +482,14 @@ TEST_F(OrderBySQLTests, OrderByStarWithLimitDesc) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithProjectionTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -517,13 +517,13 @@ TEST_F(OrderBySQLTests, OrderByWithProjectionTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithProjectionDescTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -551,13 +551,13 @@ TEST_F(OrderBySQLTests, OrderByWithProjectionDescTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithProjectionLimitTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -586,14 +586,14 @@ TEST_F(OrderBySQLTests, OrderByWithProjectionLimitTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithProjectionLimitDescTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -622,14 +622,14 @@ TEST_F(OrderBySQLTests, OrderByWithProjectionLimitDescTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(OrderBySQLTests, OrderByWithNullCheck) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); CreateAndLoadTable(); @@ -664,7 +664,7 @@ TEST_F(OrderBySQLTests, OrderByWithNullCheck) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/projection_sql_test.cpp b/test/sql/projection_sql_test.cpp index 98ed0e4d45c..f57e0c0bd84 100644 --- a/test/sql/projection_sql_test.cpp +++ b/test/sql/projection_sql_test.cpp @@ -26,14 +26,14 @@ class ProjectionSQLTests : public PelotonTest { ProjectionSQLTests() { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto *txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } ~ProjectionSQLTests() { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto *txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/string_functions_sql_test.cpp b/test/sql/string_functions_sql_test.cpp index 4a57c8a3b45..4cc33d454d3 100644 --- a/test/sql/string_functions_sql_test.cpp +++ b/test/sql/string_functions_sql_test.cpp @@ -32,7 +32,7 @@ of the second column. TEST_F(StringFunctionTest, LengthTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); catalog::Catalog::GetInstance()->Bootstrap(); txn_manager.CommitTransaction(txn); // Create a t @@ -69,7 +69,7 @@ TEST_F(StringFunctionTest, LengthTest) { } txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/timestamp_functions_sql_test.cpp b/test/sql/timestamp_functions_sql_test.cpp index c368f84ad1c..a004c206bd0 100644 --- a/test/sql/timestamp_functions_sql_test.cpp +++ b/test/sql/timestamp_functions_sql_test.cpp @@ -25,7 +25,7 @@ class TimestampFunctionsSQLTest : public PelotonTest {}; TEST_F(TimestampFunctionsSQLTest, DateTruncTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); catalog::Catalog::GetInstance()->Bootstrap(); txn_manager.CommitTransaction(txn); // Create a t @@ -72,14 +72,14 @@ TEST_F(TimestampFunctionsSQLTest, DateTruncTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(TimestampFunctionsSQLTest, DatePartTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests // you can only call it once! txn_manager.CommitTransaction(txn); @@ -142,7 +142,7 @@ TEST_F(TimestampFunctionsSQLTest, DatePartTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/type_sql_test.cpp b/test/sql/type_sql_test.cpp index 1da4f602646..6c46359f13b 100644 --- a/test/sql/type_sql_test.cpp +++ b/test/sql/type_sql_test.cpp @@ -27,14 +27,14 @@ class TypeSQLTests : public PelotonTest { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } virtual void TearDown() override { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); PelotonTest::TearDown(); diff --git a/test/sql/update_primary_index_sql_test.cpp b/test/sql/update_primary_index_sql_test.cpp index 0b6f91b39f1..0ae64bf36cb 100644 --- a/test/sql/update_primary_index_sql_test.cpp +++ b/test/sql/update_primary_index_sql_test.cpp @@ -27,7 +27,7 @@ class UpdatePrimaryIndexSQLTests : public PelotonTest {}; TEST_F(UpdatePrimaryIndexSQLTests, UpdatePrimaryIndexTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create a table first @@ -91,7 +91,7 @@ TEST_F(UpdatePrimaryIndexSQLTests, UpdatePrimaryIndexTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/update_secondary_index_sql_test.cpp b/test/sql/update_secondary_index_sql_test.cpp index 842bc1ca9ee..fb810eb3963 100644 --- a/test/sql/update_secondary_index_sql_test.cpp +++ b/test/sql/update_secondary_index_sql_test.cpp @@ -27,7 +27,7 @@ class UpdateSecondaryIndexSQLTests : public PelotonTest {}; TEST_F(UpdateSecondaryIndexSQLTests, UpdateSecondaryIndexTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create a table first @@ -69,7 +69,7 @@ TEST_F(UpdateSecondaryIndexSQLTests, UpdateSecondaryIndexTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/update_sql_test.cpp b/test/sql/update_sql_test.cpp index f3584843918..6df7faa5903 100644 --- a/test/sql/update_sql_test.cpp +++ b/test/sql/update_sql_test.cpp @@ -30,7 +30,7 @@ TEST_F(UpdateSQLTests, SimpleUpdateSQLTest) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_DEBUG("Bootstrapping completed!"); @@ -99,7 +99,7 @@ TEST_F(UpdateSQLTests, SimpleUpdateSQLTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -109,7 +109,7 @@ TEST_F(UpdateSQLTests, ComplexUpdateSQLTest) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_DEBUG("Bootstrapping completed!"); @@ -191,7 +191,7 @@ TEST_F(UpdateSQLTests, ComplexUpdateSQLTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -201,7 +201,7 @@ TEST_F(UpdateSQLTests, UpdateSQLCastTest) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_DEBUG("Bootstrapping completed!"); @@ -274,7 +274,7 @@ TEST_F(UpdateSQLTests, UpdateSQLCastTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -287,7 +287,7 @@ TEST_F(UpdateSQLTests, HalloweenProblemTest) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_DEBUG("Bootstrapping completed!"); @@ -351,7 +351,7 @@ TEST_F(UpdateSQLTests, HalloweenProblemTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -365,7 +365,7 @@ TEST_F(UpdateSQLTests, HalloweenProblemTestWithPK) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_DEBUG("Bootstrapping completed!"); @@ -452,7 +452,7 @@ TEST_F(UpdateSQLTests, HalloweenProblemTestWithPK) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -462,7 +462,7 @@ TEST_F(UpdateSQLTests, MultiTileGroupUpdateSQLTest) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_DEBUG("Bootstrapping completed!"); @@ -523,7 +523,7 @@ TEST_F(UpdateSQLTests, MultiTileGroupUpdateSQLTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -537,7 +537,7 @@ TEST_F(UpdateSQLTests, AttributeOrderUpdateSQLTest) { auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); LOG_DEBUG("Bootstrapping completed!"); @@ -629,7 +629,7 @@ TEST_F(UpdateSQLTests, AttributeOrderUpdateSQLTest) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } diff --git a/test/statistics/stats_test.cpp b/test/statistics/stats_test.cpp index ef3c7da6cba..b40efd823e6 100644 --- a/test/statistics/stats_test.cpp +++ b/test/statistics/stats_test.cpp @@ -135,17 +135,22 @@ TEST_F(StatsTests, MultiThreadStatsTest) { std::unique_ptr table_schema( new catalog::Schema({id_column, name_column})); - catalog->CreateDatabase("emp_db", txn); - catalog::Catalog::GetInstance()->CreateTable("emp_db", DEFAULT_SCHEMA_NAME, + catalog->CreateDatabase(txn, "emp_db"); + catalog::Catalog::GetInstance()->CreateTable(txn, + "emp_db", + DEFAULT_SCHEMA_NAME, + std::move(table_schema), "department_table", - std::move(table_schema), txn); + false); // Create multiple stat worker threads int num_threads = 8; storage::Database *database = - catalog->GetDatabaseWithName("emp_db", txn); - storage::DataTable *table = catalog->GetTableWithName( - "emp_db", DEFAULT_SCHEMA_NAME, "department_table", txn); + catalog->GetDatabaseWithName(txn, "emp_db"); + storage::DataTable *table = catalog->GetTableWithName(txn, + "emp_db", + DEFAULT_SCHEMA_NAME, + "department_table"); txn_manager.CommitTransaction(txn); LaunchParallelTest(num_threads, TransactionTest, database, table); // Wait for aggregation to finish @@ -194,7 +199,7 @@ TEST_F(StatsTests, MultiThreadStatsTest) { num_threads * NUM_ITERATION * NUM_INDEX_INSERT); txn = txn_manager.BeginTransaction(); - catalog->DropDatabaseWithName("emp_db", txn); + catalog->DropDatabaseWithName(txn, "emp_db"); txn_manager.CommitTransaction(txn); } // diff --git a/test/storage/database_test.cpp b/test/storage/database_test.cpp index 427d4c220e3..fee76bd33d5 100644 --- a/test/storage/database_test.cpp +++ b/test/storage/database_test.cpp @@ -41,7 +41,8 @@ TEST_F(DatabaseTests, AddDropTest) { TestingExecutorUtil::DeleteDatabase(DEFAULT_DB_NAME); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - EXPECT_THROW(catalog::Catalog::GetInstance()->GetDatabaseObject(db_id, txn), + EXPECT_THROW(catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, + db_id), CatalogException); txn_manager.CommitTransaction(txn); // Only GC will remove the actual database object @@ -80,7 +81,8 @@ TEST_F(DatabaseTests, AddDropTableTest) { TestingExecutorUtil::DeleteDatabase(DEFAULT_DB_NAME); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - EXPECT_THROW(catalog::Catalog::GetInstance()->GetDatabaseObject(db_id, txn), + EXPECT_THROW(catalog::Catalog::GetInstance()->GetDatabaseCatalogEntry(txn, + db_id), CatalogException); txn_manager.CommitTransaction(txn); // Only GC will remove the actual database object diff --git a/test/trigger/trigger_test.cpp b/test/trigger/trigger_test.cpp index 7238d7f9e6d..e199d1f69e0 100644 --- a/test/trigger/trigger_test.cpp +++ b/test/trigger/trigger_test.cpp @@ -42,7 +42,7 @@ class TriggerTests : public PelotonTest { void CreateTableHelper() { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); // Insert a table first auto id_column = catalog::Column( @@ -74,8 +74,11 @@ class TriggerTests : public PelotonTest { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - auto table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, std::string(table_name), txn); + auto table = catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + std::string( + table_name)); std::unique_ptr context( new executor::ExecutorContext(txn)); @@ -149,8 +152,10 @@ class TriggerTests : public PelotonTest { // Check the effect of creation storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, table_name, txn); + catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + table_name); txn_manager.CommitTransaction(txn); EXPECT_EQ(trigger_number, target_table->GetTriggerNumber()); trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); @@ -277,8 +282,10 @@ TEST_F(TriggerTests, BeforeAndAfterRowInsertTriggers) { // Check the effect of creation storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "accounts", txn); + catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "accounts"); txn_manager.CommitTransaction(txn); EXPECT_EQ(1, target_table->GetTriggerNumber()); trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); @@ -304,7 +311,7 @@ TEST_F(TriggerTests, BeforeAndAfterRowInsertTriggers) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -364,8 +371,10 @@ TEST_F(TriggerTests, AfterStatmentInsertTriggers) { // Check the effect of creation storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "accounts", txn); + catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + "accounts"); txn_manager.CommitTransaction(txn); EXPECT_EQ(1, target_table->GetTriggerNumber()); trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); @@ -384,7 +393,7 @@ TEST_F(TriggerTests, AfterStatmentInsertTriggers) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } @@ -468,8 +477,10 @@ TEST_F(TriggerTests, OtherTypesTriggers) { auto txn = txn_manager.BeginTransaction(); storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, table_name, txn); + catalog::Catalog::GetInstance()->GetTableWithName(txn, + DEFAULT_DB_NAME, + DEFAULT_SCHEMA_NAME, + table_name); txn_manager.CommitTransaction(txn); trigger::TriggerList *new_trigger_list = target_table->GetTriggerList(); @@ -503,7 +514,7 @@ TEST_F(TriggerTests, OtherTypesTriggers) { // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } } // namespace test diff --git a/test/udf/udf_test.cpp b/test/udf/udf_test.cpp index b45b29510b3..725bdd9f5ff 100644 --- a/test/udf/udf_test.cpp +++ b/test/udf/udf_test.cpp @@ -25,7 +25,7 @@ class UDFTest : public PelotonTest {}; TEST_F(UDFTest, SimpleExpressionTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); catalog::Catalog::GetInstance()->Bootstrap(); txn_manager.CommitTransaction(txn); // Create a t @@ -72,14 +72,14 @@ TEST_F(UDFTest, SimpleExpressionTest) { } // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(UDFTest, ComplexExpressionTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create a txn txn = txn_manager.BeginTransaction(); @@ -128,14 +128,14 @@ TEST_F(UDFTest, ComplexExpressionTest) { } // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(UDFTest, IfElseExpressionTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create a txn txn = txn_manager.BeginTransaction(); @@ -186,14 +186,14 @@ TEST_F(UDFTest, IfElseExpressionTest) { } // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); } TEST_F(UDFTest, RecursiveFunctionTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); // Create a txn txn = txn_manager.BeginTransaction(); @@ -233,7 +233,7 @@ TEST_F(UDFTest, RecursiveFunctionTest) { } // free the database just created txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName(txn, DEFAULT_DB_NAME); txn_manager.CommitTransaction(txn); }