From ab15a85852b6d7f18deeb70dc7eb0d90e2f4a596 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Mon, 27 Nov 2017 22:45:13 -0500 Subject: [PATCH 01/48] codegen insert catalog tuple --- src/catalog/abstract_catalog.cpp | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 692e14b9c98..e95c8a6d2df 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -32,6 +32,7 @@ #include "executor/delete_executor.h" #include "executor/index_scan_executor.h" #include "executor/insert_executor.h" +#include "executor/plan_executor.h" #include "executor/seq_scan_executor.h" #include "storage/database.h" @@ -107,14 +108,20 @@ bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, if (txn == nullptr) throw CatalogException("Insert tuple requires transaction"); - std::unique_ptr context( - new executor::ExecutorContext(txn)); - planner::InsertPlan node(catalog_table_, std::move(tuple)); - executor::InsertExecutor executor(&node, context.get()); - executor.Init(); - bool status = executor.Execute(); + std::vector params; + std::vector result_format(tuple->GetSchema()->GetColumnCount(), 0); + for (size_t i = 0; i < tuple->GetSchema()->GetColumnCount(); i++) { + params.push_back(tuple->GetValue(i)); + } + std::vector result; + executor::ExecuteResult p_status; + auto node = + std::make_shared(catalog_table_, std::move(tuple)); - return status; + executor::PlanExecutor::ExecutePlan(node, txn, params, result, result_format, + p_status); + + return p_status.m_result == peloton::ResultType::SUCCESS; } /*@brief Delete a tuple using index scan From 69ad2711c6d9eb933a6e5bb67cc06eb8e23e2d28 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Sun, 21 Jan 2018 19:51:28 -0500 Subject: [PATCH 02/48] add update method using old engine --- src/catalog/abstract_catalog.cpp | 127 +++++++++++++++++++++++-------- 1 file changed, 96 insertions(+), 31 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index e95c8a6d2df..f17449f3ca5 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -99,10 +99,10 @@ AbstractCatalog::AbstractCatalog(const std::string &catalog_table_ddl, } /*@brief insert tuple(reord) helper function -* @param tuple tuple to be inserted -* @param txn TransactionContext -* @return Whether insertion is Successful -*/ + * @param tuple tuple to be inserted + * @param txn TransactionContext + * @return Whether insertion is Successful + */ bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, concurrency::TransactionContext *txn) { if (txn == nullptr) @@ -125,11 +125,11 @@ bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, } /*@brief Delete a tuple using index scan -* @param index_offset Offset of index for scan -* @param values Values for search -* @param txn TransactionContext -* @return Whether deletion is Successful -*/ + * @param index_offset Offset of index for scan + * @param values Values for search + * @param txn TransactionContext + * @return Whether deletion is Successful + */ bool AbstractCatalog::DeleteWithIndexScan( oid_t index_offset, std::vector values, concurrency::TransactionContext *txn) { @@ -174,12 +174,12 @@ bool AbstractCatalog::DeleteWithIndexScan( } /*@brief Index scan helper function -* @param column_offsets Column ids for search (projection) -* @param index_offset Offset of index for scan -* @param values Values for search -* @param txn TransactionContext -* @return Unique pointer of vector of logical tiles -*/ + * @param column_offsets Column ids for search (projection) + * @param index_offset Offset of index for scan + * @param values Values for search + * @param txn TransactionContext + * @return Unique pointer of vector of logical tiles + */ std::unique_ptr>> AbstractCatalog::GetResultWithIndexScan( std::vector column_offsets, oid_t index_offset, @@ -222,14 +222,14 @@ AbstractCatalog::GetResultWithIndexScan( } /*@brief Sequential scan helper function -* NOTE: try to use efficient index scan instead of sequential scan, but you -* shouldn't build too many indexes on one catalog table -* @param column_offsets Column ids for search (projection) -* @param predicate predicate for this sequential scan query -* @param txn TransactionContext -* -* @return Unique pointer of vector of logical tiles -*/ + * NOTE: try to use efficient index scan instead of sequential scan, but you + * shouldn't build too many indexes on one catalog table + * @param column_offsets Column ids for search (projection) + * @param predicate predicate for this sequential scan query + * @param txn TransactionContext + * + * @return Unique pointer of vector of logical tiles + */ std::unique_ptr>> AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, @@ -257,14 +257,14 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, } /*@brief Add index on catalog table -* @param key_attrs indexed column offset(position) -* @param index_oid index id(global unique) -* @param index_name index name(global unique) -* @param index_constraint index constraints -* @return Unique pointer of vector of logical tiles -* Note: Use catalog::Catalog::CreateIndex() if you can, only ColumnCatalog and -* IndexCatalog should need this -*/ + * @param key_attrs indexed column offset(position) + * @param index_oid index id(global unique) + * @param index_name index name(global unique) + * @param index_constraint index constraints + * @return Unique pointer of vector of logical tiles + * 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, IndexConstraintType index_constraint) { @@ -293,5 +293,70 @@ void AbstractCatalog::AddIndex(const std::vector &key_attrs, index_name.c_str(), (int)catalog_table_->GetOid()); } +/*@brief Update specific columns using index scan + * @param update_columns Columns to be updated + * @param update_values Values to be updated + * @param scan_values Value to be scaned (used in index scan) + * @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::Transaction *txn) { + if (txn == nullptr) throw CatalogException("Scan table requires transaction"); + + std::unique_ptr context( + new executor::ExecutorContext(txn)); + // Construct index scan executor + auto index = catalog_table_->GetIndex(index_offset); + std::vector key_column_offsets = + index->GetMetadata()->GetKeySchema()->GetIndexedColumns(); + PL_ASSERT(scan_values.size() == key_column_offsets.size()); + std::vector expr_types(scan_values.size(), + ExpressionType::COMPARE_EQUAL); + std::vector runtime_keys; + + planner::IndexScanPlan::IndexScanDesc index_scan_desc( + index, key_column_offsets, expr_types, scan_values, runtime_keys); + + planner::IndexScanPlan index_scan_node(catalog_table_, nullptr, + update_columns, index_scan_desc); + + executor::IndexScanExecutor index_scan_executor(&index_scan_node, + context.get()); + // Construct update executor + TargetList target_list; + DirectMapList direct_map_list; + + size_t column_count = catalog_table_->GetSchema()->GetColumnCount(); + for (size_t col_itr = 0; col_itr < column_count; col_itr++) { + // Skip any column for update + if (std::find(std::begin(update_columns), std::end(update_columns), + col_itr) == std::end(update_columns)) { + direct_map_list.emplace_back(col_itr, std::make_pair(0, col_itr)); + } + } + + PL_ASSERT(update_columns.size() == update_values.size()); + for (size_t i = 0; i < update_values.size(); i++) { + planner::DerivedAttribute update_attribute{ + expression::ExpressionUtil::ConstantValueFactory(update_values[i])}; + // emplace(update_column_id, update_val) + target_list.emplace_back(update_columns[i], update_attribute); + } + + std::unique_ptr project_info( + new planner::ProjectInfo(std::move(target_list), + std::move(direct_map_list))); + planner::UpdatePlan update_node(catalog_table_, std::move(project_info)); + + executor::UpdateExecutor update_executor(&update_node, context.get()); + update_executor.AddChild(&index_scan_executor); + // Execute + update_executor.Init(); + return update_executor.Execute(); +} + } // namespace catalog } // namespace peloton From eb2bab53f87274bffd510742c7373586bb3c4027 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sun, 21 Jan 2018 00:07:25 -0500 Subject: [PATCH 03/48] fix segfault caused by bad insert plan --- src/catalog/abstract_catalog.cpp | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index f17449f3ca5..e00f76a40ab 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -109,19 +109,32 @@ bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, throw CatalogException("Insert tuple requires transaction"); std::vector params; + std::vector columns; + std::vector>> + values; + values.push_back( + std::vector>()); std::vector result_format(tuple->GetSchema()->GetColumnCount(), 0); for (size_t i = 0; i < tuple->GetSchema()->GetColumnCount(); i++) { params.push_back(tuple->GetValue(i)); + columns.push_back(tuple->GetSchema()->GetColumn(i).GetName()); + values[0].emplace_back( + new expression::ConstantValueExpression(tuple->GetValue(i))); } - std::vector result; - executor::ExecuteResult p_status; auto node = - std::make_shared(catalog_table_, std::move(tuple)); + std::make_shared(catalog_table_, &columns, &values); - executor::PlanExecutor::ExecutePlan(node, txn, params, result, result_format, - p_status); + executor::ExecutionResult this_p_status; + auto on_complete = + [&this_p_status](executor::ExecutionResult p_status, + std::vector &&values UNUSED_ATTRIBUTE) { + this_p_status = p_status; + }; - return p_status.m_result == peloton::ResultType::SUCCESS; + executor::PlanExecutor::ExecutePlan(node, txn, params, result_format, + on_complete); + + return this_p_status.m_result == peloton::ResultType::SUCCESS; } /*@brief Delete a tuple using index scan From 8a0b1ac0acf2b7721990bcb52ba149e22306712a Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sun, 21 Jan 2018 15:08:33 -0500 Subject: [PATCH 04/48] consider cached catalog queries --- test/codegen/query_cache_test.cpp | 57 ++++++++++++++++++------------- 1 file changed, 34 insertions(+), 23 deletions(-) diff --git a/test/codegen/query_cache_test.cpp b/test/codegen/query_cache_test.cpp index 8babf573003..410a3efe827 100644 --- a/test/codegen/query_cache_test.cpp +++ b/test/codegen/query_cache_test.cpp @@ -12,16 +12,16 @@ #include "codegen/testing_codegen_util.h" +#include "catalog/catalog.h" #include "codegen/query_cache.h" #include "codegen/testing_codegen_util.h" #include "codegen/type/decimal_type.h" #include "common/timer.h" -#include "catalog/catalog.h" #include "expression/conjunction_expression.h" #include "expression/operator_expression.h" #include "planner/aggregate_plan.h" -#include "planner/hash_plan.h" #include "planner/hash_join_plan.h" +#include "planner/hash_plan.h" #include "planner/nested_loop_join_plan.h" #include "planner/order_by_plan.h" #include "planner/seq_scan_plan.h" @@ -29,6 +29,8 @@ namespace peloton { namespace test { +constexpr int CACHE_USED_BY_CATALOG = 4; + class QueryCacheTest : public PelotonCodeGenTest { public: QueryCacheTest() : PelotonCodeGenTest(), num_rows_to_insert(64) { @@ -167,12 +169,10 @@ class QueryCacheTest : public PelotonCodeGenTest { std::shared_ptr GetBlockNestedLoopJoinPlan() { // Output all columns - DirectMapList direct_map_list = {{0, std::make_pair(0, 0)}, - {1, std::make_pair(0, 1)}, - {2, std::make_pair(0, 2)}, - {3, std::make_pair(1, 0)}, - {4, std::make_pair(1, 1)}, - {5, std::make_pair(1, 2)}}; + DirectMapList direct_map_list = { + {0, std::make_pair(0, 0)}, {1, std::make_pair(0, 1)}, + {2, std::make_pair(0, 2)}, {3, std::make_pair(1, 0)}, + {4, std::make_pair(1, 1)}, {5, std::make_pair(1, 2)}}; std::unique_ptr projection{ new planner::ProjectInfo(TargetList{}, std::move(direct_map_list))}; @@ -234,7 +234,8 @@ TEST_F(QueryCacheTest, SimpleCache) { const auto &results_1 = buffer_1.GetOutputTuples(); EXPECT_EQ(NumRowsInTestTable() - 4, results_1.size()); EXPECT_FALSE(cached); - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(1 + CACHE_USED_BY_CATALOG, + codegen::QueryCache::Instance().GetCount()); // Execute a query cached codegen::BufferingConsumer buffer_2{{0}, context_2}; @@ -243,7 +244,8 @@ TEST_F(QueryCacheTest, SimpleCache) { EXPECT_TRUE(cached); EXPECT_EQ(NumRowsInTestTable() - 4, results_2.size()); - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(1 + CACHE_USED_BY_CATALOG, + codegen::QueryCache::Instance().GetCount()); // PelotonCodeTest dies after each TEST_F() // So, we delete the cache @@ -277,9 +279,9 @@ TEST_F(QueryCacheTest, CacheSeqScanPlan) { const auto &results_1 = buffer_1.GetOutputTuples(); EXPECT_EQ(1, results_1.size()); EXPECT_EQ(CmpBool::CmpTrue, results_1[0].GetValue(0).CompareEquals( - type::ValueFactory::GetIntegerValue(20))); + type::ValueFactory::GetIntegerValue(20))); EXPECT_EQ(CmpBool::CmpTrue, results_1[0].GetValue(1).CompareEquals( - type::ValueFactory::GetIntegerValue(21))); + type::ValueFactory::GetIntegerValue(21))); EXPECT_FALSE(cached); codegen::BufferingConsumer buffer_2{{0, 1, 2}, context_2}; @@ -288,11 +290,12 @@ TEST_F(QueryCacheTest, CacheSeqScanPlan) { const auto &results_2 = buffer_2.GetOutputTuples(); EXPECT_EQ(1, results_2.size()); EXPECT_EQ(CmpBool::CmpTrue, results_2[0].GetValue(0).CompareEquals( - type::ValueFactory::GetIntegerValue(20))); + type::ValueFactory::GetIntegerValue(20))); EXPECT_EQ(CmpBool::CmpTrue, results_2[0].GetValue(1).CompareEquals( - type::ValueFactory::GetIntegerValue(21))); + type::ValueFactory::GetIntegerValue(21))); EXPECT_TRUE(cached); - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(1 + CACHE_USED_BY_CATALOG, + codegen::QueryCache::Instance().GetCount()); // PelotonCodeTest dies after each TEST_F() // So, we delete the cache @@ -350,7 +353,8 @@ TEST_F(QueryCacheTest, CacheHashJoinPlan) { EXPECT_EQ(tuple.GetValue(0).CompareEquals(tuple.GetValue(1)), CmpBool::CmpTrue); } - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(1 + CACHE_USED_BY_CATALOG, + codegen::QueryCache::Instance().GetCount()); // PelotonCodeTest dies after each TEST_F() // So, we delete the cache @@ -428,7 +432,8 @@ TEST_F(QueryCacheTest, CacheOrderByPlan) { std::move(order_by_plan_3)) == nullptr); EXPECT_EQ(found, 1); - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(1 + CACHE_USED_BY_CATALOG, + codegen::QueryCache::Instance().GetCount()); // PelotonCodeTest dies after each TEST_F() // So, we delete the cache @@ -449,7 +454,8 @@ TEST_F(QueryCacheTest, CacheAggregatePlan) { auto is_equal = (*agg_plan1.get() == *agg_plan_2.get()); EXPECT_TRUE(is_equal); - EXPECT_EQ(0, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(0 + CACHE_USED_BY_CATALOG, + codegen::QueryCache::Instance().GetCount()); codegen::BufferingConsumer buffer_1{{0, 1}, context_1}; codegen::BufferingConsumer buffer_2{{0, 1}, context_2}; @@ -461,7 +467,8 @@ TEST_F(QueryCacheTest, CacheAggregatePlan) { const auto &results_1 = buffer_1.GetOutputTuples(); EXPECT_EQ(results_1.size(), 59); EXPECT_FALSE(cached); - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(1 + CACHE_USED_BY_CATALOG, + codegen::QueryCache::Instance().GetCount()); // Compile and execute with the cached query CompileAndExecuteCache(agg_plan_2, buffer_2, cached); @@ -471,7 +478,8 @@ TEST_F(QueryCacheTest, CacheAggregatePlan) { EXPECT_TRUE(cached); // Clean the query cache and leaves only one query - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(1 + CACHE_USED_BY_CATALOG, + codegen::QueryCache::Instance().GetCount()); codegen::QueryCache::Instance().Clear(); EXPECT_EQ(0, codegen::QueryCache::Instance().GetCount()); @@ -496,7 +504,8 @@ TEST_F(QueryCacheTest, CacheNestedLoopJoinPlan) { auto is_equal = (*nlj_plan_1.get() == *nlj_plan_2.get()); EXPECT_TRUE(is_equal); - EXPECT_EQ(0, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(0 + CACHE_USED_BY_CATALOG, + codegen::QueryCache::Instance().GetCount()); codegen::BufferingConsumer buffer_1{{0, 1}, context_1}; codegen::BufferingConsumer buffer_2{{0, 1}, context_2}; @@ -505,14 +514,16 @@ TEST_F(QueryCacheTest, CacheNestedLoopJoinPlan) { bool cached; CompileAndExecuteCache(nlj_plan_1, buffer_1, cached); EXPECT_FALSE(cached); - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(1 + CACHE_USED_BY_CATALOG, + codegen::QueryCache::Instance().GetCount()); // Compile and execute with the cached query CompileAndExecuteCache(nlj_plan_2, buffer_2, cached); EXPECT_TRUE(cached); // Clean the query cache and leaves only one query - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(1 + CACHE_USED_BY_CATALOG, + codegen::QueryCache::Instance().GetCount()); codegen::QueryCache::Instance().Clear(); EXPECT_EQ(0, codegen::QueryCache::Instance().GetCount()); From b3dd1a4becbc2d3b10719157e77eed560cea8306 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Sun, 21 Jan 2018 21:35:17 -0500 Subject: [PATCH 05/48] add version id column into pg_table --- src/catalog/abstract_catalog.cpp | 15 +++++---- src/catalog/table_catalog.cpp | 44 +++++++++++++++++++++++--- src/include/catalog/abstract_catalog.h | 8 ++++- src/include/catalog/table_catalog.h | 19 +++++++---- test/catalog/catalog_test.cpp | 20 +++++++++--- 5 files changed, 84 insertions(+), 22 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index e00f76a40ab..cf2b1990c51 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -34,6 +34,7 @@ #include "executor/insert_executor.h" #include "executor/plan_executor.h" #include "executor/seq_scan_executor.h" +#include "executor/update_executor.h" #include "storage/database.h" #include "storage/storage_manager.h" @@ -125,11 +126,11 @@ bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, std::make_shared(catalog_table_, &columns, &values); executor::ExecutionResult this_p_status; - auto on_complete = - [&this_p_status](executor::ExecutionResult p_status, - std::vector &&values UNUSED_ATTRIBUTE) { - this_p_status = p_status; - }; + auto on_complete = [&this_p_status]( + executor::ExecutionResult p_status, + std::vector &&values UNUSED_ATTRIBUTE) { + this_p_status = p_status; + }; executor::PlanExecutor::ExecutePlan(node, txn, params, result_format, on_complete); @@ -316,7 +317,7 @@ void AbstractCatalog::AddIndex(const std::vector &key_attrs, bool AbstractCatalog::UpdateWithIndexScan( std::vector update_columns, std::vector update_values, std::vector scan_values, oid_t index_offset, - concurrency::Transaction *txn) { + concurrency::TransactionContext *txn) { if (txn == nullptr) throw CatalogException("Scan table requires transaction"); std::unique_ptr context( @@ -354,7 +355,7 @@ bool AbstractCatalog::UpdateWithIndexScan( PL_ASSERT(update_columns.size() == update_values.size()); for (size_t i = 0; i < update_values.size(); i++) { planner::DerivedAttribute update_attribute{ - expression::ExpressionUtil::ConstantValueFactory(update_values[i])}; + new expression::ConstantValueExpression(update_values[i])}; // emplace(update_column_id, update_val) target_list.emplace_back(update_columns[i], update_attribute); } diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 49fbaed6db5..a80e0898023 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -14,9 +14,9 @@ #include "catalog/table_catalog.h" +#include "catalog/column_catalog.h" #include "catalog/database_catalog.h" #include "catalog/index_catalog.h" -#include "catalog/column_catalog.h" #include "concurrency/transaction_context.h" #include "storage/data_table.h" #include "type/value_factory.h" @@ -33,6 +33,8 @@ TableCatalogObject::TableCatalogObject(executor::LogicalTile *tile, .ToString()), database_oid(tile->GetValue(tupleId, TableCatalog::ColumnId::DATABASE_OID) .GetAs()), + version_id(tile->GetValue(tupleId, TableCatalog::ColumnId::VERSION_ID) + .GetAs()), index_objects(), index_names(), valid_index_objects(false), @@ -357,8 +359,15 @@ std::unique_ptr TableCatalog::InitializeSchema() { database_id_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); - std::unique_ptr table_catalog_schema(new catalog::Schema( - {table_id_column, table_name_column, database_id_column})); + auto version_id_column = catalog::Column( + type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER), + "version_id", true); + version_id_column.AddConstraint( + catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); + + std::unique_ptr table_catalog_schema( + new catalog::Schema({table_id_column, table_name_column, + database_id_column, version_id_column})); return table_catalog_schema; } @@ -380,10 +389,12 @@ bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, auto val0 = type::ValueFactory::GetIntegerValue(table_oid); auto val1 = type::ValueFactory::GetVarcharValue(table_name, nullptr); auto val2 = type::ValueFactory::GetIntegerValue(database_oid); + auto val3 = type::ValueFactory::GetIntegerValue(0); tuple->SetValue(TableCatalog::ColumnId::TABLE_OID, val0, pool); tuple->SetValue(TableCatalog::ColumnId::TABLE_NAME, val1, pool); tuple->SetValue(TableCatalog::ColumnId::DATABASE_OID, val2, pool); + tuple->SetValue(TableCatalog::ColumnId::VERSION_ID, val3, pool); // Insert the tuple return InsertTuple(std::move(tuple), txn); @@ -394,7 +405,8 @@ 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(oid_t table_oid, + concurrency::TransactionContext *txn) { oid_t index_offset = IndexId::PRIMARY_KEY; // Index of table_oid std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); @@ -541,5 +553,29 @@ TableCatalog::GetTableObjects(oid_t database_oid, return database_object->GetTableObjects(); } +bool TableCatalog::UpdateVersionId(oid_t update_val, oid_t table_oid, + concurrency::TransactionContext *txn) { + 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 + std::vector scan_values; + scan_values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); + // values to update + std::vector update_values; + update_values.push_back( + type::ValueFactory::GetIntegerValue(update_val).Copy()); + + // get table object, then evict table object + auto table_object = txn->catalog_cache.GetCachedTableObject(table_oid); + if (table_object) { + auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( + table_object->GetDatabaseOid(), txn); + database_object->EvictTableObject(table_oid); + } + + return UpdateWithIndexScan(update_columns, update_values, scan_values, + index_offset, txn); +} + } // namespace catalog } // namespace peloton diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index 9acf67773b9..35319683e18 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -35,7 +35,7 @@ namespace storage { class Database; class DataTable; class Tuple; -} +} // namespace storage namespace catalog { @@ -72,6 +72,12 @@ class AbstractCatalog { expression::AbstractExpression *predicate, concurrency::TransactionContext *txn); + bool UpdateWithIndexScan(std::vector update_columns, + std::vector update_values, + std::vector scan_values, + oid_t index_offset, + concurrency::TransactionContext *txn); + void AddIndex(const std::vector &key_attrs, oid_t index_oid, const std::string &index_name, IndexConstraintType index_constraint); diff --git a/src/include/catalog/table_catalog.h b/src/include/catalog/table_catalog.h index 3ef4668d5ca..a509fa1aa35 100644 --- a/src/include/catalog/table_catalog.h +++ b/src/include/catalog/table_catalog.h @@ -45,8 +45,8 @@ class TableCatalogObject { friend class ColumnCatalog; public: - TableCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn, - int tupleId = 0); + TableCatalogObject(executor::LogicalTile *tile, + concurrency::TransactionContext *txn, int tupleId = 0); public: // Get indexes @@ -74,12 +74,14 @@ class TableCatalogObject { inline oid_t GetTableOid() { return table_oid; } inline const std::string &GetTableName() { return table_name; } inline oid_t GetDatabaseOid() { return database_oid; } + inline uint32_t GetVersionId() { return version_id; } private: // member variables oid_t table_oid; std::string table_name; oid_t database_oid; + uint32_t version_id; // Get index objects bool InsertIndexObject(std::shared_ptr index_object); @@ -119,9 +121,10 @@ class TableCatalog : public AbstractCatalog { ~TableCatalog(); // Global Singleton, only the first call requires passing parameters. - static TableCatalog *GetInstance(storage::Database *pg_catalog = nullptr, - type::AbstractPool *pool = nullptr, - concurrency::TransactionContext *txn = nullptr); + static TableCatalog *GetInstance( + storage::Database *pg_catalog = nullptr, + type::AbstractPool *pool = nullptr, + concurrency::TransactionContext *txn = nullptr); inline oid_t GetNextOid() { return oid_++ | TABLE_OID_MASK; } @@ -133,6 +136,9 @@ class TableCatalog : public AbstractCatalog { concurrency::TransactionContext *txn); bool DeleteTable(oid_t table_oid, concurrency::TransactionContext *txn); + bool UpdateVersionId(oid_t update_val, oid_t table_oid, + concurrency::TransactionContext *txn); + //===--------------------------------------------------------------------===// // Read Related API //===--------------------------------------------------------------------===// @@ -155,9 +161,10 @@ class TableCatalog : public AbstractCatalog { TABLE_OID = 0, TABLE_NAME = 1, DATABASE_OID = 2, + VERSION_ID = 3, // Add new columns here in creation order }; - std::vector all_column_ids = {0, 1, 2}; + std::vector all_column_ids = {0, 1, 2, 3}; enum IndexId { PRIMARY_KEY = 0, diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index f9e8ec00c8c..84743193ec8 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -11,15 +11,15 @@ //===----------------------------------------------------------------------===// #include "catalog/catalog.h" -#include "catalog/database_catalog.h" -#include "catalog/table_catalog.h" -#include "catalog/index_catalog.h" #include "catalog/column_catalog.h" +#include "catalog/database_catalog.h" #include "catalog/database_metrics_catalog.h" +#include "catalog/index_catalog.h" #include "catalog/query_metrics_catalog.h" -#include "concurrency/transaction_manager_factory.h" +#include "catalog/table_catalog.h" #include "common/harness.h" #include "common/logger.h" +#include "concurrency/transaction_manager_factory.h" #include "storage/storage_manager.h" #include "type/ephemeral_pool.h" @@ -182,6 +182,18 @@ TEST_F(CatalogTests, TableObject) { EXPECT_FALSE(column_objects[1]->IsPrimary()); EXPECT_FALSE(column_objects[1]->IsNotNull()); + // update pg_table SET version_oid = 1 where table_name = department_table + oid_t department_table_oid = table_object->GetTableOid(); + bool update_result = catalog::TableCatalog::GetInstance()->UpdateVersionId( + 1, department_table_oid, txn); + // get version id after update + table_object = catalog::Catalog::GetInstance()->GetTableObject( + "EMP_DB", "department_table", txn); + uint32_t version_oid = table_object->GetVersionId(); + EXPECT_NE(department_table_oid, INVALID_OID); + EXPECT_EQ(update_result, true); + EXPECT_EQ(version_oid, 1); + txn_manager.CommitTransaction(txn); } From d4815e4120b34c1ebc9d287d7a01b2979f4adbbd Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sun, 21 Jan 2018 21:45:45 -0500 Subject: [PATCH 06/48] column id and offset use uint32 --- src/catalog/column_catalog.cpp | 14 +++++++------- src/include/catalog/column_catalog.h | 20 +++++++++++--------- 2 files changed, 18 insertions(+), 16 deletions(-) diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index d5cbc3c2c10..ec34f95622c 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -27,10 +27,10 @@ ColumnCatalogObject::ColumnCatalogObject(executor::LogicalTile *tile, column_name(tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_NAME) .ToString()), column_id(tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_ID) - .GetAs()), + .GetAs()), column_offset( tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_OFFSET) - .GetAs()), + .GetAs()), column_type(StringToTypeId( tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_TYPE) .ToString())), @@ -41,9 +41,9 @@ ColumnCatalogObject::ColumnCatalogObject(executor::LogicalTile *tile, is_not_null(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_NOT_NULL) .GetAs()) {} -ColumnCatalog *ColumnCatalog::GetInstance(storage::Database *pg_catalog, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { +ColumnCatalog *ColumnCatalog::GetInstance( + storage::Database *pg_catalog, type::AbstractPool *pool, + concurrency::TransactionContext *txn) { static ColumnCatalog column_catalog{pg_catalog, pool, txn}; return &column_catalog; } @@ -63,7 +63,7 @@ ColumnCatalog::ColumnCatalog(storage::Database *pg_catalog, COLUMN_CATALOG_NAME "_skey1", IndexConstraintType::DEFAULT); // Insert columns into pg_attribute - oid_t column_id = 0; + 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.IsInlined(), @@ -141,7 +141,7 @@ std::unique_ptr ColumnCatalog::InitializeSchema() { bool ColumnCatalog::InsertColumn(oid_t table_oid, const std::string &column_name, - oid_t column_id, oid_t column_offset, + uint32_t column_id, uint32_t column_offset, type::TypeId column_type, bool is_inlined, const std::vector &constraints, type::AbstractPool *pool, diff --git a/src/include/catalog/column_catalog.h b/src/include/catalog/column_catalog.h index 56d8bf5c6b7..c0da03164cd 100644 --- a/src/include/catalog/column_catalog.h +++ b/src/include/catalog/column_catalog.h @@ -44,8 +44,8 @@ class ColumnCatalogObject { 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 uint32_t GetColumnId() { return column_id; } + inline uint32_t GetColumnOffset() { return column_offset; } inline type::TypeId GetColumnType() { return column_type; } inline bool IsInlined() { return is_inlined; } inline bool IsPrimary() { return is_primary; } @@ -55,8 +55,8 @@ class ColumnCatalogObject { // member variables oid_t table_oid; std::string column_name; - oid_t column_id; - oid_t column_offset; + uint32_t column_id; + uint32_t column_offset; type::TypeId column_type; bool is_inlined; bool is_primary; @@ -70,9 +70,10 @@ class ColumnCatalog : public AbstractCatalog { public: // Global Singleton, only the first call requires passing parameters. - static ColumnCatalog *GetInstance(storage::Database *pg_catalog = nullptr, - type::AbstractPool *pool = nullptr, - concurrency::TransactionContext *txn = nullptr); + static ColumnCatalog *GetInstance( + storage::Database *pg_catalog = nullptr, + type::AbstractPool *pool = nullptr, + concurrency::TransactionContext *txn = nullptr); ~ColumnCatalog(); @@ -83,10 +84,11 @@ 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, + uint32_t column_id, uint32_t column_offset, type::TypeId column_type, bool is_inlined, const std::vector &constraints, - type::AbstractPool *pool, concurrency::TransactionContext *txn); + 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); From bbf369b3d7aaeaf233d252185e69cbe06ecd1928 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Sun, 11 Feb 2018 16:13:50 -0500 Subject: [PATCH 07/48] using system catalog instead of singleton --- src/catalog/catalog.cpp | 201 +++++++++++++++++-------------- src/catalog/column_catalog.cpp | 17 +-- src/catalog/database_catalog.cpp | 44 ++++--- src/catalog/index_catalog.cpp | 34 ++++-- src/catalog/table_catalog.cpp | 11 +- src/include/catalog/catalog.h | 9 +- 6 files changed, 185 insertions(+), 131 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 3ed19e68dc1..dbcdd3b7075 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -148,12 +148,12 @@ void Catalog::Bootstrap() { DatabaseMetricsCatalog::GetInstance(txn); TableMetricsCatalog::GetInstance(txn); IndexMetricsCatalog::GetInstance(txn); - QueryMetricsCatalog::GetInstance(txn); + QueryMetricsCatalog::GetInstance(txn); SettingsCatalog::GetInstance(txn); TriggerCatalog::GetInstance(txn); LanguageCatalog::GetInstance(txn); ProcCatalog::GetInstance(txn); - + if (settings::SettingsManager::GetBool(settings::SettingId::brain)) { QueryHistoryCatalog::GetInstance(txn); } @@ -251,7 +251,10 @@ ResultType Catalog::CreateTable(const std::string &database_name, } // Create actual table - auto pg_table = TableCatalog::GetInstance(); + auto pg_table = + catalog_map_[database_object->GetDatabaseOid()].GetTableCatalog(); + auto pg_attribute = + catalog_map_[database_object->GetDatabaseOid()].GetColumnCatalog(); oid_t table_oid = pg_table->GetNextOid(); bool own_schema = true; bool adapt_table = false; @@ -267,10 +270,10 @@ ResultType Catalog::CreateTable(const std::string &database_name, database_object->GetDatabaseOid(), pool_.get(), txn); oid_t column_id = 0; for (const auto &column : table->GetSchema()->GetColumns()) { - ColumnCatalog::GetInstance()->InsertColumn( - table_oid, column.GetName(), column_id, column.GetOffset(), - column.GetType(), column.IsInlined(), column.GetConstraints(), - pool_.get(), txn); + pg_attribute->InsertColumn(table_oid, column.GetName(), column_id, + column.GetOffset(), column.GetType(), + column.IsInlined(), column.GetConstraints(), + pool_.get(), txn); // Create index on unique single column if (column.IsUnique()) { @@ -328,7 +331,9 @@ ResultType Catalog::CreatePrimaryIndex(oid_t database_oid, oid_t table_oid, std::string index_name = table->GetName() + "_pkey"; bool unique_keys = true; - oid_t index_oid = IndexCatalog::GetInstance()->GetNextOid(); + auto pg_index = + catalog_map_[database_object->GetDatabaseOid()].GetIndexCatalog(); + oid_t index_oid = pg_index->GetNextOid(); index_metadata = new index::IndexMetadata( index_name, index_oid, table_oid, database_oid, IndexType::BWTREE, @@ -342,10 +347,9 @@ 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 - IndexCatalog::GetInstance()->InsertIndex( - index_oid, index_name, table_oid, IndexType::BWTREE, - IndexConstraintType::PRIMARY_KEY, unique_keys, key_attrs, pool_.get(), - txn); + pg_index->InsertIndex(index_oid, index_name, table_oid, IndexType::BWTREE, + IndexConstraintType::PRIMARY_KEY, unique_keys, + key_attrs, pool_.get(), txn); LOG_TRACE("Successfully created primary key index '%s' for table '%s'", index_name.c_str(), table->GetName().c_str()); @@ -431,7 +435,8 @@ ResultType Catalog::CreateIndex( // Passed all checks, now get all index metadata LOG_TRACE("Trying to create index %s on table %d", index_name.c_str(), table_oid); - auto pg_index = IndexCatalog::GetInstance(); + auto pg_index = + catalog_map_[database_object->GetDatabaseOid()].GetIndexCatalog(); oid_t index_oid = pg_index->GetNextOid(); auto key_schema = catalog::Schema::CopySchema(schema, key_attrs); key_schema->SetIndexedColumns(key_attrs); @@ -449,9 +454,9 @@ ResultType Catalog::CreateIndex( // Put index object into rw_object_set txn->RecordCreate(database_oid, table_oid, index_oid); // Insert index record into pg_index - IndexCatalog::GetInstance()->InsertIndex( - index_oid, index_name, table_oid, index_type, index_constraint, - unique_keys, key_attrs, pool_.get(), txn); + pg_index->InsertIndex(index_oid, index_name, table_oid, index_type, + index_constraint, unique_keys, key_attrs, pool_.get(), + txn); LOG_TRACE("Successfully add index for table %s contains %d indexes", table->GetName().c_str(), (int)table->GetValidIndexCount()); @@ -561,9 +566,16 @@ ResultType Catalog::DropTable(oid_t database_oid, oid_t table_oid, auto index_objects = table_object->GetIndexObjects(); LOG_TRACE("dropping #%d indexes", (int)index_objects.size()); - for (auto it : index_objects) DropIndex(it.second->GetIndexOid(), txn); - ColumnCatalog::GetInstance()->DeleteColumns(table_oid, txn); - TableCatalog::GetInstance()->DeleteTable(table_oid, txn); + for (auto it : index_objects) + DropIndex(database_oid, it.second->GetIndexOid(), txn); + // delete record in pg_attribute + auto pg_attribute = + catalog_map_[database_object->GetDatabaseOid()].GetColumnCatalog(); + pg_attribute->DeleteColumns(table_oid, txn); + // delete record in pg_table + auto pg_table = + catalog_map_[database_object->GetDatabaseOid()].GetTableCatalog(); + pg_table->DeleteTable(table_oid, txn); database->GetTableWithOid(table_oid); txn->RecordDrop(database_oid, table_oid, INVALID_OID); @@ -576,56 +588,54 @@ 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 index_oid, +ResultType Catalog::DropIndex(oid_t database_oid, oid_t index_oid, concurrency::TransactionContext *txn) { if (txn == nullptr) throw CatalogException("Do not have transaction to drop index " + std::to_string(index_oid)); // find index catalog object by looking up pg_index or read from cache using // index_oid - auto index_object = - IndexCatalog::GetInstance()->GetIndexObject(index_oid, txn); + auto pg_index = catalog_map_[database_oid].GetIndexCatalog(); + auto index_object = pg_index->GetIndexObject(index_oid, txn); if (index_object == nullptr) { throw CatalogException("Can't find index " + std::to_string(index_oid) + " to drop"); } - // the tricky thing about drop index is that you only know index oid or - // index - // table_oid and you must obtain database_object-->table_object in reverse - // way - // invalidate index cache object in table_catalog - auto table_object = TableCatalog::GetInstance()->GetTableObject( - index_object->GetTableOid(), txn); + auto storage_manager = storage::StorageManager::GetInstance(); - auto table = storage_manager->GetTableWithOid(table_object->GetDatabaseOid(), + auto table = storage_manager->GetTableWithOid(database_oid, index_object->GetTableOid()); // drop record in pg_index - IndexCatalog::GetInstance()->DeleteIndex(index_oid, txn); + pg_index->DeleteIndex(index_oid, txn); LOG_TRACE("Successfully drop index %d for table %s", index_oid, table->GetName().c_str()); // register index object in rw_object_set table->GetIndexWithOid(index_oid); - txn->RecordDrop(table_object->GetDatabaseOid(), table_object->GetTableOid(), - index_oid); + txn->RecordDrop(database_oid, index_object->GetTableOid(), index_oid); return ResultType::SUCCESS; } -ResultType Catalog::DropIndex(const std::string &index_name, +ResultType Catalog::DropIndex(const std::string &database_name, + const std::string &index_name, concurrency::TransactionContext *txn) { - if(txn == nullptr) { - throw CatalogException("Do not have transaction to drop index " + - index_name); - } - auto index_object = catalog::IndexCatalog::GetInstance()->GetIndexObject( - index_name, txn); - if(index_object == nullptr) { - throw CatalogException("Index name " + index_name + " cannot be found"); - } - ResultType result = DropIndex(index_object->GetIndexOid(), txn); + if (txn == nullptr) { + throw CatalogException("Do not have transaction to drop index " + + index_name); + } + auto database_object = + DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); + auto pg_index = catalog_map_[database_oid].GetIndexCatalog(); + auto index_object = pg_index->GetIndexObject(index_name, txn); + + if (index_object == nullptr || database_object == nullptr) { + throw CatalogException("Index name " + index_name + " cannot be found"); + } + ResultType result = DropIndex(database_object->GetDatabaseOid(), + index_object->GetIndexOid(), txn); - return result; + return result; } //===--------------------------------------------------------------------===// @@ -787,6 +797,13 @@ std::shared_ptr Catalog::GetTableObject( return table_object; } +SystemCatalog Catalog::GetSystemCatalog(const oid_t database_oid) { + if (catalog_map_.find(database_oid) == catalog_map_.end()) { + throw CatalogException("Failed to find SystemCatalog " + database_oid); + } + return catalog_map_[database_oid]; +} + //===--------------------------------------------------------------------===// // DEPRECATED //===--------------------------------------------------------------------===// @@ -1064,15 +1081,16 @@ void Catalog::InitializeFunctions() { /** * decimal functions */ - AddBuiltinFunction( - "abs", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Abs", function::BuiltInFuncType{OperatorId::Abs, - function::DecimalFunctions::_Abs}, - txn); + AddBuiltinFunction("abs", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, + internal_lang, "Abs", + function::BuiltInFuncType{ + OperatorId::Abs, function::DecimalFunctions::_Abs}, + txn); AddBuiltinFunction( "sqrt", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::SMALLINT}, type::TypeId::DECIMAL, @@ -1082,18 +1100,21 @@ void Catalog::InitializeFunctions() { txn); AddBuiltinFunction( "sqrt", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "floor", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, @@ -1105,33 +1126,29 @@ void Catalog::InitializeFunctions() { /** * integer functions */ - AddBuiltinFunction( - "abs", {type::TypeId::TINYINT}, type::TypeId::TINYINT, - internal_lang, "Abs", - function::BuiltInFuncType{OperatorId::Abs, - function::DecimalFunctions::_Abs}, - txn); + AddBuiltinFunction("abs", {type::TypeId::TINYINT}, type::TypeId::TINYINT, + internal_lang, "Abs", + function::BuiltInFuncType{ + OperatorId::Abs, function::DecimalFunctions::_Abs}, + txn); - AddBuiltinFunction( - "abs", {type::TypeId::SMALLINT}, type::TypeId::SMALLINT, - internal_lang, "Abs", - function::BuiltInFuncType{OperatorId::Abs, - function::DecimalFunctions::_Abs}, - txn); + AddBuiltinFunction("abs", {type::TypeId::SMALLINT}, + type::TypeId::SMALLINT, internal_lang, "Abs", + function::BuiltInFuncType{ + OperatorId::Abs, function::DecimalFunctions::_Abs}, + txn); - AddBuiltinFunction( - "abs", {type::TypeId::INTEGER}, type::TypeId::INTEGER, - internal_lang, "Abs", - function::BuiltInFuncType{OperatorId::Abs, - function::DecimalFunctions::_Abs}, - txn); + AddBuiltinFunction("abs", {type::TypeId::INTEGER}, type::TypeId::INTEGER, + internal_lang, "Abs", + function::BuiltInFuncType{ + OperatorId::Abs, function::DecimalFunctions::_Abs}, + txn); - AddBuiltinFunction( - "abs", {type::TypeId::BIGINT}, type::TypeId::BIGINT, - internal_lang, "Abs", - function::BuiltInFuncType{OperatorId::Abs, - function::DecimalFunctions::_Abs}, - txn); + AddBuiltinFunction("abs", {type::TypeId::BIGINT}, type::TypeId::BIGINT, + internal_lang, "Abs", + function::BuiltInFuncType{ + OperatorId::Abs, function::DecimalFunctions::_Abs}, + txn); AddBuiltinFunction( "floor", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, @@ -1166,14 +1183,16 @@ void Catalog::InitializeFunctions() { AddBuiltinFunction( "ceil", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Ceil", function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( "ceil", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang, - "Ceil", function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( @@ -1185,14 +1204,16 @@ void Catalog::InitializeFunctions() { AddBuiltinFunction( "ceil", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, internal_lang, - "Ceil", function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( "ceil", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Ceil", function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index ec34f95622c..1654688ba67 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -193,8 +193,9 @@ bool ColumnCatalog::DeleteColumn(oid_t table_oid, type::ValueFactory::GetVarcharValue(column_name, nullptr).Copy()); // delete column from cache - auto table_object = - TableCatalog::GetInstance()->GetTableObject(table_oid, txn); + auto pg_table = + Catalog::GetInstance()->GetSystemCatalog(database_oid).GetTableCatalog(); + auto table_object = pg_table->GetTableObject(table_oid, txn); table_object->EvictColumnObject(column_name); return DeleteWithIndexScan(index_offset, values, txn); @@ -213,8 +214,9 @@ bool ColumnCatalog::DeleteColumns(oid_t table_oid, values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); // delete columns from cache - auto table_object = - TableCatalog::GetInstance()->GetTableObject(table_oid, txn); + auto pg_table = + Catalog::GetInstance()->GetSystemCatalog(database_oid).GetTableCatalog(); + auto table_object = pg_table->GetTableObject(table_oid, txn); table_object->EvictAllColumnObjects(); return DeleteWithIndexScan(index_offset, values, txn); @@ -224,9 +226,10 @@ const std::unordered_map> ColumnCatalog::GetColumnObjects(oid_t table_oid, concurrency::TransactionContext *txn) { // try get from cache - auto table_object = - TableCatalog::GetInstance()->GetTableObject(table_oid, txn); - PELOTON_ASSERT(table_object && table_object->GetTableOid() == table_oid); + auto pg_table = + Catalog::GetInstance()->GetSystemCatalog(database_oid).GetTableCatalog(); + auto table_object = pg_table->GetTableObject(table_oid, txn); + PL_ASSERT(table_object && table_object->GetTableOid() == table_oid); auto column_objects = table_object->GetColumnObjects(true); if (column_objects.size() != 0) return column_objects; diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 8786743973a..5297c909244 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -14,9 +14,9 @@ #include "catalog/database_catalog.h" -#include "concurrency/transaction_context.h" -#include "catalog/table_catalog.h" #include "catalog/column_catalog.h" +#include "catalog/table_catalog.h" +#include "concurrency/transaction_context.h" #include "executor/logical_tile.h" #include "storage/data_table.h" #include "storage/tuple.h" @@ -25,8 +25,8 @@ namespace peloton { namespace catalog { -DatabaseCatalogObject::DatabaseCatalogObject(executor::LogicalTile *tile, - concurrency::TransactionContext *txn) +DatabaseCatalogObject::DatabaseCatalogObject( + executor::LogicalTile *tile, concurrency::TransactionContext *txn) : database_oid(tile->GetValue(0, DatabaseCatalog::ColumnId::DATABASE_OID) .GetAs()), database_name(tile->GetValue(0, DatabaseCatalog::ColumnId::DATABASE_NAME) @@ -104,7 +104,7 @@ bool DatabaseCatalogObject::EvictTableObject(const std::string &table_name) { } /*@brief evict all table catalog objects in this database from cache -*/ + */ void DatabaseCatalogObject::EvictAllTableObjects() { table_objects_cache.clear(); table_name_cache.clear(); @@ -125,7 +125,10 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( return nullptr; } else { // cache miss get from pg_table - return TableCatalog::GetInstance()->GetTableObject(table_oid, txn); + auto pg_table = Catalog::GetInstance() + ->GetSystemCatalog(database_oid) + .GetTableCatalog(); + return pg_table->GetTableObject(table_oid, txn); } } @@ -145,8 +148,10 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( return nullptr; } else { // cache miss get from pg_table - return TableCatalog::GetInstance()->GetTableObject(table_name, database_oid, - txn); + auto pg_table = Catalog::GetInstance() + ->GetSystemCatalog(database_oid) + .GetTableCatalog(); + return pg_table->GetTableObject(table_name, database_oid, txn); } } @@ -159,7 +164,10 @@ std::unordered_map> DatabaseCatalogObject::GetTableObjects(bool cached_only) { if (!cached_only && !valid_table_objects) { // cache miss get from pg_table - return TableCatalog::GetInstance()->GetTableObjects(database_oid, txn); + auto pg_table = Catalog::GetInstance() + ->GetSystemCatalog(database_oid) + .GetTableCatalog(); + return pg_table->GetTableObjects(database_oid, txn); } // make sure to check IsValidTableObjects() before getting table objects PELOTON_ASSERT(valid_table_objects); @@ -167,9 +175,9 @@ DatabaseCatalogObject::GetTableObjects(bool cached_only) { } /*@brief search index catalog object from all cached database objects -* @param index_oid -* @return index catalog object; if not found return null -*/ + * @param index_oid + * @return index catalog object; if not found return null + */ std::shared_ptr DatabaseCatalogObject::GetCachedIndexObject( oid_t index_oid) { for (auto it = table_objects_cache.begin(); it != table_objects_cache.end(); @@ -182,9 +190,9 @@ std::shared_ptr DatabaseCatalogObject::GetCachedIndexObject( } /*@brief search index catalog object from all cached database objects -* @param index_name -* @return index catalog object; if not found return null -*/ + * @param index_name + * @return index catalog object; if not found return null + */ std::shared_ptr DatabaseCatalogObject::GetCachedIndexObject( const std::string &index_name) { for (auto it = table_objects_cache.begin(); it != table_objects_cache.end(); @@ -196,9 +204,9 @@ std::shared_ptr DatabaseCatalogObject::GetCachedIndexObject( return nullptr; } -DatabaseCatalog *DatabaseCatalog::GetInstance(storage::Database *pg_catalog, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { +DatabaseCatalog *DatabaseCatalog::GetInstance( + storage::Database *pg_catalog, type::AbstractPool *pool, + concurrency::TransactionContext *txn) { static DatabaseCatalog database_catalog{pg_catalog, pool, txn}; return &database_catalog; } diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index 6c32be70a3e..ef7d5c9d4a0 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -14,9 +14,9 @@ #include -#include "concurrency/transaction_context.h" -#include "catalog/table_catalog.h" #include "catalog/column_catalog.h" +#include "catalog/table_catalog.h" +#include "concurrency/transaction_context.h" #include "executor/logical_tile.h" #include "storage/data_table.h" #include "storage/tuple.h" @@ -175,7 +175,8 @@ bool IndexCatalog::InsertIndex(oid_t index_oid, const std::string &index_name, return InsertTuple(std::move(tuple), txn); } -bool IndexCatalog::DeleteIndex(oid_t index_oid, concurrency::TransactionContext *txn) { +bool IndexCatalog::DeleteIndex(oid_t index_oid, + concurrency::TransactionContext *txn) { oid_t index_offset = IndexId::PRIMARY_KEY; // Index of index_oid std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(index_oid).Copy()); @@ -214,9 +215,12 @@ std::shared_ptr IndexCatalog::GetIndexObject( auto index_object = std::make_shared((*result_tiles)[0].get()); // fetch all indexes into table object (cannot use the above index object) - auto table_object = TableCatalog::GetInstance()->GetTableObject( - index_object->GetTableOid(), txn); - PELOTON_ASSERT(table_object && + auto pg_table = Catalog::GetInstance() + ->GetSystemCatalog(database_oid) + .GetTableCatalog(); + auto table_object = + pg_table->GetTableObject(index_object->GetTableOid(), txn); + PL_ASSERT(table_object && table_object->GetTableOid() == index_object->GetTableOid()); return table_object->GetIndexObject(index_oid); } else { @@ -252,9 +256,12 @@ std::shared_ptr IndexCatalog::GetIndexObject( auto index_object = std::make_shared((*result_tiles)[0].get()); // fetch all indexes into table object (cannot use the above index object) - auto table_object = TableCatalog::GetInstance()->GetTableObject( - index_object->GetTableOid(), txn); - PELOTON_ASSERT(table_object && + auto pg_table = Catalog::GetInstance() + ->GetSystemCatalog(database_oid) + .GetTableCatalog(); + auto table_object = + pg_table->GetTableObject(index_object->GetTableOid(), txn); + PL_ASSERT(table_object && table_object->GetTableOid() == index_object->GetTableOid()); return table_object->GetIndexObject(index_name); } else { @@ -273,14 +280,17 @@ std::shared_ptr IndexCatalog::GetIndexObject( * @return a vector of index catalog objects */ const std::unordered_map> -IndexCatalog::GetIndexObjects(oid_t table_oid, concurrency::TransactionContext *txn) { +IndexCatalog::GetIndexObjects(oid_t table_oid, + concurrency::TransactionContext *txn) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } // try get from cache + auto pg_table = + Catalog::GetInstance()->GetSystemCatalog(database_oid).GetTableCatalog(); auto table_object = - TableCatalog::GetInstance()->GetTableObject(table_oid, txn); - PELOTON_ASSERT(table_object && table_object->GetTableOid() == table_oid); + pg_table->GetTableObject(index_object->GetTableOid(), txn); + PL_ASSERT(table_object && table_object->GetTableOid() == table_oid); auto index_objects = table_object->GetIndexObjects(true); if (index_objects.empty() == false) return index_objects; diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index a80e0898023..9c897f6456d 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -129,8 +129,10 @@ TableCatalogObject::GetIndexObjects(bool cached_only) { if (!valid_index_objects && !cached_only) { // get index catalog objects from pg_index valid_index_objects = true; - index_objects = - IndexCatalog::GetInstance()->GetIndexObjects(table_oid, txn); + auto pg_index = Catalog::GetInstance() + ->GetSystemCatalog(database_oid) + .GetIndexCatalog(); + index_objects = pg_index->GetIndexObjects(table_oid, txn); } return index_objects; } @@ -253,7 +255,10 @@ std::unordered_map> TableCatalogObject::GetColumnObjects(bool cached_only) { if (!valid_column_objects && !cached_only) { // get column catalog objects from pg_column - ColumnCatalog::GetInstance()->GetColumnObjects(table_oid, txn); + auto pg_attribute = Catalog::GetInstance() + ->GetSystemCatalog(database_oid) + .GetColumnCatalog(); + pg_attribute->GetColumnObjects(table_oid, txn); valid_column_objects = true; } return column_objects; diff --git a/src/include/catalog/catalog.h b/src/include/catalog/catalog.h index f060e26c5bc..4eaa77c9119 100644 --- a/src/include/catalog/catalog.h +++ b/src/include/catalog/catalog.h @@ -176,6 +176,11 @@ class Catalog { std::shared_ptr GetTableObject( oid_t database_oid, oid_t table_oid, concurrency::TransactionContext *txn); + + /* + * Using database oid to get system catalog object + */ + SystemCatalog GetSystemCatalog(const oid_t database_oid); //===--------------------------------------------------------------------===// // DEPRECATED FUNCTIONS //===--------------------------------------------------------------------===// @@ -217,8 +222,10 @@ class Catalog { // The pool for new varlen tuple fields std::unique_ptr pool_; - std::mutex catalog_mutex; + // key: database oid + // value: SystemCatalog object(including pg_table, pg_index and pg_attribute) + std::unordered_map catalog_map_; }; } // namespace catalog From 08b845e862879ebac35c96efb64cf6005f615887 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Sun, 21 Jan 2018 19:51:28 -0500 Subject: [PATCH 08/48] add update method using old engine --- src/catalog/abstract_catalog.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index cf2b1990c51..2b34e781fa7 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -356,7 +356,6 @@ bool AbstractCatalog::UpdateWithIndexScan( for (size_t i = 0; i < update_values.size(); i++) { planner::DerivedAttribute update_attribute{ new expression::ConstantValueExpression(update_values[i])}; - // emplace(update_column_id, update_val) target_list.emplace_back(update_columns[i], update_attribute); } From 4436a681eda569f0a51910226ef0c4a49db16447 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sun, 11 Feb 2018 16:08:31 -0500 Subject: [PATCH 09/48] system catalogs --- src/catalog/catalog.cpp | 52 +++++++++++++++------------ src/catalog/column_catalog.cpp | 2 ++ src/catalog/index_catalog.cpp | 2 ++ src/catalog/system_catalogs.cpp | 46 ++++++++++++++++++++++++ src/include/catalog/catalog.h | 3 ++ src/include/catalog/column_catalog.h | 2 ++ src/include/catalog/index_catalog.h | 2 ++ src/include/catalog/system_catalogs.h | 41 +++++++++++++++++++++ 8 files changed, 128 insertions(+), 22 deletions(-) create mode 100644 src/catalog/system_catalogs.cpp create mode 100644 src/include/catalog/system_catalogs.h diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index dbcdd3b7075..b2b938bf6ae 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -63,9 +63,16 @@ Catalog::Catalog() : pool_(new type::EphemeralPool()) { // Create catalog tables auto pg_database = DatabaseCatalog::GetInstance(pg_catalog, pool_.get(), txn); - auto pg_table = TableCatalog::GetInstance(pg_catalog, pool_.get(), txn); - IndexCatalog::GetInstance(pg_catalog, pool_.get(), txn); - // ColumnCatalog::GetInstance(); // Called implicitly + BootstrapSystemCatalogs(pg_catalog, txn); + + // Commit transaction + txn_manager.CommitTransaction(txn); +} + +void Catalog::BootstrapSystemCatalogs(Database *database, + concurrency::TransactionContext *txn) { + auto &system_catalogs = catalog_map_[database_oid] = + SystemCatalogs(database, pool_.get(), txn); // Create indexes on catalog tables, insert them into pg_index // note that CreateIndex() from catalog.cpp will create index on storage level @@ -94,51 +101,52 @@ Catalog::Catalog() : pool_(new type::EphemeralPool()) { // actual index already added in column_catalog, index_catalog constructor // the reason we treat those two catalog tables differently is that indexes // needs to be built before insert tuples into table - IndexCatalog::GetInstance()->InsertIndex( + system_catalogs.GetIndexCatalog()->InsertIndex( COLUMN_CATALOG_PKEY_OID, COLUMN_CATALOG_NAME "_pkey", COLUMN_CATALOG_OID, IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, true, {ColumnCatalog::ColumnId::TABLE_OID, ColumnCatalog::ColumnId::COLUMN_NAME}, pool_.get(), txn); - IndexCatalog::GetInstance()->InsertIndex( + system_catalogs.GetIndexCatalog()->InsertIndex( COLUMN_CATALOG_SKEY0_OID, COLUMN_CATALOG_NAME "_skey0", COLUMN_CATALOG_OID, IndexType::BWTREE, IndexConstraintType::UNIQUE, true, {ColumnCatalog::ColumnId::TABLE_OID, ColumnCatalog::ColumnId::COLUMN_ID}, pool_.get(), txn); - IndexCatalog::GetInstance()->InsertIndex( + system_catalogs.GetIndexCatalog()->InsertIndex( COLUMN_CATALOG_SKEY1_OID, COLUMN_CATALOG_NAME "_skey1", COLUMN_CATALOG_OID, IndexType::BWTREE, IndexConstraintType::DEFAULT, false, {ColumnCatalog::ColumnId::TABLE_OID}, pool_.get(), txn); - IndexCatalog::GetInstance()->InsertIndex( + system_catalogs.GetIndexCatalog()->InsertIndex( INDEX_CATALOG_PKEY_OID, INDEX_CATALOG_NAME "_pkey", INDEX_CATALOG_OID, IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, true, {IndexCatalog::ColumnId::INDEX_OID}, pool_.get(), txn); - IndexCatalog::GetInstance()->InsertIndex( + system_catalogs.GetIndexCatalog()->InsertIndex( INDEX_CATALOG_SKEY0_OID, INDEX_CATALOG_NAME "_skey0", INDEX_CATALOG_OID, IndexType::BWTREE, IndexConstraintType::UNIQUE, true, {IndexCatalog::ColumnId::INDEX_NAME}, pool_.get(), txn); - IndexCatalog::GetInstance()->InsertIndex( + system_catalogs.GetIndexCatalog()->InsertIndex( INDEX_CATALOG_SKEY1_OID, INDEX_CATALOG_NAME "_skey1", INDEX_CATALOG_OID, IndexType::BWTREE, IndexConstraintType::DEFAULT, false, {IndexCatalog::ColumnId::TABLE_OID}, pool_.get(), txn); // Insert pg_catalog database into pg_database - pg_database->InsertDatabase(CATALOG_DATABASE_OID, CATALOG_DATABASE_NAME, - pool_.get(), txn); + DatabaseCatalog::GetInstance()->InsertDatabase( + CATALOG_DATABASE_OID, CATALOG_DATABASE_NAME, pool_.get(), txn); // Insert catalog tables into pg_table - pg_table->InsertTable(DATABASE_CATALOG_OID, DATABASE_CATALOG_NAME, - CATALOG_DATABASE_OID, pool_.get(), txn); - pg_table->InsertTable(TABLE_CATALOG_OID, TABLE_CATALOG_NAME, - CATALOG_DATABASE_OID, pool_.get(), txn); - pg_table->InsertTable(INDEX_CATALOG_OID, INDEX_CATALOG_NAME, - CATALOG_DATABASE_OID, pool_.get(), txn); - pg_table->InsertTable(COLUMN_CATALOG_OID, COLUMN_CATALOG_NAME, - CATALOG_DATABASE_OID, pool_.get(), txn); - - // Commit transaction - txn_manager.CommitTransaction(txn); + system_catalogs.GetTableCatalog()->InsertTable( + DATABASE_CATALOG_OID, DATABASE_CATALOG_NAME, CATALOG_DATABASE_OID, + pool_.get(), txn); + system_catalogs.GetTableCatalog()->InsertTable( + TABLE_CATALOG_OID, TABLE_CATALOG_NAME, CATALOG_DATABASE_OID, pool_.get(), + txn); + system_catalogs.GetTableCatalog()->InsertTable( + INDEX_CATALOG_OID, INDEX_CATALOG_NAME, CATALOG_DATABASE_OID, pool_.get(), + txn); + system_catalogs.GetTableCatalog()->InsertTable( + COLUMN_CATALOG_OID, COLUMN_CATALOG_NAME, CATALOG_DATABASE_OID, + pool_.get(), txn); } void Catalog::Bootstrap() { diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index 1654688ba67..362cf883dad 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -53,6 +53,8 @@ ColumnCatalog::ColumnCatalog(storage::Database *pg_catalog, concurrency::TransactionContext *txn) : AbstractCatalog(COLUMN_CATALOG_OID, COLUMN_CATALOG_NAME, InitializeSchema().release(), pg_catalog) { + database_oid = pg_catalog->GetOid(); + // Add indexes for pg_attribute AddIndex({ColumnId::TABLE_OID, ColumnId::COLUMN_NAME}, COLUMN_CATALOG_PKEY_OID, COLUMN_CATALOG_NAME "_pkey", diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index ef7d5c9d4a0..d32da60577f 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -63,6 +63,8 @@ IndexCatalog::IndexCatalog(storage::Database *pg_catalog, concurrency::TransactionContext *txn) : AbstractCatalog(INDEX_CATALOG_OID, INDEX_CATALOG_NAME, InitializeSchema().release(), pg_catalog) { + database_oid = pg_catalog->GetOid(); + // Add indexes for pg_index AddIndex({0}, INDEX_CATALOG_PKEY_OID, INDEX_CATALOG_NAME "_pkey", IndexConstraintType::PRIMARY_KEY); diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp new file mode 100644 index 00000000000..4762ed395ae --- /dev/null +++ b/src/catalog/system_catalogs.cpp @@ -0,0 +1,46 @@ +//===----------------------------------------------------------------------===// +// +// Peloton +// +// system_catalog.cpp +// +// Identification: src/catalog/system_catalog.cpp +// +// Copyright (c) 2015-18, Carnegie Mellon University Database Group +// +//===----------------------------------------------------------------------===// + +namespace peloton { +namespace catalog { + +SystemCatalogs::SystemCatalogs(storage::Database *database, + type::AbstractPool *pool, + concurrency::TransactionContext *txn) { + pg_attribute = new ColumnCatalog(database, pool, txn); + + oid_t column_id = 0; + for (auto column : + StorageManager::GetInstance() + ->GetTableWithOid(CATALOG_DATABASE_OID, DATABASE_CATALOG_OID) + ->GetSchema() + ->GetColumns()) { + pg_attribute->InsertColumn(DATABASE_CATALOG_OID, column.GetName(), + column_id, column.GetOffset(), column.GetType(), + column.IsInlined(), column.GetConstraints(), + pool, txn); + column_id++; + } + + pg_table = new TableCatalog(database, pool, txn); + + pg_index = new IndexCatalog(database, pool, txn); +} + +SystemCatalogs::~SystemCatalogs() { + delete IndexCatalog; + delete TableCatalog; + delete ColumnCatalog; +} + +} // namespace catalog +} // namespace peloton diff --git a/src/include/catalog/catalog.h b/src/include/catalog/catalog.h index 4eaa77c9119..b0c64db28d0 100644 --- a/src/include/catalog/catalog.h +++ b/src/include/catalog/catalog.h @@ -220,6 +220,9 @@ class Catalog { private: Catalog(); + void BootstrapSystemCatalogs(Database *database, + concurrency::TransactionContext *txn); + // The pool for new varlen tuple fields std::unique_ptr pool_; std::mutex catalog_mutex; diff --git a/src/include/catalog/column_catalog.h b/src/include/catalog/column_catalog.h index c0da03164cd..9cb561e2ec0 100644 --- a/src/include/catalog/column_catalog.h +++ b/src/include/catalog/column_catalog.h @@ -94,6 +94,8 @@ class ColumnCatalog : public AbstractCatalog { bool DeleteColumns(oid_t table_oid, concurrency::TransactionContext *txn); private: + oid_t database_oid; + //===--------------------------------------------------------------------===// // Read Related API(only called within table catalog object) //===--------------------------------------------------------------------===// diff --git a/src/include/catalog/index_catalog.h b/src/include/catalog/index_catalog.h index 3e49cf68e91..c6b2abe2045 100644 --- a/src/include/catalog/index_catalog.h +++ b/src/include/catalog/index_catalog.h @@ -100,6 +100,8 @@ class IndexCatalog : public AbstractCatalog { GetIndexObjects(oid_t table_oid, concurrency::TransactionContext *txn); private: + oid_t database_oid; + IndexCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, concurrency::TransactionContext *txn); diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h new file mode 100644 index 00000000000..d1ef0ce4309 --- /dev/null +++ b/src/include/catalog/system_catalogs.h @@ -0,0 +1,41 @@ +//===----------------------------------------------------------------------===// +// +// Peloton +// +// system_catalog.h +// +// Identification: src/include/catalog/system_catalog.h +// +// Copyright (c) 2015-18, Carnegie Mellon University Database Group +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include + +#include "catalog/database_catalog.h" +#include "catalog/table_catalog.h" + +namespace peloton { +namespace catalog { + +class SystemCatalogs { + public: + SystemCatalogs(storage::Database *database, type::AbstractPool *pool, + concurrency::TransactionContext *txn); + + ~SystemCatalogs(); + + ColumnCatalog *GetColumnCatalog() { return pg_attribute; } + TableCatalog *GetTableCatalog() { return pg_table; } + IndexCatalog *GetIndexCatalog() { return pg_index; } + + private: + ColumnCatalog *pg_attribute; + TableCatalog *pg_table; + IndexCatalog *pg_index; +}; + +} // namespace catalog +} // namespace peloton From 666b8d2e44b6428e54857332b20b0d92b76faa39 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sun, 11 Feb 2018 16:22:42 -0500 Subject: [PATCH 10/48] remove default constructer --- src/catalog/catalog.cpp | 42 +++++++++++---------------- src/include/catalog/catalog.h | 2 +- src/include/catalog/system_catalogs.h | 2 ++ 3 files changed, 20 insertions(+), 26 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index b2b938bf6ae..a40846eb840 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -805,7 +805,7 @@ std::shared_ptr Catalog::GetTableObject( return table_object; } -SystemCatalog Catalog::GetSystemCatalog(const oid_t database_oid) { +SystemCatalogs Catalog::GetSystemCatalog(const oid_t database_oid) { if (catalog_map_.find(database_oid) == catalog_map_.end()) { throw CatalogException("Failed to find SystemCatalog " + database_oid); } @@ -1096,9 +1096,8 @@ void Catalog::InitializeFunctions() { txn); AddBuiltinFunction( "sqrt", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::SMALLINT}, type::TypeId::DECIMAL, @@ -1108,21 +1107,18 @@ void Catalog::InitializeFunctions() { txn); AddBuiltinFunction( "sqrt", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "floor", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, @@ -1191,16 +1187,14 @@ void Catalog::InitializeFunctions() { AddBuiltinFunction( "ceil", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( "ceil", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang, - "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( @@ -1212,16 +1206,14 @@ void Catalog::InitializeFunctions() { AddBuiltinFunction( "ceil", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, internal_lang, - "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( "ceil", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( diff --git a/src/include/catalog/catalog.h b/src/include/catalog/catalog.h index b0c64db28d0..e3c39449415 100644 --- a/src/include/catalog/catalog.h +++ b/src/include/catalog/catalog.h @@ -228,7 +228,7 @@ class Catalog { std::mutex catalog_mutex; // key: database oid // value: SystemCatalog object(including pg_table, pg_index and pg_attribute) - std::unordered_map catalog_map_; + std::unordered_map catalog_map_; }; } // namespace catalog diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h index d1ef0ce4309..f75b370f79e 100644 --- a/src/include/catalog/system_catalogs.h +++ b/src/include/catalog/system_catalogs.h @@ -22,6 +22,8 @@ namespace catalog { class SystemCatalogs { public: + SystemCatalogs() = delete; + SystemCatalogs(storage::Database *database, type::AbstractPool *pool, concurrency::TransactionContext *txn); From 3dd4bfe16179be8b722c0b35887000e4d1bbc43e Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sun, 11 Feb 2018 16:26:59 -0500 Subject: [PATCH 11/48] fix catalog map --- src/catalog/catalog.cpp | 25 +++++++++++++------------ src/include/catalog/catalog.h | 2 +- 2 files changed, 14 insertions(+), 13 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index a40846eb840..7b82abd57b8 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -71,8 +71,8 @@ Catalog::Catalog() : pool_(new type::EphemeralPool()) { void Catalog::BootstrapSystemCatalogs(Database *database, concurrency::TransactionContext *txn) { - auto &system_catalogs = catalog_map_[database_oid] = - SystemCatalogs(database, pool_.get(), txn); + auto system_catalogs = catalog_map_[database_oid] = + new SystemCatalogs(database, pool_.get(), txn); // Create indexes on catalog tables, insert them into pg_index // note that CreateIndex() from catalog.cpp will create index on storage level @@ -260,9 +260,9 @@ ResultType Catalog::CreateTable(const std::string &database_name, // Create actual table auto pg_table = - catalog_map_[database_object->GetDatabaseOid()].GetTableCatalog(); + catalog_map_[database_object->GetDatabaseOid()]->GetTableCatalog(); auto pg_attribute = - catalog_map_[database_object->GetDatabaseOid()].GetColumnCatalog(); + catalog_map_[database_object->GetDatabaseOid()]->GetColumnCatalog(); oid_t table_oid = pg_table->GetNextOid(); bool own_schema = true; bool adapt_table = false; @@ -340,7 +340,7 @@ ResultType Catalog::CreatePrimaryIndex(oid_t database_oid, oid_t table_oid, bool unique_keys = true; auto pg_index = - catalog_map_[database_object->GetDatabaseOid()].GetIndexCatalog(); + catalog_map_[database_object->GetDatabaseOid()]->GetIndexCatalog(); oid_t index_oid = pg_index->GetNextOid(); index_metadata = new index::IndexMetadata( @@ -444,7 +444,7 @@ ResultType Catalog::CreateIndex( LOG_TRACE("Trying to create index %s on table %d", index_name.c_str(), table_oid); auto pg_index = - catalog_map_[database_object->GetDatabaseOid()].GetIndexCatalog(); + catalog_map_[database_object->GetDatabaseOid()]->GetIndexCatalog(); oid_t index_oid = pg_index->GetNextOid(); auto key_schema = catalog::Schema::CopySchema(schema, key_attrs); key_schema->SetIndexedColumns(key_attrs); @@ -578,11 +578,11 @@ ResultType Catalog::DropTable(oid_t database_oid, oid_t table_oid, DropIndex(database_oid, it.second->GetIndexOid(), txn); // delete record in pg_attribute auto pg_attribute = - catalog_map_[database_object->GetDatabaseOid()].GetColumnCatalog(); + catalog_map_[database_object->GetDatabaseOid()]->GetColumnCatalog(); pg_attribute->DeleteColumns(table_oid, txn); // delete record in pg_table auto pg_table = - catalog_map_[database_object->GetDatabaseOid()].GetTableCatalog(); + catalog_map_[database_object->GetDatabaseOid()]->GetTableCatalog(); pg_table->DeleteTable(table_oid, txn); database->GetTableWithOid(table_oid); @@ -603,7 +603,7 @@ ResultType Catalog::DropIndex(oid_t database_oid, oid_t 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 pg_index = catalog_map_[database_oid]->GetIndexCatalog(); auto index_object = pg_index->GetIndexObject(index_oid, txn); if (index_object == nullptr) { throw CatalogException("Can't find index " + std::to_string(index_oid) + @@ -634,7 +634,7 @@ ResultType Catalog::DropIndex(const std::string &database_name, } auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); - auto pg_index = catalog_map_[database_oid].GetIndexCatalog(); + auto pg_index = catalog_map_[database_oid]->GetIndexCatalog(); auto index_object = pg_index->GetIndexObject(index_name, txn); if (index_object == nullptr || database_object == nullptr) { @@ -805,9 +805,10 @@ std::shared_ptr Catalog::GetTableObject( return table_object; } -SystemCatalogs Catalog::GetSystemCatalog(const oid_t database_oid) { +shared_ptr Catalog::GetSystemCatalog(const oid_t database_oid) { if (catalog_map_.find(database_oid) == catalog_map_.end()) { - throw CatalogException("Failed to find SystemCatalog " + database_oid); + throw CatalogException("Failed to find SystemCatalog for database_oid = " + + database_oid); } return catalog_map_[database_oid]; } diff --git a/src/include/catalog/catalog.h b/src/include/catalog/catalog.h index e3c39449415..f44ca2caa3b 100644 --- a/src/include/catalog/catalog.h +++ b/src/include/catalog/catalog.h @@ -228,7 +228,7 @@ class Catalog { std::mutex catalog_mutex; // key: database oid // value: SystemCatalog object(including pg_table, pg_index and pg_attribute) - std::unordered_map catalog_map_; + std::unordered_map> catalog_map_; }; } // namespace catalog From 2f6d937fce8d46dbc7bce088023c30741fe2ec32 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Sun, 11 Feb 2018 16:30:31 -0500 Subject: [PATCH 12/48] system catalog return value change to shared pointer --- src/catalog/column_catalog.cpp | 6 +++--- src/catalog/database_catalog.cpp | 6 +++--- src/catalog/index_catalog.cpp | 6 +++--- src/catalog/table_catalog.cpp | 4 ++-- src/executor/drop_executor.cpp | 17 +++++++++++------ src/include/catalog/catalog.h | 2 +- 6 files changed, 23 insertions(+), 18 deletions(-) diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index 362cf883dad..986f638d282 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -196,7 +196,7 @@ bool ColumnCatalog::DeleteColumn(oid_t table_oid, // delete column from cache auto pg_table = - Catalog::GetInstance()->GetSystemCatalog(database_oid).GetTableCatalog(); + Catalog::GetInstance()->GetSystemCatalog(database_oid)->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); table_object->EvictColumnObject(column_name); @@ -217,7 +217,7 @@ bool ColumnCatalog::DeleteColumns(oid_t table_oid, // delete columns from cache auto pg_table = - Catalog::GetInstance()->GetSystemCatalog(database_oid).GetTableCatalog(); + Catalog::GetInstance()->GetSystemCatalog(database_oid)->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); table_object->EvictAllColumnObjects(); @@ -229,7 +229,7 @@ ColumnCatalog::GetColumnObjects(oid_t table_oid, concurrency::TransactionContext *txn) { // try get from cache auto pg_table = - Catalog::GetInstance()->GetSystemCatalog(database_oid).GetTableCatalog(); + Catalog::GetInstance()->GetSystemCatalog(database_oid)->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); PL_ASSERT(table_object && table_object->GetTableOid() == table_oid); auto column_objects = table_object->GetColumnObjects(true); diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 5297c909244..79a8eb116dc 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -127,7 +127,7 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( // cache miss get from pg_table auto pg_table = Catalog::GetInstance() ->GetSystemCatalog(database_oid) - .GetTableCatalog(); + ->GetTableCatalog(); return pg_table->GetTableObject(table_oid, txn); } } @@ -150,7 +150,7 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( // cache miss get from pg_table auto pg_table = Catalog::GetInstance() ->GetSystemCatalog(database_oid) - .GetTableCatalog(); + ->GetTableCatalog(); return pg_table->GetTableObject(table_name, database_oid, txn); } } @@ -166,7 +166,7 @@ DatabaseCatalogObject::GetTableObjects(bool cached_only) { // cache miss get from pg_table auto pg_table = Catalog::GetInstance() ->GetSystemCatalog(database_oid) - .GetTableCatalog(); + ->GetTableCatalog(); return pg_table->GetTableObjects(database_oid, txn); } // make sure to check IsValidTableObjects() before getting table objects diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index d32da60577f..3f20dd38618 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -219,7 +219,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( // fetch all indexes into table object (cannot use the above index object) auto pg_table = Catalog::GetInstance() ->GetSystemCatalog(database_oid) - .GetTableCatalog(); + ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(index_object->GetTableOid(), txn); PL_ASSERT(table_object && @@ -260,7 +260,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( // fetch all indexes into table object (cannot use the above index object) auto pg_table = Catalog::GetInstance() ->GetSystemCatalog(database_oid) - .GetTableCatalog(); + ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(index_object->GetTableOid(), txn); PL_ASSERT(table_object && @@ -289,7 +289,7 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, } // try get from cache auto pg_table = - Catalog::GetInstance()->GetSystemCatalog(database_oid).GetTableCatalog(); + Catalog::GetInstance()->GetSystemCatalog(database_oid)->GetTableCatalog(); auto table_object = pg_table->GetTableObject(index_object->GetTableOid(), txn); PL_ASSERT(table_object && table_object->GetTableOid() == table_oid); diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 9c897f6456d..a5d22182b89 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -131,7 +131,7 @@ TableCatalogObject::GetIndexObjects(bool cached_only) { valid_index_objects = true; auto pg_index = Catalog::GetInstance() ->GetSystemCatalog(database_oid) - .GetIndexCatalog(); + ->GetIndexCatalog(); index_objects = pg_index->GetIndexObjects(table_oid, txn); } return index_objects; @@ -257,7 +257,7 @@ TableCatalogObject::GetColumnObjects(bool cached_only) { // get column catalog objects from pg_column auto pg_attribute = Catalog::GetInstance() ->GetSystemCatalog(database_oid) - .GetColumnCatalog(); + ->GetColumnCatalog(); pg_attribute->GetColumnObjects(table_oid, txn); valid_column_objects = true; } diff --git a/src/executor/drop_executor.cpp b/src/executor/drop_executor.cpp index 6ee2502e64e..0a69469e4e5 100644 --- a/src/executor/drop_executor.cpp +++ b/src/executor/drop_executor.cpp @@ -180,12 +180,17 @@ bool DropExecutor::DropTrigger(const planner::DropPlan &node, bool DropExecutor::DropIndex(const planner::DropPlan &node, concurrency::TransactionContext *txn) { + auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( + node.GetDatabaseName(), txn); + + auto pg_index = catalog::Catalog::GetInstance() + ->GetSystemCatalog(database_object->GetDatabaseOid()) + ->GetIndexCatalog(); std::string index_name = node.GetIndexName(); - auto index_object = - catalog::IndexCatalog::GetInstance()->GetIndexObject(index_name, txn); + auto index_object = pg_index->GetIndexObject(index_name, txn); ResultType result = catalog::Catalog::GetInstance()->DropIndex( - index_object->GetIndexOid(), txn); + database_object->GetDatabaseOid(), index_object->GetIndexOid(), txn); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { @@ -194,8 +199,8 @@ bool DropExecutor::DropIndex(const planner::DropPlan &node, StatementCacheManager::GetStmtCacheManager()->InvalidateTableOid( table_id); } - LOG_TRACE("Dropping Index Succeeded! Index oid: %d", - index_object->GetIndexOid()); + LOG_TRACE("Dropping Index Succeeded! Index name: %s", + node.GetIndexName().c_str()); } else { LOG_TRACE("Dropping Index Failed!"); } @@ -203,4 +208,4 @@ bool DropExecutor::DropIndex(const planner::DropPlan &node, } } // namespace executor -} // namespace peloton \ No newline at end of file +} // namespace peloton diff --git a/src/include/catalog/catalog.h b/src/include/catalog/catalog.h index f44ca2caa3b..0ef4e151d25 100644 --- a/src/include/catalog/catalog.h +++ b/src/include/catalog/catalog.h @@ -180,7 +180,7 @@ class Catalog { /* * Using database oid to get system catalog object */ - SystemCatalog GetSystemCatalog(const oid_t database_oid); + shared_ptr GetSystemCatalog(const oid_t database_oid); //===--------------------------------------------------------------------===// // DEPRECATED FUNCTIONS //===--------------------------------------------------------------------===// From 5a8d30eae83e5689145f0fd397d6fc45fd7d12e2 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Thu, 15 Feb 2018 01:07:29 -0500 Subject: [PATCH 13/48] refactoring system catalog, seems to compile now --- src/catalog/catalog.cpp | 62 +++++++++++++++++---------- src/catalog/column_catalog.cpp | 20 ++++----- src/catalog/database_catalog.cpp | 31 +++++--------- src/catalog/index_catalog.cpp | 20 ++++----- src/catalog/system_catalogs.cpp | 16 +++++-- src/catalog/table_catalog.cpp | 22 +++++----- src/executor/drop_executor.cpp | 5 ++- src/include/catalog/catalog.h | 7 +-- src/include/catalog/column_catalog.h | 10 +---- src/include/catalog/index_catalog.h | 12 ++---- src/include/catalog/system_catalogs.h | 10 +++++ src/include/catalog/table_catalog.h | 12 ++---- 12 files changed, 113 insertions(+), 114 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 7b82abd57b8..b4749870d85 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -12,6 +12,7 @@ #include "catalog/catalog.h" +#include "catalog/system_catalogs.h" #include "catalog/column_catalog.h" #include "catalog/database_catalog.h" #include "catalog/database_metrics_catalog.h" @@ -62,17 +63,29 @@ Catalog::Catalog() : pool_(new type::EphemeralPool()) { storage_manager->AddDatabaseToStorageManager(pg_catalog); // Create catalog tables - auto pg_database = DatabaseCatalog::GetInstance(pg_catalog, pool_.get(), txn); + DatabaseCatalog::GetInstance(pg_catalog, pool_.get(), txn); BootstrapSystemCatalogs(pg_catalog, txn); + // Insert pg_catalog database into pg_database + DatabaseCatalog::GetInstance()->InsertDatabase( + CATALOG_DATABASE_OID, CATALOG_DATABASE_NAME, pool_.get(), txn); + // Commit transaction txn_manager.CommitTransaction(txn); } -void Catalog::BootstrapSystemCatalogs(Database *database, +/* This function *MUST* be called after a new database is created to bootstrap + * all system catalog tables for that database. + * The system catalog tables must be created in certain order to make sure + * all tuples are indexed (actually this might be fine now after Paulo's fix) + */ +void Catalog::BootstrapSystemCatalogs(storage::Database *database, concurrency::TransactionContext *txn) { - auto system_catalogs = catalog_map_[database_oid] = - new SystemCatalogs(database, pool_.get(), txn); + oid_t database_oid = database->GetOid(); + catalog_map_.emplace(database_oid, + std::shared_ptr( + new SystemCatalogs(database, pool_.get(), txn))); + auto system_catalogs = catalog_map_[database_oid]; // Create indexes on catalog tables, insert them into pg_index // note that CreateIndex() from catalog.cpp will create index on storage level @@ -101,50 +114,46 @@ void Catalog::BootstrapSystemCatalogs(Database *database, // actual index already added in column_catalog, index_catalog constructor // the reason we treat those two catalog tables differently is that indexes // needs to be built before insert tuples into table - system_catalogs.GetIndexCatalog()->InsertIndex( + system_catalogs->GetIndexCatalog()->InsertIndex( COLUMN_CATALOG_PKEY_OID, COLUMN_CATALOG_NAME "_pkey", COLUMN_CATALOG_OID, IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, true, {ColumnCatalog::ColumnId::TABLE_OID, ColumnCatalog::ColumnId::COLUMN_NAME}, pool_.get(), txn); - system_catalogs.GetIndexCatalog()->InsertIndex( + system_catalogs->GetIndexCatalog()->InsertIndex( COLUMN_CATALOG_SKEY0_OID, COLUMN_CATALOG_NAME "_skey0", COLUMN_CATALOG_OID, IndexType::BWTREE, IndexConstraintType::UNIQUE, true, {ColumnCatalog::ColumnId::TABLE_OID, ColumnCatalog::ColumnId::COLUMN_ID}, pool_.get(), txn); - system_catalogs.GetIndexCatalog()->InsertIndex( + system_catalogs->GetIndexCatalog()->InsertIndex( COLUMN_CATALOG_SKEY1_OID, COLUMN_CATALOG_NAME "_skey1", COLUMN_CATALOG_OID, IndexType::BWTREE, IndexConstraintType::DEFAULT, false, {ColumnCatalog::ColumnId::TABLE_OID}, pool_.get(), txn); - system_catalogs.GetIndexCatalog()->InsertIndex( + system_catalogs->GetIndexCatalog()->InsertIndex( INDEX_CATALOG_PKEY_OID, INDEX_CATALOG_NAME "_pkey", INDEX_CATALOG_OID, IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, true, {IndexCatalog::ColumnId::INDEX_OID}, pool_.get(), txn); - system_catalogs.GetIndexCatalog()->InsertIndex( + system_catalogs->GetIndexCatalog()->InsertIndex( INDEX_CATALOG_SKEY0_OID, INDEX_CATALOG_NAME "_skey0", INDEX_CATALOG_OID, IndexType::BWTREE, IndexConstraintType::UNIQUE, true, {IndexCatalog::ColumnId::INDEX_NAME}, pool_.get(), txn); - system_catalogs.GetIndexCatalog()->InsertIndex( + system_catalogs->GetIndexCatalog()->InsertIndex( INDEX_CATALOG_SKEY1_OID, INDEX_CATALOG_NAME "_skey1", INDEX_CATALOG_OID, IndexType::BWTREE, IndexConstraintType::DEFAULT, false, {IndexCatalog::ColumnId::TABLE_OID}, pool_.get(), txn); - // Insert pg_catalog database into pg_database - DatabaseCatalog::GetInstance()->InsertDatabase( - CATALOG_DATABASE_OID, CATALOG_DATABASE_NAME, pool_.get(), txn); - // Insert catalog tables into pg_table - system_catalogs.GetTableCatalog()->InsertTable( + system_catalogs->GetTableCatalog()->InsertTable( DATABASE_CATALOG_OID, DATABASE_CATALOG_NAME, CATALOG_DATABASE_OID, pool_.get(), txn); - system_catalogs.GetTableCatalog()->InsertTable( + system_catalogs->GetTableCatalog()->InsertTable( TABLE_CATALOG_OID, TABLE_CATALOG_NAME, CATALOG_DATABASE_OID, pool_.get(), txn); - system_catalogs.GetTableCatalog()->InsertTable( + system_catalogs->GetTableCatalog()->InsertTable( INDEX_CATALOG_OID, INDEX_CATALOG_NAME, CATALOG_DATABASE_OID, pool_.get(), txn); - system_catalogs.GetTableCatalog()->InsertTable( + system_catalogs->GetTableCatalog()->InsertTable( COLUMN_CATALOG_OID, COLUMN_CATALOG_NAME, CATALOG_DATABASE_OID, pool_.get(), txn); } @@ -205,6 +214,7 @@ ResultType Catalog::CreateDatabase(const std::string &database_name, txn->RecordCreate(database_oid, INVALID_OID, INVALID_OID); // Insert database record into pg_db + BootstrapSystemCatalogs(database, txn); pg_database->InsertDatabase(database_oid, database_name, pool_.get(), txn); LOG_TRACE("Database %s created. Returning RESULT_SUCCESS.", @@ -340,7 +350,7 @@ ResultType Catalog::CreatePrimaryIndex(oid_t database_oid, oid_t table_oid, bool unique_keys = true; auto pg_index = - catalog_map_[database_object->GetDatabaseOid()]->GetIndexCatalog(); + catalog_map_[database_oid]->GetIndexCatalog(); oid_t index_oid = pg_index->GetNextOid(); index_metadata = new index::IndexMetadata( @@ -444,7 +454,7 @@ ResultType Catalog::CreateIndex( LOG_TRACE("Trying to create index %s on table %d", index_name.c_str(), table_oid); auto pg_index = - catalog_map_[database_object->GetDatabaseOid()]->GetIndexCatalog(); + catalog_map_[database_oid]->GetIndexCatalog(); oid_t index_oid = pg_index->GetNextOid(); auto key_schema = catalog::Schema::CopySchema(schema, key_attrs); key_schema->SetIndexedColumns(key_attrs); @@ -632,14 +642,19 @@ ResultType Catalog::DropIndex(const std::string &database_name, throw CatalogException("Do not have transaction to drop index " + index_name); } + auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); - auto pg_index = catalog_map_[database_oid]->GetIndexCatalog(); - auto index_object = pg_index->GetIndexObject(index_name, txn); + if (database_object == nullptr) { + throw CatalogException("Index name " + index_name + " cannot be found"); + } + auto pg_index = catalog_map_[database_object->GetDatabaseOid()]->GetIndexCatalog(); + auto index_object = pg_index->GetIndexObject(index_name, txn); if (index_object == nullptr || database_object == nullptr) { throw CatalogException("Index name " + index_name + " cannot be found"); } + ResultType result = DropIndex(database_object->GetDatabaseOid(), index_object->GetIndexOid(), txn); @@ -805,7 +820,7 @@ std::shared_ptr Catalog::GetTableObject( return table_object; } -shared_ptr Catalog::GetSystemCatalog(const oid_t database_oid) { +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 = " + database_oid); @@ -824,6 +839,7 @@ 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 diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index 986f638d282..3fc135ad1c8 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -11,9 +11,12 @@ //===----------------------------------------------------------------------===// #include "catalog/column_catalog.h" -#include "concurrency/transaction_context.h" +#include "catalog/catalog.h" +#include "catalog/system_catalogs.h" #include "catalog/table_catalog.h" +#include "concurrency/transaction_context.h" +#include "storage/database.h" #include "storage/data_table.h" #include "type/value_factory.h" @@ -41,13 +44,6 @@ ColumnCatalogObject::ColumnCatalogObject(executor::LogicalTile *tile, is_not_null(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_NOT_NULL) .GetAs()) {} -ColumnCatalog *ColumnCatalog::GetInstance( - storage::Database *pg_catalog, type::AbstractPool *pool, - concurrency::TransactionContext *txn) { - static ColumnCatalog column_catalog{pg_catalog, pool, txn}; - return &column_catalog; -} - ColumnCatalog::ColumnCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, concurrency::TransactionContext *txn) @@ -64,7 +60,7 @@ ColumnCatalog::ColumnCatalog(storage::Database *pg_catalog, AddIndex({ColumnId::TABLE_OID}, COLUMN_CATALOG_SKEY1_OID, COLUMN_CATALOG_NAME "_skey1", IndexConstraintType::DEFAULT); - // Insert columns into pg_attribute + // 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, @@ -196,7 +192,7 @@ bool ColumnCatalog::DeleteColumn(oid_t table_oid, // delete column from cache auto pg_table = - Catalog::GetInstance()->GetSystemCatalog(database_oid)->GetTableCatalog(); + Catalog::GetInstance()->GetSystemCatalogs(database_oid)->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); table_object->EvictColumnObject(column_name); @@ -217,7 +213,7 @@ bool ColumnCatalog::DeleteColumns(oid_t table_oid, // delete columns from cache auto pg_table = - Catalog::GetInstance()->GetSystemCatalog(database_oid)->GetTableCatalog(); + Catalog::GetInstance()->GetSystemCatalogs(database_oid)->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); table_object->EvictAllColumnObjects(); @@ -229,7 +225,7 @@ ColumnCatalog::GetColumnObjects(oid_t table_oid, concurrency::TransactionContext *txn) { // try get from cache auto pg_table = - Catalog::GetInstance()->GetSystemCatalog(database_oid)->GetTableCatalog(); + Catalog::GetInstance()->GetSystemCatalogs(database_oid)->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); PL_ASSERT(table_object && table_object->GetTableOid() == table_oid); auto column_objects = table_object->GetColumnObjects(true); diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 79a8eb116dc..70d626331a1 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -10,10 +10,12 @@ // //===----------------------------------------------------------------------===// -#include - #include "catalog/database_catalog.h" +#include + +#include "catalog/catalog.h" +#include "catalog/system_catalogs.h" #include "catalog/column_catalog.h" #include "catalog/table_catalog.h" #include "concurrency/transaction_context.h" @@ -126,7 +128,7 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( } else { // cache miss get from pg_table auto pg_table = Catalog::GetInstance() - ->GetSystemCatalog(database_oid) + ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); return pg_table->GetTableObject(table_oid, txn); } @@ -149,7 +151,7 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( } else { // cache miss get from pg_table auto pg_table = Catalog::GetInstance() - ->GetSystemCatalog(database_oid) + ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); return pg_table->GetTableObject(table_name, database_oid, txn); } @@ -165,7 +167,7 @@ DatabaseCatalogObject::GetTableObjects(bool cached_only) { if (!cached_only && !valid_table_objects) { // cache miss get from pg_table auto pg_table = Catalog::GetInstance() - ->GetSystemCatalog(database_oid) + ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); return pg_table->GetTableObjects(database_oid, txn); } @@ -212,23 +214,10 @@ DatabaseCatalog *DatabaseCatalog::GetInstance( } DatabaseCatalog::DatabaseCatalog(storage::Database *pg_catalog, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) + UNUSED_ATTRIBUTE type::AbstractPool *pool, + UNUSED_ATTRIBUTE concurrency::TransactionContext *txn) : AbstractCatalog(DATABASE_CATALOG_OID, DATABASE_CATALOG_NAME, - InitializeSchema().release(), pg_catalog) { - // Insert columns into pg_attribute - ColumnCatalog *pg_attribute = - ColumnCatalog::GetInstance(pg_catalog, pool, txn); - - oid_t column_id = 0; - for (auto column : catalog_table_->GetSchema()->GetColumns()) { - pg_attribute->InsertColumn(DATABASE_CATALOG_OID, column.GetName(), - column_id, column.GetOffset(), column.GetType(), - column.IsInlined(), column.GetConstraints(), - pool, txn); - column_id++; - } -} + InitializeSchema().release(), pg_catalog) {} DatabaseCatalog::~DatabaseCatalog() {} diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index 3f20dd38618..9f42bc5da3a 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -14,10 +14,13 @@ #include +#include "catalog/catalog.h" +#include "catalog/system_catalogs.h" #include "catalog/column_catalog.h" #include "catalog/table_catalog.h" #include "concurrency/transaction_context.h" #include "executor/logical_tile.h" +#include "storage/database.h" #include "storage/data_table.h" #include "storage/tuple.h" #include "type/value_factory.h" @@ -51,13 +54,6 @@ IndexCatalogObject::IndexCatalogObject(executor::LogicalTile *tile, int tupleId) LOG_TRACE("the size for indexed key is %lu", key_attrs.size()); } -IndexCatalog *IndexCatalog::GetInstance(storage::Database *pg_catalog, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { - static IndexCatalog index_catalog{pg_catalog, pool, txn}; - return &index_catalog; -} - IndexCatalog::IndexCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, concurrency::TransactionContext *txn) @@ -75,7 +71,7 @@ IndexCatalog::IndexCatalog(storage::Database *pg_catalog, // Insert columns into pg_attribute ColumnCatalog *pg_attribute = - ColumnCatalog::GetInstance(pg_catalog, pool, txn); + Catalog::GetInstance()->GetSystemCatalogs(database_oid)->GetColumnCatalog(); oid_t column_id = 0; for (auto column : catalog_table_->GetSchema()->GetColumns()) { @@ -218,7 +214,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( std::make_shared((*result_tiles)[0].get()); // fetch all indexes into table object (cannot use the above index object) auto pg_table = Catalog::GetInstance() - ->GetSystemCatalog(database_oid) + ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(index_object->GetTableOid(), txn); @@ -259,7 +255,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( std::make_shared((*result_tiles)[0].get()); // fetch all indexes into table object (cannot use the above index object) auto pg_table = Catalog::GetInstance() - ->GetSystemCatalog(database_oid) + ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(index_object->GetTableOid(), txn); @@ -289,9 +285,9 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, } // try get from cache auto pg_table = - Catalog::GetInstance()->GetSystemCatalog(database_oid)->GetTableCatalog(); + Catalog::GetInstance()->GetSystemCatalogs(database_oid)->GetTableCatalog(); auto table_object = - pg_table->GetTableObject(index_object->GetTableOid(), txn); + pg_table->GetTableObject(table_oid, txn); PL_ASSERT(table_object && table_object->GetTableOid() == table_oid); auto index_objects = table_object->GetIndexObjects(true); if (index_objects.empty() == false) return index_objects; diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index 4762ed395ae..3aff6d678d9 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -10,6 +10,13 @@ // //===----------------------------------------------------------------------===// +#include "catalog/system_catalogs.h" +#include "catalog/column_catalog.h" +#include "catalog/table_catalog.h" +#include "catalog/index_catalog.h" +#include "storage/storage_manager.h" +#include "storage/data_table.h" + namespace peloton { namespace catalog { @@ -18,9 +25,10 @@ SystemCatalogs::SystemCatalogs(storage::Database *database, concurrency::TransactionContext *txn) { pg_attribute = new ColumnCatalog(database, pool, txn); + // TODO: can we move this to BootstrapSystemCatalogs()? oid_t column_id = 0; for (auto column : - StorageManager::GetInstance() + storage::StorageManager::GetInstance() ->GetTableWithOid(CATALOG_DATABASE_OID, DATABASE_CATALOG_OID) ->GetSchema() ->GetColumns()) { @@ -37,9 +45,9 @@ SystemCatalogs::SystemCatalogs(storage::Database *database, } SystemCatalogs::~SystemCatalogs() { - delete IndexCatalog; - delete TableCatalog; - delete ColumnCatalog; + delete pg_index; + delete pg_table; + delete pg_attribute; } } // namespace catalog diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index a5d22182b89..f2d930793ff 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -10,14 +10,17 @@ // //===----------------------------------------------------------------------===// -#include - #include "catalog/table_catalog.h" +#include + +#include "catalog/catalog.h" +#include "catalog/system_catalogs.h" #include "catalog/column_catalog.h" #include "catalog/database_catalog.h" #include "catalog/index_catalog.h" #include "concurrency/transaction_context.h" +#include "storage/database.h" #include "storage/data_table.h" #include "type/value_factory.h" @@ -130,7 +133,7 @@ TableCatalogObject::GetIndexObjects(bool cached_only) { // get index catalog objects from pg_index valid_index_objects = true; auto pg_index = Catalog::GetInstance() - ->GetSystemCatalog(database_oid) + ->GetSystemCatalogs(database_oid) ->GetIndexCatalog(); index_objects = pg_index->GetIndexObjects(table_oid, txn); } @@ -256,7 +259,7 @@ TableCatalogObject::GetColumnObjects(bool cached_only) { if (!valid_column_objects && !cached_only) { // get column catalog objects from pg_column auto pg_attribute = Catalog::GetInstance() - ->GetSystemCatalog(database_oid) + ->GetSystemCatalogs(database_oid) ->GetColumnCatalog(); pg_attribute->GetColumnObjects(table_oid, txn); valid_column_objects = true; @@ -310,21 +313,16 @@ std::shared_ptr TableCatalogObject::GetColumnObject( return nullptr; } -TableCatalog *TableCatalog::GetInstance(storage::Database *pg_catalog, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { - static TableCatalog table_catalog{pg_catalog, pool, txn}; - return &table_catalog; -} - TableCatalog::TableCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, concurrency::TransactionContext *txn) : AbstractCatalog(TABLE_CATALOG_OID, TABLE_CATALOG_NAME, InitializeSchema().release(), pg_catalog) { + database_oid = pg_catalog->GetOid(); + // Insert columns into pg_attribute ColumnCatalog *pg_attribute = - ColumnCatalog::GetInstance(pg_catalog, pool, txn); + Catalog::GetInstance()->GetSystemCatalogs(database_oid)->GetColumnCatalog(); oid_t column_id = 0; for (auto column : catalog_table_->GetSchema()->GetColumns()) { diff --git a/src/executor/drop_executor.cpp b/src/executor/drop_executor.cpp index 0a69469e4e5..db7d70b0c23 100644 --- a/src/executor/drop_executor.cpp +++ b/src/executor/drop_executor.cpp @@ -15,6 +15,7 @@ #include "catalog/catalog.h" #include "catalog/database_catalog.h" #include "catalog/index_catalog.h" +#include "catalog/system_catalogs.h" #include "catalog/table_catalog.h" #include "catalog/trigger_catalog.h" #include "common/logger.h" @@ -180,11 +181,11 @@ bool DropExecutor::DropTrigger(const planner::DropPlan &node, bool DropExecutor::DropIndex(const planner::DropPlan &node, concurrency::TransactionContext *txn) { - auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( + auto database_object = catalog::Catalog::GetInstance()->GetDatabaseObject( node.GetDatabaseName(), txn); auto pg_index = catalog::Catalog::GetInstance() - ->GetSystemCatalog(database_object->GetDatabaseOid()) + ->GetSystemCatalogs(database_object->GetDatabaseOid()) ->GetIndexCatalog(); std::string index_name = node.GetIndexName(); auto index_object = pg_index->GetIndexObject(index_name, txn); diff --git a/src/include/catalog/catalog.h b/src/include/catalog/catalog.h index 0ef4e151d25..4f64b718b16 100644 --- a/src/include/catalog/catalog.h +++ b/src/include/catalog/catalog.h @@ -24,6 +24,7 @@ class Schema; class DatabaseCatalogObject; class TableCatalogObject; class IndexCatalogObject; +class SystemCatalogs; } // namespace catalog namespace concurrency { @@ -180,7 +181,7 @@ class Catalog { /* * Using database oid to get system catalog object */ - shared_ptr GetSystemCatalog(const oid_t database_oid); + std::shared_ptr GetSystemCatalogs(const oid_t database_oid); //===--------------------------------------------------------------------===// // DEPRECATED FUNCTIONS //===--------------------------------------------------------------------===// @@ -220,7 +221,7 @@ class Catalog { private: Catalog(); - void BootstrapSystemCatalogs(Database *database, + void BootstrapSystemCatalogs(storage::Database *database, concurrency::TransactionContext *txn); // The pool for new varlen tuple fields @@ -228,7 +229,7 @@ class Catalog { std::mutex catalog_mutex; // key: database oid // value: SystemCatalog object(including pg_table, pg_index and pg_attribute) - std::unordered_map> catalog_map_; + std::unordered_map> catalog_map_; }; } // namespace catalog diff --git a/src/include/catalog/column_catalog.h b/src/include/catalog/column_catalog.h index 9cb561e2ec0..2eb71cb14d9 100644 --- a/src/include/catalog/column_catalog.h +++ b/src/include/catalog/column_catalog.h @@ -69,11 +69,8 @@ class ColumnCatalog : public AbstractCatalog { friend class Catalog; public: - // Global Singleton, only the first call requires passing parameters. - static ColumnCatalog *GetInstance( - storage::Database *pg_catalog = nullptr, - type::AbstractPool *pool = nullptr, - concurrency::TransactionContext *txn = nullptr); + ColumnCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, + concurrency::TransactionContext *txn); ~ColumnCatalog(); @@ -102,9 +99,6 @@ class ColumnCatalog : public AbstractCatalog { const std::unordered_map> GetColumnObjects(oid_t table_oid, concurrency::TransactionContext *txn); - ColumnCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, - concurrency::TransactionContext *txn); - std::unique_ptr InitializeSchema(); enum ColumnId { diff --git a/src/include/catalog/index_catalog.h b/src/include/catalog/index_catalog.h index c6b2abe2045..0da44b045a9 100644 --- a/src/include/catalog/index_catalog.h +++ b/src/include/catalog/index_catalog.h @@ -70,13 +70,10 @@ class IndexCatalog : public AbstractCatalog { friend class Catalog; public: - ~IndexCatalog(); + IndexCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, + concurrency::TransactionContext *txn); - // Global Singleton, only the first call requires passing parameters. - static IndexCatalog *GetInstance( - storage::Database *pg_catalog = nullptr, - type::AbstractPool *pool = nullptr, - concurrency::TransactionContext *txn = nullptr); + ~IndexCatalog(); inline oid_t GetNextOid() { return oid_++ | INDEX_OID_MASK; } @@ -102,9 +99,6 @@ class IndexCatalog : public AbstractCatalog { private: oid_t database_oid; - IndexCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, - concurrency::TransactionContext *txn); - std::unique_ptr InitializeSchema(); enum ColumnId { diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h index f75b370f79e..17f2f7ddd34 100644 --- a/src/include/catalog/system_catalogs.h +++ b/src/include/catalog/system_catalogs.h @@ -18,8 +18,18 @@ #include "catalog/table_catalog.h" namespace peloton { + +namespace storage { +class Database; +} // namespace storage + namespace catalog { +class DatabaseCatalog; +class TableCatalog; +class IndexCatalog; +class ColumnCatalog; + class SystemCatalogs { public: SystemCatalogs() = delete; diff --git a/src/include/catalog/table_catalog.h b/src/include/catalog/table_catalog.h index a509fa1aa35..37882e02a7e 100644 --- a/src/include/catalog/table_catalog.h +++ b/src/include/catalog/table_catalog.h @@ -118,14 +118,11 @@ class TableCatalog : public AbstractCatalog { friend class Catalog; public: + TableCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, + concurrency::TransactionContext *txn); + ~TableCatalog(); - // Global Singleton, only the first call requires passing parameters. - static TableCatalog *GetInstance( - storage::Database *pg_catalog = nullptr, - type::AbstractPool *pool = nullptr, - concurrency::TransactionContext *txn = nullptr); - inline oid_t GetNextOid() { return oid_++ | TABLE_OID_MASK; } //===--------------------------------------------------------------------===// @@ -152,8 +149,7 @@ class TableCatalog : public AbstractCatalog { GetTableObjects(oid_t database_oid, concurrency::TransactionContext *txn); private: - TableCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, - concurrency::TransactionContext *txn); + oid_t database_oid; std::unique_ptr InitializeSchema(); From c4a73172b21bd2c025778b61eb8fa981f2447679 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Thu, 15 Feb 2018 09:21:44 -0500 Subject: [PATCH 14/48] refactor fix --- src/include/catalog/catalog.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/include/catalog/catalog.h b/src/include/catalog/catalog.h index 4f64b718b16..e631da45f43 100644 --- a/src/include/catalog/catalog.h +++ b/src/include/catalog/catalog.h @@ -134,10 +134,10 @@ class Catalog { ResultType DropTable(oid_t database_oid, oid_t table_oid, concurrency::TransactionContext *txn); // Drop an index, using its index_oid - ResultType DropIndex(oid_t index_oid, concurrency::TransactionContext *txn); + ResultType DropIndex(oid_t database_oid, oid_t index_oid, concurrency::TransactionContext *txn); // Drop an index, using its index name - ResultType DropIndex(const std::string &index_name, + ResultType DropIndex(const std::string &database_name, const std::string &index_name, concurrency::TransactionContext *txn); //===--------------------------------------------------------------------===// // GET WITH NAME - CHECK FROM CATALOG TABLES, USING TRANSACTION From 792f6607653b8f9e7c64eafefaec49e14452c140 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Thu, 15 Feb 2018 10:26:58 -0500 Subject: [PATCH 15/48] refactor, peloton can start and finish bootstrap. TODO: refactor global unique oid --- src/catalog/index_catalog.cpp | 27 +++++++-------------------- src/catalog/system_catalogs.cpp | 31 +++++++++++++++++++++++++++++-- src/catalog/table_catalog.cpp | 19 +++---------------- 3 files changed, 39 insertions(+), 38 deletions(-) diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index 9f42bc5da3a..5dfbb07552a 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -54,9 +54,9 @@ IndexCatalogObject::IndexCatalogObject(executor::LogicalTile *tile, int tupleId) LOG_TRACE("the size for indexed key is %lu", key_attrs.size()); } -IndexCatalog::IndexCatalog(storage::Database *pg_catalog, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) +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) { database_oid = pg_catalog->GetOid(); @@ -68,19 +68,6 @@ IndexCatalog::IndexCatalog(storage::Database *pg_catalog, IndexConstraintType::UNIQUE); AddIndex({2}, INDEX_CATALOG_SKEY1_OID, INDEX_CATALOG_NAME "_skey1", IndexConstraintType::DEFAULT); - - // Insert columns into pg_attribute - ColumnCatalog *pg_attribute = - Catalog::GetInstance()->GetSystemCatalogs(database_oid)->GetColumnCatalog(); - - oid_t column_id = 0; - for (auto column : catalog_table_->GetSchema()->GetColumns()) { - pg_attribute->InsertColumn(INDEX_CATALOG_OID, column.GetName(), column_id, - column.GetOffset(), column.GetType(), - column.IsInlined(), column.GetConstraints(), - pool, txn); - column_id++; - } } IndexCatalog::~IndexCatalog() {} @@ -284,10 +271,10 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, throw CatalogException("Transaction is invalid!"); } // try get from cache - auto pg_table = - Catalog::GetInstance()->GetSystemCatalogs(database_oid)->GetTableCatalog(); - auto table_object = - pg_table->GetTableObject(table_oid, txn); + auto pg_table = Catalog::GetInstance() + ->GetSystemCatalogs(database_oid) + ->GetTableCatalog(); + auto table_object = pg_table->GetTableObject(table_oid, txn); PL_ASSERT(table_object && table_object->GetTableOid() == table_oid); auto index_objects = table_object->GetIndexObjects(true); if (index_objects.empty() == false) return index_objects; diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index 3aff6d678d9..09e9ebf534f 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -15,6 +15,7 @@ #include "catalog/table_catalog.h" #include "catalog/index_catalog.h" #include "storage/storage_manager.h" +#include "storage/database.h" #include "storage/data_table.h" namespace peloton { @@ -23,9 +24,13 @@ namespace catalog { SystemCatalogs::SystemCatalogs(storage::Database *database, type::AbstractPool *pool, concurrency::TransactionContext *txn) { + oid_t database_oid = database->GetOid(); pg_attribute = new ColumnCatalog(database, pool, txn); + pg_table = new TableCatalog(database, pool, txn); + pg_index = new IndexCatalog(database, pool, txn); // TODO: can we move this to BootstrapSystemCatalogs()? + // insert pg_database columns into pg_attribute oid_t column_id = 0; for (auto column : storage::StorageManager::GetInstance() @@ -39,9 +44,31 @@ SystemCatalogs::SystemCatalogs(storage::Database *database, column_id++; } - pg_table = new TableCatalog(database, pool, txn); + // Insert pg_table columns into pg_attribute + column_id = 0; + for (auto column : storage::StorageManager::GetInstance() + ->GetTableWithOid(database_oid, TABLE_CATALOG_OID) + ->GetSchema() + ->GetColumns()) { + pg_attribute->InsertColumn(TABLE_CATALOG_OID, column.GetName(), column_id, + column.GetOffset(), column.GetType(), + column.IsInlined(), column.GetConstraints(), + pool, txn); + column_id++; + } - pg_index = new IndexCatalog(database, pool, txn); + // Insert pg_index columns into pg_attribute + column_id = 0; + for (auto column : storage::StorageManager::GetInstance() + ->GetTableWithOid(database_oid, INDEX_CATALOG_OID) + ->GetSchema() + ->GetColumns()) { + pg_attribute->InsertColumn(INDEX_CATALOG_OID, column.GetName(), column_id, + column.GetOffset(), column.GetType(), + column.IsInlined(), column.GetConstraints(), + pool, txn); + column_id++; + } } SystemCatalogs::~SystemCatalogs() { diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index f2d930793ff..ebd4e2b9a2b 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -313,25 +313,12 @@ std::shared_ptr TableCatalogObject::GetColumnObject( return nullptr; } -TableCatalog::TableCatalog(storage::Database *pg_catalog, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) +TableCatalog::TableCatalog( + storage::Database *pg_catalog, UNUSED_ATTRIBUTE type::AbstractPool *pool, + UNUSED_ATTRIBUTE concurrency::TransactionContext *txn) : AbstractCatalog(TABLE_CATALOG_OID, TABLE_CATALOG_NAME, InitializeSchema().release(), pg_catalog) { database_oid = pg_catalog->GetOid(); - - // Insert columns into pg_attribute - ColumnCatalog *pg_attribute = - Catalog::GetInstance()->GetSystemCatalogs(database_oid)->GetColumnCatalog(); - - oid_t column_id = 0; - for (auto column : catalog_table_->GetSchema()->GetColumns()) { - pg_attribute->InsertColumn(TABLE_CATALOG_OID, column.GetName(), column_id, - column.GetOffset(), column.GetType(), - column.IsInlined(), column.GetConstraints(), - pool, txn); - column_id++; - } } TableCatalog::~TableCatalog() {} From 88c2cefdd266d548fa659d36c01d7f8682fd6f14 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Thu, 15 Feb 2018 13:51:29 -0500 Subject: [PATCH 16/48] fixed pg_database index, still cannot find system catalog in other databases --- src/catalog/catalog.cpp | 36 ++++++++++++++------------ src/catalog/database_catalog.cpp | 14 +++++++--- src/include/catalog/catalog_defaults.h | 4 +++ 3 files changed, 33 insertions(+), 21 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index b4749870d85..19b7f0c194d 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -83,8 +83,8 @@ void Catalog::BootstrapSystemCatalogs(storage::Database *database, concurrency::TransactionContext *txn) { oid_t database_oid = database->GetOid(); catalog_map_.emplace(database_oid, - std::shared_ptr( - new SystemCatalogs(database, pool_.get(), txn))); + std::shared_ptr( + new SystemCatalogs(database, pool_.get(), txn))); auto system_catalogs = catalog_map_[database_oid]; // Create indexes on catalog tables, insert them into pg_index @@ -93,20 +93,14 @@ void Catalog::BootstrapSystemCatalogs(storage::Database *database, // TODO: This should be hash index rather than tree index?? (but postgres use // btree!!) - CreatePrimaryIndex(CATALOG_DATABASE_OID, DATABASE_CATALOG_OID, txn); - CreatePrimaryIndex(CATALOG_DATABASE_OID, TABLE_CATALOG_OID, txn); + CreatePrimaryIndex(database_oid, TABLE_CATALOG_OID, txn); - CreateIndex(CATALOG_DATABASE_OID, DATABASE_CATALOG_OID, - {DatabaseCatalog::ColumnId::DATABASE_NAME}, - DATABASE_CATALOG_NAME "_skey0", IndexType::BWTREE, - IndexConstraintType::UNIQUE, true, txn, true); - - CreateIndex(CATALOG_DATABASE_OID, TABLE_CATALOG_OID, + CreateIndex(database_oid, TABLE_CATALOG_OID, {TableCatalog::ColumnId::TABLE_NAME, TableCatalog::ColumnId::DATABASE_OID}, TABLE_CATALOG_NAME "_skey0", IndexType::BWTREE, IndexConstraintType::UNIQUE, true, txn, true); - CreateIndex(CATALOG_DATABASE_OID, TABLE_CATALOG_OID, + CreateIndex(database_oid, TABLE_CATALOG_OID, {TableCatalog::ColumnId::DATABASE_OID}, TABLE_CATALOG_NAME "_skey1", IndexType::BWTREE, IndexConstraintType::DEFAULT, false, txn, true); @@ -142,6 +136,14 @@ void Catalog::BootstrapSystemCatalogs(storage::Database *database, INDEX_CATALOG_SKEY1_OID, INDEX_CATALOG_NAME "_skey1", INDEX_CATALOG_OID, 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, 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, IndexType::BWTREE, IndexConstraintType::DEFAULT, + false, {DatabaseCatalog::ColumnId::DATABASE_NAME}, pool_.get(), txn); // Insert catalog tables into pg_table system_catalogs->GetTableCatalog()->InsertTable( @@ -349,8 +351,7 @@ ResultType Catalog::CreatePrimaryIndex(oid_t database_oid, oid_t table_oid, std::string index_name = table->GetName() + "_pkey"; bool unique_keys = true; - auto pg_index = - catalog_map_[database_oid]->GetIndexCatalog(); + auto pg_index = catalog_map_[database_oid]->GetIndexCatalog(); oid_t index_oid = pg_index->GetNextOid(); index_metadata = new index::IndexMetadata( @@ -453,8 +454,7 @@ ResultType Catalog::CreateIndex( // Passed all checks, now get all index metadata LOG_TRACE("Trying to create index %s on table %d", index_name.c_str(), table_oid); - auto pg_index = - catalog_map_[database_oid]->GetIndexCatalog(); + auto pg_index = catalog_map_[database_oid]->GetIndexCatalog(); oid_t index_oid = pg_index->GetNextOid(); auto key_schema = catalog::Schema::CopySchema(schema, key_attrs); key_schema->SetIndexedColumns(key_attrs); @@ -649,7 +649,8 @@ ResultType Catalog::DropIndex(const std::string &database_name, throw CatalogException("Index name " + index_name + " cannot be found"); } - auto pg_index = catalog_map_[database_object->GetDatabaseOid()]->GetIndexCatalog(); + auto pg_index = + catalog_map_[database_object->GetDatabaseOid()]->GetIndexCatalog(); auto index_object = pg_index->GetIndexObject(index_name, txn); if (index_object == nullptr || database_object == nullptr) { throw CatalogException("Index name " + index_name + " cannot be found"); @@ -820,7 +821,8 @@ std::shared_ptr Catalog::GetTableObject( return table_object; } -std::shared_ptr Catalog::GetSystemCatalogs(const oid_t database_oid) { +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 = " + database_oid); diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 70d626331a1..3072b8cd040 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -213,11 +213,17 @@ DatabaseCatalog *DatabaseCatalog::GetInstance( return &database_catalog; } -DatabaseCatalog::DatabaseCatalog(storage::Database *pg_catalog, - UNUSED_ATTRIBUTE type::AbstractPool *pool, - UNUSED_ATTRIBUTE concurrency::TransactionContext *txn) +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) {} + InitializeSchema().release(), pg_catalog) { + // 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); +} DatabaseCatalog::~DatabaseCatalog() {} diff --git a/src/include/catalog/catalog_defaults.h b/src/include/catalog/catalog_defaults.h index 69834ec769a..da6b1ae5072 100644 --- a/src/include/catalog/catalog_defaults.h +++ b/src/include/catalog/catalog_defaults.h @@ -64,6 +64,10 @@ namespace catalog { #define INDEX_CATALOG_SKEY0_OID (4 | INDEX_OID_MASK) #define INDEX_CATALOG_SKEY1_OID (5 | INDEX_OID_MASK) +// Reserved pg_database index oid +#define DATABASE_CATALOG_PKEY_OID (6 | INDEX_OID_MASK) +#define DATABASE_CATALOG_SKEY0_OID (7 | INDEX_OID_MASK) + // Use upper 8 bits indicating catalog type #define CATALOG_TYPE_OFFSET 24 From f15b3c3bba9850a4a8d30d8f126d43343ee9ea15 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sat, 17 Feb 2018 14:43:27 -0500 Subject: [PATCH 17/48] fix two misuse of CATALOG_DATABASE_OID --- src/catalog/abstract_catalog.cpp | 12 ++++++------ src/catalog/catalog.cpp | 9 +++------ 2 files changed, 9 insertions(+), 12 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 2b34e781fa7..23286cd540a 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -49,7 +49,7 @@ AbstractCatalog::AbstractCatalog(oid_t catalog_table_oid, storage::Database *pg_catalog) { // Create catalog_table_ catalog_table_ = storage::TableFactory::GetDataTable( - CATALOG_DATABASE_OID, catalog_table_oid, catalog_table_schema, + pg_catalog->GetOid(), catalog_table_oid, catalog_table_schema, catalog_table_name, DEFAULT_TUPLES_PER_TILEGROUP, true, false, true); // Add catalog_table_ into pg_catalog database @@ -126,11 +126,11 @@ bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, std::make_shared(catalog_table_, &columns, &values); executor::ExecutionResult this_p_status; - auto on_complete = [&this_p_status]( - executor::ExecutionResult p_status, - std::vector &&values UNUSED_ATTRIBUTE) { - this_p_status = p_status; - }; + auto on_complete = + [&this_p_status](executor::ExecutionResult p_status, + std::vector &&values UNUSED_ATTRIBUTE) { + this_p_status = p_status; + }; executor::PlanExecutor::ExecutePlan(node, txn, params, result_format, on_complete); diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 19b7f0c194d..9bd716e3319 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -150,14 +150,11 @@ void Catalog::BootstrapSystemCatalogs(storage::Database *database, DATABASE_CATALOG_OID, DATABASE_CATALOG_NAME, CATALOG_DATABASE_OID, pool_.get(), txn); system_catalogs->GetTableCatalog()->InsertTable( - TABLE_CATALOG_OID, TABLE_CATALOG_NAME, CATALOG_DATABASE_OID, pool_.get(), - txn); + TABLE_CATALOG_OID, TABLE_CATALOG_NAME, database_oid, pool_.get(), txn); system_catalogs->GetTableCatalog()->InsertTable( - INDEX_CATALOG_OID, INDEX_CATALOG_NAME, CATALOG_DATABASE_OID, pool_.get(), - txn); + INDEX_CATALOG_OID, INDEX_CATALOG_NAME, database_oid, pool_.get(), txn); system_catalogs->GetTableCatalog()->InsertTable( - COLUMN_CATALOG_OID, COLUMN_CATALOG_NAME, CATALOG_DATABASE_OID, - pool_.get(), txn); + COLUMN_CATALOG_OID, COLUMN_CATALOG_NAME, database_oid, pool_.get(), txn); } void Catalog::Bootstrap() { From e9d118df850e999dd5835e02e52b23ed6e30948a Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sat, 17 Feb 2018 15:37:24 -0500 Subject: [PATCH 18/48] seems to work now --- src/catalog/catalog.cpp | 6 ++--- src/catalog/database_catalog.cpp | 2 +- src/catalog/table_catalog.cpp | 36 ++++++++++++++--------------- src/include/catalog/table_catalog.h | 7 +++--- src/parser/postgresparser.cpp | 4 ++-- 5 files changed, 25 insertions(+), 30 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 9bd716e3319..efe4733d46a 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -96,10 +96,8 @@ void Catalog::BootstrapSystemCatalogs(storage::Database *database, CreatePrimaryIndex(database_oid, TABLE_CATALOG_OID, txn); CreateIndex(database_oid, TABLE_CATALOG_OID, - {TableCatalog::ColumnId::TABLE_NAME, - TableCatalog::ColumnId::DATABASE_OID}, - TABLE_CATALOG_NAME "_skey0", IndexType::BWTREE, - IndexConstraintType::UNIQUE, true, txn, true); + {TableCatalog::ColumnId::TABLE_NAME}, TABLE_CATALOG_NAME "_skey0", + IndexType::BWTREE, IndexConstraintType::UNIQUE, true, txn, true); CreateIndex(database_oid, TABLE_CATALOG_OID, {TableCatalog::ColumnId::DATABASE_OID}, TABLE_CATALOG_NAME "_skey1", IndexType::BWTREE, diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 3072b8cd040..3f53e2eaa55 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -153,7 +153,7 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( auto pg_table = Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); - return pg_table->GetTableObject(table_name, database_oid, txn); + return pg_table->GetTableObject(table_name, txn); } } diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index ebd4e2b9a2b..0a66d7457e7 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -15,13 +15,13 @@ #include #include "catalog/catalog.h" -#include "catalog/system_catalogs.h" #include "catalog/column_catalog.h" #include "catalog/database_catalog.h" #include "catalog/index_catalog.h" +#include "catalog/system_catalogs.h" #include "concurrency/transaction_context.h" -#include "storage/database.h" #include "storage/data_table.h" +#include "storage/database.h" #include "type/value_factory.h" namespace peloton { @@ -274,8 +274,9 @@ std::unordered_map> TableCatalogObject::GetColumnNames(bool cached_only) { if (!valid_column_objects && !cached_only) { auto column_objects = GetColumnObjects(); - std::unordered_map > column_names; - for (auto& pair : column_objects) { + std::unordered_map> + column_names; + for (auto &pair : column_objects) { auto column = pair.second; column_names[column->GetColumnName()] = column; } @@ -404,8 +405,8 @@ bool TableCatalog::DeleteTable(oid_t table_oid, // evict from cache auto table_object = txn->catalog_cache.GetCachedTableObject(table_oid); if (table_object) { - auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( - table_object->GetDatabaseOid(), txn); + auto database_object = + DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); database_object->EvictTableObject(table_oid); } @@ -439,9 +440,9 @@ std::shared_ptr TableCatalog::GetTableObject( auto table_object = std::make_shared((*result_tiles)[0].get(), txn); // insert into cache - auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( - table_object->GetDatabaseOid(), txn); - PELOTON_ASSERT(database_object); + auto database_object = + DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); + PL_ASSERT(database_object); bool success = database_object->InsertTableObject(table_object); PELOTON_ASSERT(success == true); (void)success; @@ -462,8 +463,7 @@ std::shared_ptr TableCatalog::GetTableObject( * @return table catalog object */ std::shared_ptr TableCatalog::GetTableObject( - const std::string &table_name, oid_t database_oid, - concurrency::TransactionContext *txn) { + const std::string &table_name, concurrency::TransactionContext *txn) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } @@ -476,12 +476,10 @@ std::shared_ptr TableCatalog::GetTableObject( // cache miss, get from pg_table std::vector column_ids(all_column_ids); - oid_t index_offset = - IndexId::SKEY_TABLE_NAME; // Index of table_name & database_oid + oid_t index_offset = IndexId::SKEY_TABLE_NAME; // Index of table_name std::vector values; values.push_back( type::ValueFactory::GetVarcharValue(table_name, nullptr).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); auto result_tiles = GetResultWithIndexScan(column_ids, index_offset, values, txn); @@ -490,9 +488,9 @@ std::shared_ptr TableCatalog::GetTableObject( auto table_object = std::make_shared((*result_tiles)[0].get(), txn); // insert into cache - auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( - table_object->GetDatabaseOid(), txn); - PELOTON_ASSERT(database_object); + auto database_object = + DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); + PL_ASSERT(database_object); bool success = database_object->InsertTableObject(table_object); PELOTON_ASSERT(success == true); (void)success; @@ -558,8 +556,8 @@ bool TableCatalog::UpdateVersionId(oid_t update_val, oid_t table_oid, // get table object, then evict table object auto table_object = txn->catalog_cache.GetCachedTableObject(table_oid); if (table_object) { - auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( - table_object->GetDatabaseOid(), txn); + auto database_object = + DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); database_object->EvictTableObject(table_oid); } diff --git a/src/include/catalog/table_catalog.h b/src/include/catalog/table_catalog.h index 37882e02a7e..1269d3fe31a 100644 --- a/src/include/catalog/table_catalog.h +++ b/src/include/catalog/table_catalog.h @@ -20,7 +20,7 @@ // // Indexes: (index offset: indexed columns) // 0: table_oid (unique & primary key) -// 1: table_name & database_oid (unique) +// 1: table_name (unique) // 2: database_oid (non-unique) // //===----------------------------------------------------------------------===// @@ -120,7 +120,7 @@ class TableCatalog : public AbstractCatalog { public: TableCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, concurrency::TransactionContext *txn); - + ~TableCatalog(); inline oid_t GetNextOid() { return oid_++ | TABLE_OID_MASK; } @@ -143,8 +143,7 @@ class TableCatalog : public AbstractCatalog { std::shared_ptr GetTableObject( oid_t table_oid, concurrency::TransactionContext *txn); std::shared_ptr GetTableObject( - const std::string &table_name, oid_t database_oid, - concurrency::TransactionContext *txn); + const std::string &table_name, concurrency::TransactionContext *txn); std::unordered_map> GetTableObjects(oid_t database_oid, concurrency::TransactionContext *txn); diff --git a/src/parser/postgresparser.cpp b/src/parser/postgresparser.cpp index 32e7a374e38..6c3697499e9 100644 --- a/src/parser/postgresparser.cpp +++ b/src/parser/postgresparser.cpp @@ -973,8 +973,8 @@ parser::SQLStatement *PostgresParser::CreateTransform(CreateStmt *root) { if (relation->relname) { result->table_info_->table_name = relation->relname; } - if (relation->catalogname) { - result->table_info_->database_name = relation->catalogname; + if (relation->schemaname) { + result->table_info_->database_name = relation->schemaname; }; std::unordered_set primary_keys; From 98d632121ab845597e13b67e6dccb051f905c416 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Tue, 13 Mar 2018 19:30:57 -0400 Subject: [PATCH 19/48] fix two tests --- test/catalog/catalog_test.cpp | 21 ++++++++++++--------- test/sql/drop_sql_test.cpp | 6 +++--- 2 files changed, 15 insertions(+), 12 deletions(-) diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index 84743193ec8..7edbbf90a96 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -16,6 +16,7 @@ #include "catalog/database_metrics_catalog.h" #include "catalog/index_catalog.h" #include "catalog/query_metrics_catalog.h" +#include "catalog/system_catalogs.h" #include "catalog/table_catalog.h" #include "common/harness.h" #include "common/logger.h" @@ -184,9 +185,11 @@ TEST_F(CatalogTests, TableObject) { // update pg_table SET version_oid = 1 where table_name = department_table oid_t department_table_oid = table_object->GetTableOid(); - bool update_result = catalog::TableCatalog::GetInstance()->UpdateVersionId( - 1, department_table_oid, txn); - // get version id after update + auto pg_table = catalog::Catalog::GetInstance() + ->GetSystemCatalogs(table_object->GetDatabaseOid()) + ->GetTableCatalog(); + bool update_result = pg_table->UpdateVersionId(1, department_table_oid, txn); + // get version id after update, invalidate old cache table_object = catalog::Catalog::GetInstance()->GetTableObject( "EMP_DB", "department_table", txn); uint32_t version_oid = table_object->GetVersionId(); @@ -201,8 +204,9 @@ TEST_F(CatalogTests, DroppingTable) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); + // everytime we create a database, there will be 3 catalog tables inside EXPECT_EQ( - 3, + 6, (int)catalog->GetDatabaseObject("EMP_DB", txn)->GetTableObjects().size()); auto database_object = catalog::Catalog::GetInstance()->GetDatabaseObject("EMP_DB", txn); @@ -214,9 +218,8 @@ TEST_F(CatalogTests, DroppingTable) { EXPECT_NE(nullptr, database_object); auto department_table_object = database_object->GetTableObject("department_table"); - // catalog::Catalog::GetInstance()->PrintCatalogs(); EXPECT_EQ( - 2, + 5, (int)catalog->GetDatabaseObject("EMP_DB", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); @@ -229,7 +232,7 @@ TEST_F(CatalogTests, DroppingTable) { CatalogException); EXPECT_EQ( - 2, + 5, (int)catalog->GetDatabaseObject("EMP_DB", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); @@ -239,7 +242,7 @@ TEST_F(CatalogTests, DroppingTable) { catalog::Catalog::GetInstance()->DropTable("EMP_DB", "void_table", txn), CatalogException); EXPECT_EQ( - 2, + 5, (int)catalog->GetDatabaseObject("EMP_DB", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); @@ -247,7 +250,7 @@ TEST_F(CatalogTests, DroppingTable) { txn = txn_manager.BeginTransaction(); catalog::Catalog::GetInstance()->DropTable("EMP_DB", "emp_table", txn); EXPECT_EQ( - 1, + 4, (int)catalog->GetDatabaseObject("EMP_DB", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); } diff --git a/test/sql/drop_sql_test.cpp b/test/sql/drop_sql_test.cpp index b53d1d2200a..5b3c2b551b5 100644 --- a/test/sql/drop_sql_test.cpp +++ b/test/sql/drop_sql_test.cpp @@ -12,13 +12,13 @@ #include -#include "catalog/index_catalog.h" -#include "sql/testing_sql_util.h" #include "catalog/catalog.h" +#include "catalog/index_catalog.h" #include "common/harness.h" #include "concurrency/transaction_manager_factory.h" #include "executor/create_executor.h" #include "planner/create_plan.h" +#include "sql/testing_sql_util.h" namespace peloton { namespace test { @@ -131,4 +131,4 @@ TEST_F(DropSQLTests, DropIndexTest) { } } // namespace test -} // namespace peloton \ No newline at end of file +} // namespace peloton From f63fcd90db6a475e8bbb4592cd67f121b19c7059 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Tue, 13 Mar 2018 22:25:40 -0400 Subject: [PATCH 20/48] fix drop index bug, need information about database --- src/planner/drop_plan.cpp | 1 + test/executor/drop_test.cpp | 57 ++++++++++++++++++++----------------- test/sql/drop_sql_test.cpp | 17 ++++++++--- 3 files changed, 45 insertions(+), 30 deletions(-) diff --git a/src/planner/drop_plan.cpp b/src/planner/drop_plan.cpp index 07e04b25cd0..e4993e6cadb 100644 --- a/src/planner/drop_plan.cpp +++ b/src/planner/drop_plan.cpp @@ -49,6 +49,7 @@ DropPlan::DropPlan(parser::DropStatement *parse_tree) { break; } case parser::DropStatement::EntityType::kIndex: { + database_name = parse_tree->GetDatabaseName(); index_name = std::string(parse_tree->GetIndexName()); drop_type = DropType::INDEX; break; diff --git a/test/executor/drop_test.cpp b/test/executor/drop_test.cpp index d0d385b85fb..2d86f74821c 100644 --- a/test/executor/drop_test.cpp +++ b/test/executor/drop_test.cpp @@ -14,9 +14,10 @@ #include "gtest/gtest.h" -#include "catalog/index_catalog.h" #include "catalog/catalog.h" #include "catalog/database_catalog.h" +#include "catalog/index_catalog.h" +#include "catalog/system_catalogs.h" #include "common/harness.h" #include "concurrency/transaction_manager_factory.h" #include "executor/create_executor.h" @@ -68,11 +69,8 @@ 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->GetDatabaseObject(TEST_DB_NAME, txn);); txn_manager.CommitTransaction(txn); - } TEST_F(DropTests, DroppingTable) { @@ -97,8 +95,8 @@ TEST_F(DropTests, DroppingTable) { txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_NAME, "department_table", std::move(table_schema), - txn); + catalog->CreateTable(TEST_DB_NAME, "department_table", + std::move(table_schema), txn); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); @@ -107,15 +105,17 @@ TEST_F(DropTests, DroppingTable) { txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - EXPECT_EQ( - (int)catalog->GetDatabaseObject(TEST_DB_NAME, txn)->GetTableObjects().size(), - 2); + EXPECT_EQ((int)catalog->GetDatabaseObject(TEST_DB_NAME, txn) + ->GetTableObjects() + .size(), + 5); // Now dropping the table using the executor catalog->DropTable(TEST_DB_NAME, "department_table", txn); - EXPECT_EQ( - (int)catalog->GetDatabaseObject(TEST_DB_NAME, txn)->GetTableObjects().size(), - 1); + EXPECT_EQ((int)catalog->GetDatabaseObject(TEST_DB_NAME, txn) + ->GetTableObjects() + .size(), + 4); // free the database just created catalog->DropDatabaseWithName(TEST_DB_NAME, txn); @@ -143,8 +143,8 @@ TEST_F(DropTests, DroppingTrigger) { txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_NAME, "department_table", std::move(table_schema), - txn); + catalog->CreateTable(TEST_DB_NAME, "department_table", + std::move(table_schema), txn); txn_manager.CommitTransaction(txn); // Create a trigger @@ -208,7 +208,7 @@ TEST_F(DropTests, DroppingTrigger) { // Now dropping the table using the executer txn = txn_manager.BeginTransaction(); catalog->DropTable(TEST_DB_NAME, "department_table", txn); - EXPECT_EQ(0, (int)catalog::Catalog::GetInstance() + EXPECT_EQ(3, (int)catalog::Catalog::GetInstance() ->GetDatabaseObject(TEST_DB_NAME, txn) ->GetTableObjects() .size()); @@ -249,30 +249,35 @@ TEST_F(DropTests, DroppingIndexByName) { txn = txn_manager.BeginTransaction(); auto source_table = db->GetTableWithName("department_table_01"); - oid_t col_id = source_table->GetSchema()->GetColumnID( - id_column.column_name); + 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, "department_table_01", - source_col_ids, index_name1, false, - IndexType::BWTREE, txn); + catalog->CreateIndex(TEST_DB_NAME, "department_table_01", source_col_ids, + index_name1, false, IndexType::BWTREE, txn); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); + // retrieve pg_index catalog table + auto database_object = + catalog::Catalog::GetInstance()->GetDatabaseObject(TEST_DB_NAME, txn); + EXPECT_NE(nullptr, database_object); + + auto pg_index = catalog::Catalog::GetInstance() + ->GetSystemCatalogs(database_object->GetDatabaseOid()) + ->GetIndexCatalog(); + EXPECT_NE(nullptr, pg_index); // Check the effect of drop // Most major check in this test case // Now dropping the index using the DropIndex functionality - catalog->DropIndex(index_name1,txn); - EXPECT_EQ(catalog::IndexCatalog::GetInstance()->GetIndexObject( - index_name1, txn), nullptr); + catalog->DropIndex(TEST_DB_NAME, index_name1, txn); + EXPECT_EQ(pg_index->GetIndexObject(index_name1, txn), nullptr); txn_manager.CommitTransaction(txn); // Drop the table just created txn = txn_manager.BeginTransaction(); // Check the effect of drop index - EXPECT_EQ(catalog::IndexCatalog::GetInstance()->GetIndexObject( - index_name1, txn), nullptr); + EXPECT_EQ(pg_index->GetIndexObject(index_name1, txn), nullptr); // Now dropping the table catalog->DropTable(TEST_DB_NAME, "department_table_01", txn); diff --git a/test/sql/drop_sql_test.cpp b/test/sql/drop_sql_test.cpp index 5b3c2b551b5..fbb10a7cbb2 100644 --- a/test/sql/drop_sql_test.cpp +++ b/test/sql/drop_sql_test.cpp @@ -14,6 +14,7 @@ #include "catalog/catalog.h" #include "catalog/index_catalog.h" +#include "catalog/system_catalogs.h" #include "common/harness.h" #include "concurrency/transaction_manager_factory.h" #include "executor/create_executor.h" @@ -101,12 +102,20 @@ TEST_F(DropSQLTests, DropIndexTest) { // Create a Index TestingSQLUtil::ExecuteSQLQuery("CREATE INDEX idx ON test(a);"); - + // retrieve pg_index catalog table + auto database_object = + catalog::Catalog::GetInstance()->GetDatabaseObject(DEFAULT_DB_NAME, txn); + EXPECT_NE(nullptr, database_object); + + auto pg_index = catalog::Catalog::GetInstance() + ->GetSystemCatalogs(database_object->GetDatabaseOid()) + ->GetIndexCatalog(); + EXPECT_NE(nullptr, pg_index); // Check if the index is in catalog std::shared_ptr index; txn = txn_manager.BeginTransaction(); try { - index = catalog::IndexCatalog::GetInstance()->GetIndexObject("idx", txn); + index = pg_index->GetIndexObject("idx", txn); } catch (CatalogException &e) { index = nullptr; @@ -120,11 +129,11 @@ TEST_F(DropSQLTests, DropIndexTest) { // Check if index is not in catalog txn = txn_manager.BeginTransaction(); - index = catalog::IndexCatalog::GetInstance()->GetIndexObject("idx", txn); + index = pg_index->GetIndexObject("idx", txn); txn_manager.CommitTransaction(txn); EXPECT_EQ(index, nullptr); - // Free the database just created + // Free the database just created txn = txn_manager.BeginTransaction(); catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); txn_manager.CommitTransaction(txn); From 0aed96f349d65d30d39ebf424ee112ccb155fdaa Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Wed, 14 Mar 2018 00:26:13 -0400 Subject: [PATCH 21/48] fix query cache test --- test/codegen/query_cache_test.cpp | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/test/codegen/query_cache_test.cpp b/test/codegen/query_cache_test.cpp index 410a3efe827..125517dc9fe 100644 --- a/test/codegen/query_cache_test.cpp +++ b/test/codegen/query_cache_test.cpp @@ -29,8 +29,6 @@ namespace peloton { namespace test { -constexpr int CACHE_USED_BY_CATALOG = 4; - class QueryCacheTest : public PelotonCodeGenTest { public: QueryCacheTest() : PelotonCodeGenTest(), num_rows_to_insert(64) { @@ -210,6 +208,8 @@ class QueryCacheTest : public PelotonCodeGenTest { }; TEST_F(QueryCacheTest, SimpleCache) { + int CACHE_USED_BY_CATALOG = codegen::QueryCache::Instance().GetCount(); + // SELECT b FROM table where a >= 40; std::shared_ptr scan1 = GetSeqScanPlan(); std::shared_ptr scan2 = GetSeqScanPlan(); @@ -254,6 +254,8 @@ TEST_F(QueryCacheTest, SimpleCache) { } TEST_F(QueryCacheTest, CacheSeqScanPlan) { + int CACHE_USED_BY_CATALOG = codegen::QueryCache::Instance().GetCount(); + // SELECT a, b, c FROM table where a >= 20 and b = 21; auto scan1 = GetSeqScanPlanWithPredicate(); auto scan2 = GetSeqScanPlanWithPredicate(); @@ -304,6 +306,8 @@ TEST_F(QueryCacheTest, CacheSeqScanPlan) { } TEST_F(QueryCacheTest, CacheHashJoinPlan) { + int CACHE_USED_BY_CATALOG = codegen::QueryCache::Instance().GetCount(); + auto hj_plan1 = GetHashJoinPlan(); auto hj_plan_2 = GetHashJoinPlan(); @@ -363,6 +367,8 @@ TEST_F(QueryCacheTest, CacheHashJoinPlan) { } TEST_F(QueryCacheTest, CacheOrderByPlan) { + int CACHE_USED_BY_CATALOG = codegen::QueryCache::Instance().GetCount(); + // plan 1, 2: SELECT * FROM test_table ORDER BY b DESC a ASC; // plan 3: SELECT * FROM test_table ORDER BY b ASC a DESC; std::shared_ptr order_by_plan_1{ @@ -442,6 +448,8 @@ TEST_F(QueryCacheTest, CacheOrderByPlan) { } TEST_F(QueryCacheTest, CacheAggregatePlan) { + int CACHE_USED_BY_CATALOG = codegen::QueryCache::Instance().GetCount(); + auto agg_plan1 = GetAggregatePlan(); auto agg_plan_2 = GetAggregatePlan(); @@ -492,6 +500,8 @@ TEST_F(QueryCacheTest, CacheAggregatePlan) { } TEST_F(QueryCacheTest, CacheNestedLoopJoinPlan) { + int CACHE_USED_BY_CATALOG = codegen::QueryCache::Instance().GetCount(); + auto nlj_plan_1 = GetBlockNestedLoopJoinPlan(); auto nlj_plan_2 = GetBlockNestedLoopJoinPlan(); From a21bb1305bfe5c134fa32edd36a9e0c50dde0278 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Wed, 14 Mar 2018 00:10:02 -0400 Subject: [PATCH 22/48] change test case, mainly gettablecount --- test/executor/create_index_test.cpp | 4 +-- test/executor/create_test.cpp | 4 +-- test/executor/delete_test.cpp | 2 +- test/executor/update_test.cpp | 8 +++--- test/optimizer/old_optimizer_test.cpp | 2 +- test/optimizer/optimizer_rule_test.cpp | 2 ++ test/optimizer/optimizer_test.cpp | 25 ++++++++----------- test/optimizer/tuple_samples_storage_test.cpp | 8 +++--- test/planner/plan_util_test.cpp | 2 +- test/storage/database_test.cpp | 6 ++--- 10 files changed, 31 insertions(+), 32 deletions(-) diff --git a/test/executor/create_index_test.cpp b/test/executor/create_index_test.cpp index acef289ae66..576d68cb2c6 100644 --- a/test/executor/create_index_test.cpp +++ b/test/executor/create_index_test.cpp @@ -10,9 +10,9 @@ // //===----------------------------------------------------------------------===// -#include "traffic_cop/traffic_cop.h" #include #include "sql/testing_sql_util.h" +#include "traffic_cop/traffic_cop.h" #include "binder/bind_node_visitor.h" #include "catalog/catalog.h" @@ -118,7 +118,7 @@ TEST_F(CreateIndexTests, CreatingIndex) { EXPECT_EQ(catalog::Catalog::GetInstance() ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) ->GetTableCount(), - 1); + 4); // Inserting a tuple end-to-end traffic_cop.SetTcopTxnState(txn); diff --git a/test/executor/create_test.cpp b/test/executor/create_test.cpp index 6e8c44bd0ce..82460e7cf47 100644 --- a/test/executor/create_test.cpp +++ b/test/executor/create_test.cpp @@ -110,7 +110,7 @@ TEST_F(CreateTests, CreatingTable) { executor.Init(); executor.Execute(); - EXPECT_EQ(1, (int)catalog::Catalog::GetInstance() + EXPECT_EQ(4, (int)catalog::Catalog::GetInstance() ->GetDatabaseObject(DEFAULT_DB_NAME, txn) ->GetTableObjects() .size()); @@ -155,7 +155,7 @@ TEST_F(CreateTests, CreatingUDFs) { executor.Init(); executor.Execute(); - EXPECT_EQ(1, (int)catalog::Catalog::GetInstance() + EXPECT_EQ(4, (int)catalog::Catalog::GetInstance() ->GetDatabaseObject(DEFAULT_DB_NAME, txn) ->GetTableObjects() .size()); diff --git a/test/executor/delete_test.cpp b/test/executor/delete_test.cpp index 5deefbdddca..32ce676b79a 100644 --- a/test/executor/delete_test.cpp +++ b/test/executor/delete_test.cpp @@ -121,7 +121,7 @@ TEST_F(DeleteTests, VariousOperations) { executor::CreateExecutor create_executor(&node, context.get()); create_executor.Init(); create_executor.Execute(); - EXPECT_EQ(1, (int)catalog::Catalog::GetInstance() + EXPECT_EQ(4, (int)catalog::Catalog::GetInstance() ->GetDatabaseObject(DEFAULT_DB_NAME, txn) ->GetTableObjects() .size()); diff --git a/test/executor/update_test.cpp b/test/executor/update_test.cpp index 0f4b8724516..8db4f755276 100644 --- a/test/executor/update_test.cpp +++ b/test/executor/update_test.cpp @@ -12,13 +12,14 @@ #include +#include "common/harness.h" #include "executor/testing_executor_util.h" #include "sql/testing_sql_util.h" -#include "common/harness.h" #include "binder/bind_node_visitor.h" #include "catalog/catalog.h" #include "catalog/schema.h" +#include "common/internal_types.h" #include "common/logger.h" #include "common/statement.h" #include "concurrency/transaction_context.h" @@ -46,7 +47,6 @@ #include "storage/data_table.h" #include "storage/tile_group_factory.h" #include "traffic_cop/traffic_cop.h" -#include "common/internal_types.h" #include "type/value.h" #include "type/value_factory.h" @@ -182,7 +182,7 @@ TEST_F(UpdateTests, UpdatingOld) { create_executor.Init(); create_executor.Execute(); EXPECT_EQ(catalog->GetDatabaseWithName(DEFAULT_DB_NAME, txn)->GetTableCount(), - 1); + 4); LOG_INFO("Table created!"); @@ -416,6 +416,6 @@ TEST_F(UpdateTests, UpdatingOld) { catalog->DropDatabaseWithName(DEFAULT_DB_NAME, txn); txn_manager.CommitTransaction(txn); } -} // namespace? +} // namespace } // namespace test } // namespace peloton diff --git a/test/optimizer/old_optimizer_test.cpp b/test/optimizer/old_optimizer_test.cpp index 6ae7b96f6cb..3033722805a 100644 --- a/test/optimizer/old_optimizer_test.cpp +++ b/test/optimizer/old_optimizer_test.cpp @@ -104,7 +104,7 @@ TEST_F(OldOptimizerTests, UpdateDelWithIndexScanTest) { EXPECT_EQ(catalog::Catalog::GetInstance() ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) ->GetTableCount(), - 1); + 4); // Inserting a tuple end-to-end traffic_cop.SetTcopTxnState(txn); diff --git a/test/optimizer/optimizer_rule_test.cpp b/test/optimizer/optimizer_rule_test.cpp index fbcac54f9b4..e4266a7fa91 100644 --- a/test/optimizer/optimizer_rule_test.cpp +++ b/test/optimizer/optimizer_rule_test.cpp @@ -23,6 +23,8 @@ #include "executor/update_executor.h" #include "expression/abstract_expression.h" #include "expression/operator_expression.h" + +#define private public #include "optimizer/operator_expression.h" #include "optimizer/operators.h" #include "optimizer/optimizer.h" diff --git a/test/optimizer/optimizer_test.cpp b/test/optimizer/optimizer_test.cpp index 372053e9f78..7e2e6b3a777 100644 --- a/test/optimizer/optimizer_test.cpp +++ b/test/optimizer/optimizer_test.cpp @@ -12,6 +12,7 @@ #include "common/harness.h" +#include "binder/bind_node_visitor.h" #include "catalog/catalog.h" #include "common/logger.h" #include "common/statement.h" @@ -19,23 +20,19 @@ #include "executor/create_executor.h" #include "executor/insert_executor.h" #include "executor/plan_executor.h" +#include "expression/tuple_value_expression.h" +#include "optimizer/operators.h" #include "optimizer/optimizer.h" -#include "parser/mock_sql_statement.h" +#include "optimizer/rule_impls.h" #include "parser/postgresparser.h" +#include "planner/abstract_join_plan.h" #include "planner/create_plan.h" #include "planner/delete_plan.h" +#include "planner/hash_join_plan.h" #include "planner/insert_plan.h" +#include "planner/seq_scan_plan.h" #include "planner/update_plan.h" #include "sql/testing_sql_util.h" -#include "planner/seq_scan_plan.h" -#include "planner/abstract_join_plan.h" -#include "planner/hash_join_plan.h" -#include "binder/bind_node_visitor.h" -#include "traffic_cop/traffic_cop.h" -#include "expression/tuple_value_expression.h" -#include "optimizer/mock_task.h" -#include "optimizer/operators.h" -#include "optimizer/rule_impls.h" #include "traffic_cop/traffic_cop.h" namespace peloton { @@ -124,7 +121,7 @@ TEST_F(OptimizerTests, HashJoinTest) { EXPECT_EQ(catalog::Catalog::GetInstance() ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) ->GetTableCount(), - 1); + 4); traffic_cop.SetTcopTxnState(txn); LOG_INFO("Creating table"); @@ -159,7 +156,7 @@ TEST_F(OptimizerTests, HashJoinTest) { EXPECT_EQ(catalog::Catalog::GetInstance() ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) ->GetTableCount(), - 2); + 5); // Inserting a tuple to table_a traffic_cop.SetTcopTxnState(txn); @@ -485,8 +482,8 @@ TEST_F(OptimizerTests, ExecuteTaskStackTest) { optimizer.GetMetadata().memo.Groups().emplace_back(root_group); auto required_prop = std::make_shared(PropertySet()); - auto root_context = - std::make_shared(&(optimizer.GetMetadata()), required_prop); + auto root_context = std::make_shared( + &(optimizer.GetMetadata()), required_prop); auto task_stack = std::unique_ptr(new OptimizerTaskStack()); auto &timer = optimizer.GetMetadata().timer; diff --git a/test/optimizer/tuple_samples_storage_test.cpp b/test/optimizer/tuple_samples_storage_test.cpp index 72249805a7a..36e6a785646 100644 --- a/test/optimizer/tuple_samples_storage_test.cpp +++ b/test/optimizer/tuple_samples_storage_test.cpp @@ -12,14 +12,14 @@ #include "common/harness.h" -#include "optimizer/stats/tuple_samples_storage.h" #include "optimizer/stats/tuple_sampler.h" +#include "optimizer/stats/tuple_samples_storage.h" -#include "storage/data_table.h" -#include "storage/database.h" #include "catalog/catalog.h" -#include "executor/testing_executor_util.h" #include "concurrency/transaction_manager_factory.h" +#include "executor/testing_executor_util.h" +#include "storage/data_table.h" +#include "storage/database.h" namespace peloton { namespace test { diff --git a/test/planner/plan_util_test.cpp b/test/planner/plan_util_test.cpp index 504552f372e..814c0e194e3 100644 --- a/test/planner/plan_util_test.cpp +++ b/test/planner/plan_util_test.cpp @@ -82,7 +82,7 @@ TEST_F(PlanUtilTests, GetAffectedIndexesTest) { // This is also required so that database objects are cached auto db_object = catalog->GetDatabaseObject(TEST_DB_NAME, txn); - EXPECT_EQ(1, static_cast(db_object->GetTableObjects().size())); + EXPECT_EQ(4, static_cast(db_object->GetTableObjects().size())); // Till now, we have a table : id, first_name, last_name // And two indexes on following columns: diff --git a/test/storage/database_test.cpp b/test/storage/database_test.cpp index c964eee927d..d6c35f4af1c 100644 --- a/test/storage/database_test.cpp +++ b/test/storage/database_test.cpp @@ -12,8 +12,8 @@ #include "common/harness.h" -#include "concurrency/transaction_manager_factory.h" #include "catalog/catalog.h" +#include "concurrency/transaction_manager_factory.h" #include "storage/data_table.h" #include "storage/database.h" #include "storage/storage_manager.h" @@ -63,11 +63,11 @@ TEST_F(DatabaseTests, AddDropTableTest) { database->AddTable(data_table.get()); - EXPECT_TRUE(database->GetTableCount() == 1); + EXPECT_TRUE(database->GetTableCount() == 4); database->DropTableWithOid(table_oid); - EXPECT_TRUE(database->GetTableCount() == 0); + EXPECT_TRUE(database->GetTableCount() == 3); data_table.release(); From 5d877bfddd297b06d71e3e488e9b0006f0523e71 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Wed, 14 Mar 2018 17:17:25 -0400 Subject: [PATCH 23/48] half way fixing trigger test --- src/catalog/abstract_catalog.cpp | 8 ++-- src/catalog/catalog.cpp | 1 - src/catalog/system_catalogs.cpp | 55 +++++++++------------------ src/catalog/trigger_catalog.cpp | 39 +++++++++---------- src/include/catalog/system_catalogs.h | 2 + src/include/catalog/trigger_catalog.h | 9 ++--- 6 files changed, 46 insertions(+), 68 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 23286cd540a..d380a4252f8 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -79,20 +79,22 @@ AbstractCatalog::AbstractCatalog(const std::string &catalog_table_ddl, optimizer::Optimizer().BuildPelotonPlanTree(parse_tree_list, txn)); auto catalog_table_schema = create_plan->GetSchema(); auto catalog_table_name = create_plan->GetTableName(); + auto catalog_database_name = create_plan->GetDatabaseName(); // Create catalog table Catalog::GetInstance()->CreateTable( - CATALOG_DATABASE_NAME, catalog_table_name, + catalog_database_name, catalog_table_name, std::unique_ptr(catalog_table_schema), txn, true); // Get catalog table oid auto catalog_table_object = Catalog::GetInstance()->GetTableObject( - CATALOG_DATABASE_NAME, catalog_table_name, txn); + catalog_database_name, catalog_table_name, txn); // Set catalog_table_ try { catalog_table_ = storage::StorageManager::GetInstance()->GetTableWithOid( - CATALOG_DATABASE_OID, catalog_table_object->GetTableOid()); + catalog_table_object->GetDatabaseOid(), + catalog_table_object->GetTableOid()); } catch (CatalogException &e) { LOG_TRACE("Can't find table %d! Return false", catalog_table_object->GetTableOid()); diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index efe4733d46a..885fb9c2aeb 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -164,7 +164,6 @@ void Catalog::Bootstrap() { IndexMetricsCatalog::GetInstance(txn); QueryMetricsCatalog::GetInstance(txn); SettingsCatalog::GetInstance(txn); - TriggerCatalog::GetInstance(txn); LanguageCatalog::GetInstance(txn); ProcCatalog::GetInstance(txn); diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index 09e9ebf534f..eb78d9725f8 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -31,43 +31,24 @@ SystemCatalogs::SystemCatalogs(storage::Database *database, // TODO: can we move this to BootstrapSystemCatalogs()? // insert pg_database columns into pg_attribute - oid_t column_id = 0; - for (auto column : - storage::StorageManager::GetInstance() - ->GetTableWithOid(CATALOG_DATABASE_OID, DATABASE_CATALOG_OID) - ->GetSchema() - ->GetColumns()) { - pg_attribute->InsertColumn(DATABASE_CATALOG_OID, column.GetName(), - column_id, column.GetOffset(), column.GetType(), - column.IsInlined(), column.GetConstraints(), - pool, txn); - column_id++; - } - - // Insert pg_table columns into pg_attribute - column_id = 0; - for (auto column : storage::StorageManager::GetInstance() - ->GetTableWithOid(database_oid, TABLE_CATALOG_OID) - ->GetSchema() - ->GetColumns()) { - pg_attribute->InsertColumn(TABLE_CATALOG_OID, column.GetName(), column_id, - column.GetOffset(), column.GetType(), - column.IsInlined(), column.GetConstraints(), - pool, txn); - column_id++; - } - - // Insert pg_index columns into pg_attribute - column_id = 0; - for (auto column : storage::StorageManager::GetInstance() - ->GetTableWithOid(database_oid, INDEX_CATALOG_OID) - ->GetSchema() - ->GetColumns()) { - pg_attribute->InsertColumn(INDEX_CATALOG_OID, column.GetName(), column_id, - column.GetOffset(), column.GetType(), - column.IsInlined(), column.GetConstraints(), - pool, txn); - column_id++; + std::vector> shared_tables = { + {CATALOG_DATABASE_OID, DATABASE_CATALOG_OID}, + {database_oid, TABLE_CATALOG_OID}, + {database_oid, INDEX_CATALOG_OID}}; + + for (int i = 0; i < shared_tables.size(); i++) { + oid_t column_id = 0; + for (auto column : + storage::StorageManager::GetInstance() + ->GetTableWithOid(CATALOG_DATABASE_OID, DATABASE_CATALOG_OID) + ->GetSchema() + ->GetColumns()) { + pg_attribute->InsertColumn(DATABASE_CATALOG_OID, column.GetName(), + column_id, column.GetOffset(), + column.GetType(), column.IsInlined(), + column.GetConstraints(), pool, txn); + column_id++; + } } } diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index e04fbe3d906..0c37b43554a 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -21,36 +21,32 @@ namespace peloton { namespace catalog { -TriggerCatalog &TriggerCatalog::GetInstance(concurrency::TransactionContext *txn) { - static TriggerCatalog trigger_catalog{txn}; - return trigger_catalog; -} - -TriggerCatalog::TriggerCatalog(concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_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);", +TriggerCatalog::TriggerCatalog(const std::string &database_name, + concurrency::TransactionContext *txn) + : AbstractCatalog("CREATE TABLE " + database_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) { // Add secondary index here if necessary Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, TRIGGER_CATALOG_NAME, + database_name, TRIGGER_CATALOG_NAME, {ColumnId::TABLE_OID, ColumnId::TRIGGER_TYPE}, TRIGGER_CATALOG_NAME "_skey0", false, IndexType::BWTREE, txn); Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, TRIGGER_CATALOG_NAME, {ColumnId::TABLE_OID}, + database_name, TRIGGER_CATALOG_NAME, {ColumnId::TABLE_OID}, TRIGGER_CATALOG_NAME "_skey1", false, IndexType::BWTREE, txn); Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, TRIGGER_CATALOG_NAME, + database_name, TRIGGER_CATALOG_NAME, {ColumnId::TRIGGER_NAME, ColumnId::TABLE_OID}, TRIGGER_CATALOG_NAME "_skey2", false, IndexType::BWTREE, txn); } @@ -165,7 +161,8 @@ bool TriggerCatalog::DeleteTriggerByName(const std::string &trigger_name, } std::unique_ptr TriggerCatalog::GetTriggersByType( - oid_t table_oid, int16_t trigger_type, concurrency::TransactionContext *txn) { + oid_t table_oid, int16_t trigger_type, + concurrency::TransactionContext *txn) { LOG_INFO("Get triggers for table %d", table_oid); // select trigger_name, fire condition, function_name, function_args std::vector column_ids( diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h index 17f2f7ddd34..e5b21d2854a 100644 --- a/src/include/catalog/system_catalogs.h +++ b/src/include/catalog/system_catalogs.h @@ -42,11 +42,13 @@ class SystemCatalogs { ColumnCatalog *GetColumnCatalog() { return pg_attribute; } TableCatalog *GetTableCatalog() { return pg_table; } IndexCatalog *GetIndexCatalog() { return pg_index; } + TriggerCatalog *GetTriggerCatalog() { return pg_trigger; } private: ColumnCatalog *pg_attribute; TableCatalog *pg_table; IndexCatalog *pg_index; + TriggerCatalog *pg_trigger; }; } // namespace catalog diff --git a/src/include/catalog/trigger_catalog.h b/src/include/catalog/trigger_catalog.h index 14c9acbf888..967c05124ad 100644 --- a/src/include/catalog/trigger_catalog.h +++ b/src/include/catalog/trigger_catalog.h @@ -47,11 +47,9 @@ namespace catalog { class TriggerCatalog : public AbstractCatalog { public: + TriggerCatalog(concurrency::TransactionContext *txn); ~TriggerCatalog(); - // Global Singleton - static TriggerCatalog &GetInstance(concurrency::TransactionContext *txn = nullptr); - //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// @@ -74,7 +72,8 @@ class TriggerCatalog : public AbstractCatalog { // of the same type //===--------------------------------------------------------------------===// std::unique_ptr GetTriggersByType( - oid_t table_oid, int16_t trigger_type, concurrency::TransactionContext *txn); + oid_t table_oid, int16_t trigger_type, + concurrency::TransactionContext *txn); //===--------------------------------------------------------------------===// // get all types of triggers for a specific table @@ -97,8 +96,6 @@ class TriggerCatalog : public AbstractCatalog { }; private: - TriggerCatalog(concurrency::TransactionContext *txn); - oid_t GetNextOid() { return oid_++ | TRIGGER_OID_MASK; } enum IndexId { From ec6d27a1fcb8055530e09804b3db81958f6406ab Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Thu, 15 Mar 2018 10:40:00 -0400 Subject: [PATCH 24/48] trigger catalog --- src/catalog/system_catalogs.cpp | 7 +- src/executor/create_executor.cpp | 57 +++++----- src/executor/drop_executor.cpp | 12 +- src/include/catalog/catalog.h | 6 +- src/include/catalog/system_catalogs.h | 2 + src/storage/data_table.cpp | 152 +++++++++++++------------- 6 files changed, 121 insertions(+), 115 deletions(-) diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index eb78d9725f8..f29d3303210 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -30,7 +30,6 @@ SystemCatalogs::SystemCatalogs(storage::Database *database, pg_index = new IndexCatalog(database, pool, txn); // TODO: can we move this to BootstrapSystemCatalogs()? - // insert pg_database columns into pg_attribute std::vector> shared_tables = { {CATALOG_DATABASE_OID, DATABASE_CATALOG_OID}, {database_oid, TABLE_CATALOG_OID}, @@ -56,6 +55,12 @@ SystemCatalogs::~SystemCatalogs() { delete pg_index; delete pg_table; delete pg_attribute; + if (pg_trigger) delete pg_trigger; +} + +void SystemCatalogs::Bootstrap(const string &database_name) { + pg_trigger = + new TriggerCatalog(database_name, concurrency::TransactionContext * txn); } } // namespace catalog diff --git a/src/executor/create_executor.cpp b/src/executor/create_executor.cpp index 22c4eb77e2c..e82e16f79ee 100644 --- a/src/executor/create_executor.cpp +++ b/src/executor/create_executor.cpp @@ -87,14 +87,12 @@ bool CreateExecutor::DExecute() { } bool CreateExecutor::CreateDatabase(const planner::CreatePlan &node) { - auto txn = context_->GetTransaction(); auto database_name = node.GetDatabaseName(); - ResultType result = catalog::Catalog::GetInstance()->CreateDatabase( - database_name, txn); + ResultType result = + catalog::Catalog::GetInstance()->CreateDatabase(database_name, txn); txn->SetResult(result); - LOG_TRACE("Result is: %s", - ResultTypeToString(txn->GetResult()).c_str()); + LOG_TRACE("Result is: %s", ResultTypeToString(txn->GetResult()).c_str()); return (true); } @@ -153,30 +151,25 @@ bool CreateExecutor::CreateTable(const planner::CreatePlan &node) { PELOTON_ASSERT(sink_col_ids.size() == fk.foreign_key_sinks.size()); // Create the catalog object and shove it into the table - auto catalog_fk = new catalog::ForeignKey(INVALID_OID, - sink_table->GetOid(), sink_col_ids, source_col_ids, + auto catalog_fk = new catalog::ForeignKey( + INVALID_OID, sink_table->GetOid(), sink_col_ids, source_col_ids, fk.upd_action, fk.del_action, fk.constraint_name); source_table->AddForeignKey(catalog_fk); // Register FK with the sink table for delete/update actions - catalog_fk = new catalog::ForeignKey(source_table->GetOid(), - INVALID_OID, - sink_col_ids, - source_col_ids, - fk.upd_action, - fk.del_action, - fk.constraint_name); + catalog_fk = new catalog::ForeignKey( + source_table->GetOid(), INVALID_OID, sink_col_ids, source_col_ids, + fk.upd_action, fk.del_action, fk.constraint_name); sink_table->RegisterForeignKeySource(catalog_fk); // Add a non-unique index on the source table if needed - std::vector source_col_names = - fk.foreign_key_sources; - std::string index_name = - source_table->GetName() + "_FK_" + sink_table->GetName() + "_" - + std::to_string(count); + std::vector source_col_names = fk.foreign_key_sources; + std::string index_name = source_table->GetName() + "_FK_" + + sink_table->GetName() + "_" + + std::to_string(count); catalog->CreateIndex(database_name, source_table->GetName(), - source_col_ids, index_name, false, - IndexType::BWTREE, current_txn); + source_col_ids, index_name, false, + IndexType::BWTREE, current_txn); count++; #ifdef LOG_DEBUG_ENABLED @@ -212,8 +205,8 @@ bool CreateExecutor::CreateIndex(const planner::CreatePlan &node) { auto key_attrs = node.GetKeyAttrs(); ResultType result = catalog::Catalog::GetInstance()->CreateIndex( - database_name, table_name, key_attrs, index_name, unique_flag, - index_type, txn); + database_name, table_name, key_attrs, index_name, unique_flag, index_type, + txn); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { @@ -221,8 +214,7 @@ bool CreateExecutor::CreateIndex(const planner::CreatePlan &node) { } else if (txn->GetResult() == ResultType::FAILURE) { LOG_TRACE("Creating table failed!"); } else { - LOG_TRACE("Result is: %s", - ResultTypeToString(txn->GetResult()).c_str()); + LOG_TRACE("Result is: %s", ResultTypeToString(txn->GetResult()).c_str()); } return (true); } @@ -250,14 +242,16 @@ bool CreateExecutor::CreateTrigger(const planner::CreatePlan &node) { auto when = type::ValueFactory::GetVarbinaryValue( (const unsigned char *)output.Data(), (int32_t)output.Size(), true); - catalog::TriggerCatalog::GetInstance().InsertTrigger( - table_object->GetTableOid(), trigger_name, - newTrigger.GetTriggerType(), newTrigger.GetFuncname(), - newTrigger.GetArgs(), when, time_stamp, pool_.get(), txn); + catalog::Catalog::GetInstance() + .GetSystemCatalogs(table_object->database_oid) + .GetTriggerCatalog() + .InsertTrigger(table_object->GetTableOid(), trigger_name, + newTrigger.GetTriggerType(), newTrigger.GetFuncname(), + newTrigger.GetArgs(), when, time_stamp, pool_.get(), txn); // ask target table to update its trigger list variable storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName( - database_name, table_name, txn); + catalog::Catalog::GetInstance()->GetTableWithName(database_name, + table_name, txn); target_table->UpdateTriggerListFromCatalog(txn); // hardcode SUCCESS result for txn @@ -270,6 +264,5 @@ bool CreateExecutor::CreateTrigger(const planner::CreatePlan &node) { return (true); } - } // namespace executor } // namespace peloton diff --git a/src/executor/drop_executor.cpp b/src/executor/drop_executor.cpp index db7d70b0c23..30182da8002 100644 --- a/src/executor/drop_executor.cpp +++ b/src/executor/drop_executor.cpp @@ -150,13 +150,19 @@ bool DropExecutor::DropTable(const planner::DropPlan &node, bool DropExecutor::DropTrigger(const planner::DropPlan &node, concurrency::TransactionContext *txn) { auto database_name = node.GetDatabaseName(); - std::string table_name = node.GetTableName(); + auto table_name = node.GetTableName(); LOG_DEBUG("database name: %s", database_name.c_str()); LOG_DEBUG("table name: %s", table_name.c_str()); std::string trigger_name = node.GetTriggerName(); - ResultType result = catalog::TriggerCatalog::GetInstance().DropTrigger( - database_name, table_name, trigger_name, txn); + auto table_object = catalog::Catalog::GetInstance()->GetTableObject( + database_name, table_name, txn); + + ResultType result = + catalog::Catalog::GetInstance() + .GetSystemCatalogs(table_object->database_oid) + .GetTriggerCatalog() + .DropTrigger(database_name, table_name, trigger_name, txn); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { LOG_DEBUG("Dropping trigger succeeded!"); diff --git a/src/include/catalog/catalog.h b/src/include/catalog/catalog.h index e631da45f43..f90bab5eaca 100644 --- a/src/include/catalog/catalog.h +++ b/src/include/catalog/catalog.h @@ -134,10 +134,12 @@ class Catalog { ResultType DropTable(oid_t database_oid, oid_t table_oid, concurrency::TransactionContext *txn); // Drop an index, using its index_oid - ResultType DropIndex(oid_t database_oid, oid_t index_oid, concurrency::TransactionContext *txn); + ResultType DropIndex(oid_t database_oid, oid_t index_oid, + concurrency::TransactionContext *txn); // Drop an index, using its index name - ResultType DropIndex(const std::string &database_name, const std::string &index_name, + ResultType DropIndex(const std::string &database_name, + const std::string &index_name, concurrency::TransactionContext *txn); //===--------------------------------------------------------------------===// // GET WITH NAME - CHECK FROM CATALOG TABLES, USING TRANSACTION diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h index e5b21d2854a..81cd9924467 100644 --- a/src/include/catalog/system_catalogs.h +++ b/src/include/catalog/system_catalogs.h @@ -39,6 +39,8 @@ class SystemCatalogs { ~SystemCatalogs(); + void Bootstrap(); + ColumnCatalog *GetColumnCatalog() { return pg_attribute; } TableCatalog *GetTableCatalog() { return pg_table; } IndexCatalog *GetIndexCatalog() { return pg_index; } diff --git a/src/storage/data_table.cpp b/src/storage/data_table.cpp index 94091249071..0779b0853d2 100644 --- a/src/storage/data_table.cpp +++ b/src/storage/data_table.cpp @@ -67,7 +67,6 @@ DataTable::DataTable(catalog::Schema *schema, const std::string &table_name, tuples_per_tilegroup_(tuples_per_tilegroup), adapt_table_(adapt_table), trigger_list_(new trigger::TriggerList()) { - // Init default partition auto col_count = schema->GetColumnCount(); for (oid_t col_itr = 0; col_itr < col_count; col_itr++) { @@ -341,16 +340,17 @@ ItemPointer DataTable::InsertTuple(const storage::Tuple *tuple, return INVALID_ITEMPOINTER; } - auto result = InsertTuple(tuple, location, transaction, index_entry_ptr, check_fk); + auto result = + InsertTuple(tuple, location, transaction, index_entry_ptr, check_fk); if (result == false) { return INVALID_ITEMPOINTER; } return location; } -bool DataTable::InsertTuple(const AbstractTuple *tuple, - ItemPointer location, concurrency::TransactionContext *transaction, - ItemPointer **index_entry_ptr, bool check_fk) { +bool DataTable::InsertTuple(const AbstractTuple *tuple, ItemPointer location, + concurrency::TransactionContext *transaction, + ItemPointer **index_entry_ptr, bool check_fk) { if (CheckConstraints(tuple) == false) { LOG_TRACE("InsertTuple(): Constraint violated"); return false; @@ -501,10 +501,10 @@ bool DataTable::InsertInIndexes(const AbstractTuple *tuple, return true; } -bool DataTable::InsertInSecondaryIndexes(const AbstractTuple *tuple, - const TargetList *targets_ptr, - concurrency::TransactionContext *transaction, - ItemPointer *index_entry_ptr) { +bool DataTable::InsertInSecondaryIndexes( + const AbstractTuple *tuple, const TargetList *targets_ptr, + concurrency::TransactionContext *transaction, + ItemPointer *index_entry_ptr) { int index_count = GetIndexCount(); // Transform the target list into a hash set // when attempting to perform insertion to a secondary index, @@ -571,10 +571,11 @@ bool DataTable::InsertInSecondaryIndexes(const AbstractTuple *tuple, } /** - * @brief This function checks any other table which has a foreign key constraint + * @brief This function checks any other table which has a foreign key + *constraint * referencing the current table, where a tuple is updated/deleted. The final * result depends on the type of cascade action. - * + * * @param prev_tuple: The tuple which will be updated/deleted in the current * table * @param new_tuple: The new tuple after update. This parameter is ignored @@ -582,17 +583,16 @@ bool DataTable::InsertInSecondaryIndexes(const AbstractTuple *tuple, * @param current_txn: The current transaction context * @param context: The executor context passed from upper level * @param is_update: whether this is a update action (false means delete) - * - * @return True if the check is successful (nothing happens) or the cascade operation + * + * @return True if the check is successful (nothing happens) or the cascade + *operation * is done properly. Otherwise returns false. Note that the transaction result * is not set in this function. - */ -bool DataTable::CheckForeignKeySrcAndCascade(storage::Tuple *prev_tuple, - storage::Tuple *new_tuple, - concurrency::TransactionContext *current_txn, - executor::ExecutorContext *context, - bool is_update) -{ + */ +bool DataTable::CheckForeignKeySrcAndCascade( + storage::Tuple *prev_tuple, storage::Tuple *new_tuple, + concurrency::TransactionContext *current_txn, + executor::ExecutorContext *context, bool is_update) { size_t fk_count = GetForeignKeySrcCount(); if (fk_count == 0) return true; @@ -602,7 +602,7 @@ bool DataTable::CheckForeignKeySrcAndCascade(storage::Tuple *prev_tuple, for (size_t iter = 0; iter < fk_count; iter++) { catalog::ForeignKey *fk = GetForeignKeySrc(iter); - + // Check if any row in the source table references the current tuple oid_t source_table_id = fk->GetSourceTableOid(); storage::DataTable *src_table = nullptr; @@ -621,18 +621,17 @@ bool DataTable::CheckForeignKeySrcAndCascade(storage::Tuple *prev_tuple, // Make sure this is the right index to search in if (index->GetMetadata()->GetName().find("_FK_") != std::string::npos && - index->GetMetadata()->GetKeyAttrs() == fk->GetSourceColumnIds()) - { - LOG_DEBUG("Searching in source tables's fk index...\n"); + index->GetMetadata()->GetKeyAttrs() == fk->GetSourceColumnIds()) { + LOG_DEBUG("Searching in source tables's fk index...\n"); std::vector key_attrs = fk->GetSourceColumnIds(); std::unique_ptr fk_schema( - catalog::Schema::CopySchema(src_table->GetSchema(), key_attrs)); + catalog::Schema::CopySchema(src_table->GetSchema(), key_attrs)); std::unique_ptr key( - new storage::Tuple(fk_schema.get(), true)); - + new storage::Tuple(fk_schema.get(), true)); + key->SetFromTuple(prev_tuple, fk->GetSinkColumnIds(), index->GetPool()); - + std::vector location_ptrs; index->ScanKey(key.get(), location_ptrs); @@ -644,8 +643,8 @@ bool DataTable::CheckForeignKeySrcAndCascade(storage::Tuple *prev_tuple, auto src_tile_group_header = src_tile_group->GetHeader(); auto visibility = transaction_manager.IsVisible( - current_txn, src_tile_group_header, ptr->offset, - VisibilityIdType::COMMIT_ID); + current_txn, src_tile_group_header, ptr->offset, + VisibilityIdType::COMMIT_ID); if (visibility != VisibilityType::OK) continue; @@ -655,32 +654,34 @@ bool DataTable::CheckForeignKeySrcAndCascade(storage::Tuple *prev_tuple, case FKConstrActionType::RESTRICT: { return false; } - case FKConstrActionType::CASCADE: + case FKConstrActionType::CASCADE: default: { // Update - bool src_is_owner = transaction_manager.IsOwner(current_txn, - src_tile_group_header, ptr->offset); + bool src_is_owner = transaction_manager.IsOwner( + current_txn, src_tile_group_header, ptr->offset); - // Read the referencing tuple, update the read timestamp so that we can + // Read the referencing tuple, update the read timestamp so that + // we can // delete it later - bool ret = transaction_manager.PerformRead(current_txn, - *ptr, - true); + bool ret = + transaction_manager.PerformRead(current_txn, *ptr, true); if (ret == false) { if (src_is_owner) { - transaction_manager.YieldOwnership(current_txn, src_tile_group_header, - ptr->offset); + transaction_manager.YieldOwnership( + current_txn, src_tile_group_header, ptr->offset); } return false; } - ContainerTuple src_old_tuple(src_tile_group.get(), ptr->offset); + ContainerTuple src_old_tuple( + src_tile_group.get(), ptr->offset); storage::Tuple src_new_tuple(src_table->GetSchema(), true); if (is_update) { - for (oid_t col_itr = 0; col_itr < src_table->GetSchema()->GetColumnCount(); col_itr++) - { + for (oid_t col_itr = 0; + col_itr < src_table->GetSchema()->GetColumnCount(); + col_itr++) { type::Value val = src_old_tuple.GetValue(col_itr); src_new_tuple.SetValue(col_itr, val, context->GetPool()); } @@ -690,8 +691,8 @@ bool DataTable::CheckForeignKeySrcAndCascade(storage::Tuple *prev_tuple, auto src_col_index = key_attrs[k]; auto sink_col_index = fk->GetSinkColumnIds()[k]; src_new_tuple.SetValue(src_col_index, - new_tuple->GetValue(sink_col_index), - context->GetPool()); + new_tuple->GetValue(sink_col_index), + context->GetPool()); } } @@ -699,16 +700,13 @@ bool DataTable::CheckForeignKeySrcAndCascade(storage::Tuple *prev_tuple, if (new_loc.IsNull()) { if (src_is_owner == false) { - transaction_manager.YieldOwnership(current_txn, - src_tile_group_header, - ptr->offset); + transaction_manager.YieldOwnership( + current_txn, src_tile_group_header, ptr->offset); } return false; } - transaction_manager.PerformDelete(current_txn, - *ptr, - new_loc); + transaction_manager.PerformDelete(current_txn, *ptr, new_loc); // For delete cascade, just stop here if (is_update == false) { @@ -716,14 +714,15 @@ bool DataTable::CheckForeignKeySrcAndCascade(storage::Tuple *prev_tuple, } ItemPointer *index_entry_ptr = nullptr; - peloton::ItemPointer location = - src_table->InsertTuple(&src_new_tuple, current_txn, &index_entry_ptr, false); + peloton::ItemPointer location = src_table->InsertTuple( + &src_new_tuple, current_txn, &index_entry_ptr, false); if (location.block == INVALID_OID) { return false; } - transaction_manager.PerformInsert(current_txn, location, index_entry_ptr); + transaction_manager.PerformInsert(current_txn, location, + index_entry_ptr); break; } @@ -755,8 +754,7 @@ bool DataTable::CheckForeignKeySrcAndCascade(storage::Tuple *prev_tuple, * @returns True on success, false if any foreign key constraints fail */ bool DataTable::CheckForeignKeyConstraints( - const AbstractTuple *tuple, - concurrency::TransactionContext *transaction) { + const AbstractTuple *tuple, concurrency::TransactionContext *transaction) { for (auto foreign_key : foreign_keys_) { oid_t sink_table_id = foreign_key->GetSinkTableOid(); storage::DataTable *ref_table = nullptr; @@ -781,7 +779,8 @@ bool DataTable::CheckForeignKeyConstraints( catalog::Schema::CopySchema(ref_table->schema, key_attrs)); std::unique_ptr key( new storage::Tuple(foreign_key_schema.get(), true)); - key->SetFromTuple(tuple, foreign_key->GetSourceColumnIds(), index->GetPool()); + key->SetFromTuple(tuple, foreign_key->GetSourceColumnIds(), + index->GetPool()); LOG_TRACE("check key: %s", key->GetInfo().c_str()); std::vector location_ptrs; @@ -790,8 +789,7 @@ bool DataTable::CheckForeignKeyConstraints( // if this key doesn't exist in the referred column if (location_ptrs.size() == 0) { LOG_DEBUG("The key: %s does not exist in table %s\n", - key->GetInfo().c_str(), - ref_table->GetInfo().c_str()); + key->GetInfo().c_str(), ref_table->GetInfo().c_str()); return false; } @@ -800,17 +798,17 @@ bool DataTable::CheckForeignKeyConstraints( auto tile_group_header = tile_group->GetHeader(); auto &transaction_manager = - concurrency::TransactionManagerFactory::GetInstance(); + concurrency::TransactionManagerFactory::GetInstance(); auto visibility = transaction_manager.IsVisible( - transaction, tile_group_header, location_ptrs[0]->offset, - VisibilityIdType::READ_ID); + transaction, tile_group_header, location_ptrs[0]->offset, + VisibilityIdType::READ_ID); if (visibility != VisibilityType::OK) { - LOG_DEBUG("The key: %s is not yet visible in table %s, visibility " - "type: %s.\n", - key->GetInfo().c_str(), - ref_table->GetInfo().c_str(), - VisibilityTypeToString(visibility).c_str()); + LOG_DEBUG( + "The key: %s is not yet visible in table %s, visibility " + "type: %s.\n", + key->GetInfo().c_str(), ref_table->GetInfo().c_str(), + VisibilityTypeToString(visibility).c_str()); return false; } @@ -1405,16 +1403,19 @@ trigger::TriggerList *DataTable::GetTriggerList() { return trigger_list_.get(); } -void DataTable::UpdateTriggerListFromCatalog(concurrency::TransactionContext *txn) { - trigger_list_ = - catalog::TriggerCatalog::GetInstance().GetTriggers(table_oid, txn); +void DataTable::UpdateTriggerListFromCatalog( + concurrency::TransactionContext *txn) { + trigger_list_ = catalog::Catalog::GetInstance() + .GetSystemCatalogs(database_oid) + .GetTriggerCatalog() + .GetTriggers(table_oid, txn); } hash_t DataTable::Hash() const { auto oid = GetOid(); hash_t hash = HashUtil::Hash(&oid); - hash = HashUtil::CombineHashes(hash, HashUtil::HashBytes(GetName().c_str(), - GetName().length())); + hash = HashUtil::CombineHashes( + hash, HashUtil::HashBytes(GetName().c_str(), GetName().length())); auto db_oid = GetOid(); hash = HashUtil::CombineHashes(hash, HashUtil::Hash(&db_oid)); return hash; @@ -1425,12 +1426,9 @@ bool DataTable::Equals(const storage::DataTable &other) const { } bool DataTable::operator==(const DataTable &rhs) const { - if (GetName() != rhs.GetName()) - return false; - if (GetDatabaseOid() != rhs.GetDatabaseOid()) - return false; - if (GetOid() != rhs.GetOid()) - return false; + if (GetName() != rhs.GetName()) return false; + if (GetDatabaseOid() != rhs.GetDatabaseOid()) return false; + if (GetOid() != rhs.GetOid()) return false; return true; } From ec7e9d2917d465f037fdce45641f8ebddb715efb Mon Sep 17 00:00:00 2001 From: mengranwo Date: Thu, 15 Mar 2018 11:27:56 -0400 Subject: [PATCH 25/48] move trigger_catalog into per database --- src/catalog/catalog.cpp | 49 ++++++++++++++++----------- src/catalog/system_catalogs.cpp | 20 +++++------ src/catalog/trigger_catalog.cpp | 10 +++--- src/executor/create_executor.cpp | 17 +++++----- src/executor/drop_executor.cpp | 9 ++--- src/include/catalog/system_catalogs.h | 4 ++- src/include/catalog/trigger_catalog.h | 3 +- src/storage/data_table.cpp | 18 +++++----- 8 files changed, 68 insertions(+), 62 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 885fb9c2aeb..6283c8adec6 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -12,7 +12,6 @@ #include "catalog/catalog.h" -#include "catalog/system_catalogs.h" #include "catalog/column_catalog.h" #include "catalog/database_catalog.h" #include "catalog/database_metrics_catalog.h" @@ -23,6 +22,7 @@ #include "catalog/query_history_catalog.h" #include "catalog/query_metrics_catalog.h" #include "catalog/settings_catalog.h" +#include "catalog/system_catalogs.h" #include "catalog/table_catalog.h" #include "catalog/table_metrics_catalog.h" #include "catalog/trigger_catalog.h" @@ -92,7 +92,6 @@ void Catalog::BootstrapSystemCatalogs(storage::Database *database, // table and at the same time insert a new index record into pg_index // TODO: This should be hash index rather than tree index?? (but postgres use // btree!!) - CreatePrimaryIndex(database_oid, TABLE_CATALOG_OID, txn); CreateIndex(database_oid, TABLE_CATALOG_OID, @@ -208,11 +207,12 @@ 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 - BootstrapSystemCatalogs(database, txn); pg_database->InsertDatabase(database_oid, database_name, pool_.get(), txn); + // add core & non-core system catalog tables into database + BootstrapSystemCatalogs(database, txn); + catalog_map_[database_oid]->Bootstrap(database_name, txn); LOG_TRACE("Database %s created. Returning RESULT_SUCCESS.", database_name.c_str()); return ResultType::SUCCESS; @@ -513,6 +513,7 @@ ResultType Catalog::DropDatabaseWithOid(oid_t database_oid, throw CatalogException("Database record: " + std::to_string(database_oid) + " does not exist in pg_database"); + catalog_map_.erase(database_oid); // put database object into rw_object_set storage_manager->GetDatabaseWithOid(database_oid); txn->RecordDrop(database_oid, INVALID_OID, INVALID_OID); @@ -1109,8 +1110,9 @@ void Catalog::InitializeFunctions() { txn); AddBuiltinFunction( "sqrt", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::SMALLINT}, type::TypeId::DECIMAL, @@ -1120,18 +1122,21 @@ void Catalog::InitializeFunctions() { txn); AddBuiltinFunction( "sqrt", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "floor", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, @@ -1200,14 +1205,16 @@ void Catalog::InitializeFunctions() { AddBuiltinFunction( "ceil", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Ceil", function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( "ceil", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang, - "Ceil", function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( @@ -1219,14 +1226,16 @@ void Catalog::InitializeFunctions() { AddBuiltinFunction( "ceil", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, internal_lang, - "Ceil", function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( "ceil", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Ceil", function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index f29d3303210..3c7f1195cc1 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -12,11 +12,11 @@ #include "catalog/system_catalogs.h" #include "catalog/column_catalog.h" -#include "catalog/table_catalog.h" #include "catalog/index_catalog.h" -#include "storage/storage_manager.h" -#include "storage/database.h" +#include "catalog/table_catalog.h" #include "storage/data_table.h" +#include "storage/database.h" +#include "storage/storage_manager.h" namespace peloton { namespace catalog { @@ -30,19 +30,19 @@ SystemCatalogs::SystemCatalogs(storage::Database *database, pg_index = new IndexCatalog(database, pool, txn); // TODO: can we move this to BootstrapSystemCatalogs()? - std::vector> shared_tables = { + std::vector> shared_tables = { {CATALOG_DATABASE_OID, DATABASE_CATALOG_OID}, {database_oid, TABLE_CATALOG_OID}, {database_oid, INDEX_CATALOG_OID}}; - for (int i = 0; i < shared_tables.size(); i++) { + for (int i = 0; i < (int)shared_tables.size(); i++) { oid_t column_id = 0; for (auto column : storage::StorageManager::GetInstance() - ->GetTableWithOid(CATALOG_DATABASE_OID, DATABASE_CATALOG_OID) + ->GetTableWithOid(shared_tables[i].first, shared_tables[i].second) ->GetSchema() ->GetColumns()) { - pg_attribute->InsertColumn(DATABASE_CATALOG_OID, column.GetName(), + pg_attribute->InsertColumn(shared_tables[i].second, column.GetName(), column_id, column.GetOffset(), column.GetType(), column.IsInlined(), column.GetConstraints(), pool, txn); @@ -58,9 +58,9 @@ SystemCatalogs::~SystemCatalogs() { if (pg_trigger) delete pg_trigger; } -void SystemCatalogs::Bootstrap(const string &database_name) { - pg_trigger = - new TriggerCatalog(database_name, concurrency::TransactionContext * txn); +void SystemCatalogs::Bootstrap(const std::string &database_name, + concurrency::TransactionContext *txn) { + pg_trigger = new TriggerCatalog(database_name, txn); } } // namespace catalog diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index 0c37b43554a..df14fbfbcef 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -100,20 +100,18 @@ ResultType TriggerCatalog::DropTrigger(const std::string &database_name, // Checking if statement is valid auto table_object = Catalog::GetInstance()->GetTableObject(database_name, table_name, txn); + oid_t trigger_oid = + GetTriggerOid(trigger_name, table_object->GetTableOid(), txn); - oid_t trigger_oid = TriggerCatalog::GetInstance().GetTriggerOid( - trigger_name, table_object->GetTableOid(), txn); if (trigger_oid == INVALID_OID) { LOG_TRACE("Cannot find trigger %s to drop!", trigger_name.c_str()); return ResultType::FAILURE; } - LOG_INFO("trigger %d will be deleted!", trigger_oid); - bool delete_success = DeleteTriggerByName(trigger_name, table_object->GetTableOid(), txn); if (delete_success) { - LOG_DEBUG("Delete trigger successfully"); + LOG_TRACE("Delete trigger successfully"); // ask target table to update its trigger list variable storage::DataTable *target_table = catalog::Catalog::GetInstance()->GetTableWithName(database_name, @@ -121,7 +119,7 @@ ResultType TriggerCatalog::DropTrigger(const std::string &database_name, target_table->UpdateTriggerListFromCatalog(txn); return ResultType::SUCCESS; } - LOG_DEBUG("Failed to delete trigger"); + LOG_TRACE("Failed to delete trigger"); return ResultType::FAILURE; } diff --git a/src/executor/create_executor.cpp b/src/executor/create_executor.cpp index e82e16f79ee..d1df4bc2e77 100644 --- a/src/executor/create_executor.cpp +++ b/src/executor/create_executor.cpp @@ -14,9 +14,7 @@ #include "catalog/catalog.h" #include "catalog/foreign_key.h" -#include "catalog/trigger_catalog.h" -#include "catalog/database_catalog.h" -#include "catalog/table_catalog.h" +#include "catalog/system_catalogs.h" #include "concurrency/transaction_context.h" #include "executor/executor_context.h" #include "planner/create_plan.h" @@ -234,7 +232,8 @@ bool CreateExecutor::CreateTrigger(const planner::CreatePlan &node) { // catalog table auto time_stamp = type::ValueFactory::GetTimestampValue( std::chrono::duration_cast( - std::chrono::system_clock::now().time_since_epoch()).count()); + std::chrono::system_clock::now().time_since_epoch()) + .count()); CopySerializeOutput output; newTrigger.SerializeWhen(output, table_object->GetDatabaseOid(), @@ -243,11 +242,11 @@ bool CreateExecutor::CreateTrigger(const planner::CreatePlan &node) { (const unsigned char *)output.Data(), (int32_t)output.Size(), true); catalog::Catalog::GetInstance() - .GetSystemCatalogs(table_object->database_oid) - .GetTriggerCatalog() - .InsertTrigger(table_object->GetTableOid(), trigger_name, - newTrigger.GetTriggerType(), newTrigger.GetFuncname(), - newTrigger.GetArgs(), when, time_stamp, pool_.get(), txn); + ->GetSystemCatalogs(table_object->GetDatabaseOid()) + ->GetTriggerCatalog() + ->InsertTrigger(table_object->GetTableOid(), trigger_name, + newTrigger.GetTriggerType(), newTrigger.GetFuncname(), + newTrigger.GetArgs(), when, time_stamp, pool_.get(), txn); // ask target table to update its trigger list variable storage::DataTable *target_table = catalog::Catalog::GetInstance()->GetTableWithName(database_name, diff --git a/src/executor/drop_executor.cpp b/src/executor/drop_executor.cpp index 30182da8002..e41d8800541 100644 --- a/src/executor/drop_executor.cpp +++ b/src/executor/drop_executor.cpp @@ -13,11 +13,8 @@ #include "executor/drop_executor.h" #include "catalog/catalog.h" -#include "catalog/database_catalog.h" #include "catalog/index_catalog.h" #include "catalog/system_catalogs.h" -#include "catalog/table_catalog.h" -#include "catalog/trigger_catalog.h" #include "common/logger.h" #include "common/statement_cache_manager.h" #include "executor/executor_context.h" @@ -160,9 +157,9 @@ bool DropExecutor::DropTrigger(const planner::DropPlan &node, ResultType result = catalog::Catalog::GetInstance() - .GetSystemCatalogs(table_object->database_oid) - .GetTriggerCatalog() - .DropTrigger(database_name, table_name, trigger_name, txn); + ->GetSystemCatalogs(table_object->GetDatabaseOid()) + ->GetTriggerCatalog() + ->DropTrigger(database_name, table_name, trigger_name, txn); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { LOG_DEBUG("Dropping trigger succeeded!"); diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h index 81cd9924467..68c2c331bce 100644 --- a/src/include/catalog/system_catalogs.h +++ b/src/include/catalog/system_catalogs.h @@ -16,6 +16,7 @@ #include "catalog/database_catalog.h" #include "catalog/table_catalog.h" +#include "catalog/trigger_catalog.h" namespace peloton { @@ -39,7 +40,8 @@ class SystemCatalogs { ~SystemCatalogs(); - void Bootstrap(); + void Bootstrap(const std::string &database_name, + concurrency::TransactionContext *txn); ColumnCatalog *GetColumnCatalog() { return pg_attribute; } TableCatalog *GetTableCatalog() { return pg_table; } diff --git a/src/include/catalog/trigger_catalog.h b/src/include/catalog/trigger_catalog.h index 967c05124ad..8dda72afd67 100644 --- a/src/include/catalog/trigger_catalog.h +++ b/src/include/catalog/trigger_catalog.h @@ -47,7 +47,8 @@ namespace catalog { class TriggerCatalog : public AbstractCatalog { public: - TriggerCatalog(concurrency::TransactionContext *txn); + TriggerCatalog(const std::string &database_name, + concurrency::TransactionContext *txn); ~TriggerCatalog(); //===--------------------------------------------------------------------===// diff --git a/src/storage/data_table.cpp b/src/storage/data_table.cpp index 0779b0853d2..1f3d9195038 100644 --- a/src/storage/data_table.cpp +++ b/src/storage/data_table.cpp @@ -13,11 +13,9 @@ #include #include -#include "tuning/clusterer.h" -#include "tuning/sample.h" +#include "catalog/catalog.h" #include "catalog/foreign_key.h" -#include "catalog/table_catalog.h" -#include "catalog/trigger_catalog.h" +#include "catalog/system_catalogs.h" #include "common/container_tuple.h" #include "common/exception.h" #include "common/logger.h" @@ -37,6 +35,8 @@ #include "storage/tile_group_factory.h" #include "storage/tile_group_header.h" #include "storage/tuple.h" +#include "tuning/clusterer.h" +#include "tuning/sample.h" //===--------------------------------------------------------------------===// // Configuration Variables @@ -1406,9 +1406,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(table_oid, txn); } hash_t DataTable::Hash() const { @@ -1432,5 +1432,5 @@ bool DataTable::operator==(const DataTable &rhs) const { return true; } -} // End storage namespace -} // End peloton namespace +} // namespace storage +} // namespace peloton From 00ebf5fa0b29fd25e2c8973674ee0b1592b181d4 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Thu, 15 Mar 2018 12:01:57 -0400 Subject: [PATCH 26/48] can pass trigger test now, also drop trigger when drop table --- src/catalog/catalog.cpp | 12 ++++++++++++ src/catalog/trigger_catalog.cpp | 21 ++++++++++++++++----- src/include/catalog/trigger_catalog.h | 4 ++++ test/executor/create_test.cpp | 15 +++++++++------ 4 files changed, 41 insertions(+), 11 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 6283c8adec6..bf53d22d8b3 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -579,12 +579,24 @@ ResultType Catalog::DropTable(oid_t database_oid, oid_t table_oid, auto index_objects = table_object->GetIndexObjects(); 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); + for (int i = 0; i < trigger_lists->GetTriggerListSize(); i++) + pg_trigger->DropTrigger(database_oid, table_oid, + trigger_lists->Get(i)->GetTriggerName(), txn); + + // delete index and records pg_index for (auto it : index_objects) DropIndex(database_oid, it.second->GetIndexOid(), txn); + // delete record in pg_attribute auto pg_attribute = catalog_map_[database_object->GetDatabaseOid()]->GetColumnCatalog(); pg_attribute->DeleteColumns(table_oid, txn); + // delete record in pg_table auto pg_table = catalog_map_[database_object->GetDatabaseOid()]->GetTableCatalog(); diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index df14fbfbcef..7b5dd654d6d 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -16,6 +16,7 @@ #include "catalog/database_catalog.h" #include "catalog/table_catalog.h" #include "storage/data_table.h" +#include "storage/storage_manager.h" #include "type/value_factory.h" namespace peloton { @@ -100,22 +101,32 @@ ResultType TriggerCatalog::DropTrigger(const std::string &database_name, // Checking if statement is valid auto table_object = Catalog::GetInstance()->GetTableObject(database_name, table_name, txn); + if (table_object == nullptr) + throw CatalogException("Drop Trigger: table " + table_name + + " does not exist"); + oid_t trigger_oid = GetTriggerOid(trigger_name, table_object->GetTableOid(), txn); - if (trigger_oid == INVALID_OID) { LOG_TRACE("Cannot find trigger %s to drop!", trigger_name.c_str()); return ResultType::FAILURE; } - bool delete_success = - DeleteTriggerByName(trigger_name, table_object->GetTableOid(), txn); + return DropTrigger(table_object->GetDatabaseOid(), + table_object->GetTableOid(), trigger_name, txn); +} + +ResultType TriggerCatalog::DropTrigger(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); if (delete_success) { LOG_TRACE("Delete trigger successfully"); // ask target table to update its trigger list variable storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName(database_name, - table_name, txn); + storage::StorageManager::GetInstance()->GetTableWithOid(database_oid, + table_oid); target_table->UpdateTriggerListFromCatalog(txn); return ResultType::SUCCESS; } diff --git a/src/include/catalog/trigger_catalog.h b/src/include/catalog/trigger_catalog.h index 8dda72afd67..20038aa441b 100644 --- a/src/include/catalog/trigger_catalog.h +++ b/src/include/catalog/trigger_catalog.h @@ -65,6 +65,10 @@ class TriggerCatalog : public AbstractCatalog { const std::string &trigger_name, concurrency::TransactionContext *txn); + ResultType DropTrigger(const oid_t oid_tdatabase_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); diff --git a/test/executor/create_test.cpp b/test/executor/create_test.cpp index 82460e7cf47..12d0d62269d 100644 --- a/test/executor/create_test.cpp +++ b/test/executor/create_test.cpp @@ -13,10 +13,8 @@ #include #include "catalog/catalog.h" -#include "catalog/database_catalog.h" #include "catalog/proc_catalog.h" -#include "catalog/table_catalog.h" -#include "catalog/trigger_catalog.h" +#include "catalog/system_catalogs.h" #include "common/harness.h" #include "concurrency/transaction_manager_factory.h" #include "executor/create_executor.h" @@ -526,9 +524,14 @@ TEST_F(CreateTests, CreatingTriggerInCatalog) { // check whether the trigger catalog table contains this new trigger auto table_object = catalog::Catalog::GetInstance()->GetTableObject( DEFAULT_DB_NAME, "accounts", txn); - auto trigger_list = catalog::TriggerCatalog::GetInstance().GetTriggersByType( - table_object->GetTableOid(), - (TRIGGER_TYPE_ROW | TRIGGER_TYPE_BEFORE | TRIGGER_TYPE_UPDATE), txn); + 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); txn_manager.CommitTransaction(txn); From 69b1be33f305f262b3720b61f60f656e9a933d57 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Sat, 17 Mar 2018 17:24:28 -0400 Subject: [PATCH 27/48] fix udf test, bootstrap only once --- test/sql/drop_sql_test.cpp | 11 ++++------- test/udf/udf_test.cpp | 5 ++--- 2 files changed, 6 insertions(+), 10 deletions(-) diff --git a/test/sql/drop_sql_test.cpp b/test/sql/drop_sql_test.cpp index fbb10a7cbb2..418634f8f73 100644 --- a/test/sql/drop_sql_test.cpp +++ b/test/sql/drop_sql_test.cpp @@ -94,19 +94,18 @@ TEST_F(DropSQLTests, DropIndexTest) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + auto database_object = + catalog::Catalog::GetInstance()->GetDatabaseObject(DEFAULT_DB_NAME, txn); + EXPECT_NE(nullptr, database_object); txn_manager.CommitTransaction(txn); // Create a table first TestingSQLUtil::ExecuteSQLQuery( "CREATE TABLE test(a INT PRIMARY KEY, b INT);"); - // Create a Index TestingSQLUtil::ExecuteSQLQuery("CREATE INDEX idx ON test(a);"); - // retrieve pg_index catalog table - auto database_object = - catalog::Catalog::GetInstance()->GetDatabaseObject(DEFAULT_DB_NAME, txn); - EXPECT_NE(nullptr, database_object); + // retrieve pg_index catalog table auto pg_index = catalog::Catalog::GetInstance() ->GetSystemCatalogs(database_object->GetDatabaseOid()) ->GetIndexCatalog(); @@ -130,11 +129,9 @@ TEST_F(DropSQLTests, DropIndexTest) { // Check if index is not in catalog txn = txn_manager.BeginTransaction(); index = pg_index->GetIndexObject("idx", txn); - txn_manager.CommitTransaction(txn); EXPECT_EQ(index, nullptr); // Free the database just created - txn = txn_manager.BeginTransaction(); catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); txn_manager.CommitTransaction(txn); } diff --git a/test/udf/udf_test.cpp b/test/udf/udf_test.cpp index a5d3452a791..f4eee947f76 100644 --- a/test/udf/udf_test.cpp +++ b/test/udf/udf_test.cpp @@ -80,7 +80,6 @@ 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()->Bootstrap(); txn_manager.CommitTransaction(txn); // Create a txn txn = txn_manager.BeginTransaction(); @@ -137,7 +136,7 @@ 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()->Bootstrap(); + // catalog::Catalog::GetInstance()->Bootstrap(); txn_manager.CommitTransaction(txn); // Create a txn txn = txn_manager.BeginTransaction(); @@ -196,7 +195,7 @@ 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()->Bootstrap(); + // catalog::Catalog::GetInstance()->Bootstrap(); txn_manager.CommitTransaction(txn); // Create a txn txn = txn_manager.BeginTransaction(); From ea6f79f876232943ff79a17fbb180d72d461028b Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sat, 17 Mar 2018 17:24:55 -0400 Subject: [PATCH 28/48] fix db names --- test/binder/binder_test.cpp | 6 +-- test/catalog/catalog_test.cpp | 46 +++++++++---------- test/executor/create_test.cpp | 22 ++++----- test/gc/garbage_collection_test.cpp | 8 ++-- test/gc/transaction_level_gc_manager_test.cpp | 10 ++-- test/include/codegen/testing_codegen_util.h | 2 +- test/statistics/testing_stats_util.cpp | 6 +-- 7 files changed, 49 insertions(+), 51 deletions(-) diff --git a/test/binder/binder_test.cpp b/test/binder/binder_test.cpp index 3cf7510c4bd..2d94728f743 100644 --- a/test/binder/binder_test.cpp +++ b/test/binder/binder_test.cpp @@ -102,7 +102,7 @@ void SetupTables(std::string database_name) { } TEST_F(BinderCorrectnessTest, SelectStatementTest) { - std::string default_database_name = "TEST_DB"; + std::string default_database_name = "test_db"; SetupTables(default_database_name); auto &parser = parser::PostgresParser::GetInstance(); catalog::Catalog *catalog_ptr = catalog::Catalog::GetInstance(); @@ -246,7 +246,7 @@ TEST_F(BinderCorrectnessTest, SelectStatementTest) { // test after UpdateStatement is changed TEST_F(BinderCorrectnessTest, DeleteStatementTest) { - std::string default_database_name = "TEST_DB"; + std::string default_database_name = "test_db"; SetupTables(default_database_name); auto &parser = parser::PostgresParser::GetInstance(); catalog::Catalog *catalog_ptr = catalog::Catalog::GetInstance(); @@ -286,7 +286,7 @@ TEST_F(BinderCorrectnessTest, DeleteStatementTest) { } TEST_F(BinderCorrectnessTest, BindDepthTest) { - std::string default_database_name = "TEST_DB"; + std::string default_database_name = "test_db"; SetupTables(default_database_name); auto &parser = parser::PostgresParser::GetInstance(); diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index 7edbbf90a96..24fc22afd6b 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -52,14 +52,14 @@ 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("emp_db", txn); auto table_object = catalog::Catalog::GetInstance()->GetTableObject( CATALOG_DATABASE_NAME, INDEX_CATALOG_NAME, txn); auto index_object = table_object->GetIndexObject(INDEX_CATALOG_PKEY_OID); std::vector key_attrs = index_object->GetKeyAttrs(); - EXPECT_EQ("EMP_DB", catalog::Catalog::GetInstance() - ->GetDatabaseWithName("EMP_DB", txn) + EXPECT_EQ("emp_db", catalog::Catalog::GetInstance() + ->GetDatabaseWithName("emp_db", txn) ->GetDBName()); txn_manager.CommitTransaction(txn); EXPECT_EQ(1, key_attrs.size()); @@ -83,11 +83,11 @@ TEST_F(CatalogTests, CreatingTable) { std::unique_ptr table_schema_3( new catalog::Schema({id_column, name_column})); - catalog::Catalog::GetInstance()->CreateTable("EMP_DB", "emp_table", + catalog::Catalog::GetInstance()->CreateTable("emp_db", "emp_table", std::move(table_schema), txn); - catalog::Catalog::GetInstance()->CreateTable("EMP_DB", "department_table", + catalog::Catalog::GetInstance()->CreateTable("emp_db", "department_table", std::move(table_schema_2), txn); - catalog::Catalog::GetInstance()->CreateTable("EMP_DB", "salary_table", + catalog::Catalog::GetInstance()->CreateTable("emp_db", "salary_table", std::move(table_schema_3), txn); // insert random tuple into DATABASE_METRICS_CATALOG and check std::unique_ptr pool(new type::EphemeralPool()); @@ -110,7 +110,7 @@ TEST_F(CatalogTests, CreatingTable) { EXPECT_EQ('a', *param1.buf); EXPECT_EQ("name", catalog::Catalog::GetInstance() - ->GetDatabaseWithName("EMP_DB", txn) + ->GetDatabaseWithName("emp_db", txn) ->GetTableWithName("department_table") ->GetSchema() ->GetColumn(1) @@ -132,7 +132,7 @@ TEST_F(CatalogTests, CreatingTable) { // ->GetTableWithName("pg_attribute") // ->GetTupleCount(), // 57); - // // pg_catalog + EMP_DB + // // pg_catalog + emp_db // EXPECT_EQ(catalog::Catalog::GetInstance() // ->GetDatabaseWithName("pg_catalog") // ->GetTableWithName("pg_database") @@ -157,7 +157,7 @@ TEST_F(CatalogTests, TableObject) { auto txn = txn_manager.BeginTransaction(); auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - "EMP_DB", "department_table", txn); + "emp_db", "department_table", txn); auto index_objects = table_object->GetIndexObjects(); auto column_objects = table_object->GetColumnObjects(); @@ -191,7 +191,7 @@ TEST_F(CatalogTests, TableObject) { bool update_result = pg_table->UpdateVersionId(1, department_table_oid, txn); // get version id after update, invalidate old cache table_object = catalog::Catalog::GetInstance()->GetTableObject( - "EMP_DB", "department_table", txn); + "emp_db", "department_table", txn); uint32_t version_oid = table_object->GetVersionId(); EXPECT_NE(department_table_oid, INVALID_OID); EXPECT_EQ(update_result, true); @@ -207,20 +207,20 @@ TEST_F(CatalogTests, DroppingTable) { // everytime we create a database, there will be 3 catalog tables inside EXPECT_EQ( 6, - (int)catalog->GetDatabaseObject("EMP_DB", txn)->GetTableObjects().size()); + (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); auto database_object = - catalog::Catalog::GetInstance()->GetDatabaseObject("EMP_DB", txn); + catalog::Catalog::GetInstance()->GetDatabaseObject("emp_db", txn); EXPECT_NE(nullptr, database_object); - catalog::Catalog::GetInstance()->DropTable("EMP_DB", "department_table", txn); + catalog::Catalog::GetInstance()->DropTable("emp_db", "department_table", txn); database_object = - catalog::Catalog::GetInstance()->GetDatabaseObject("EMP_DB", txn); + catalog::Catalog::GetInstance()->GetDatabaseObject("emp_db", txn); EXPECT_NE(nullptr, database_object); auto department_table_object = database_object->GetTableObject("department_table"); EXPECT_EQ( 5, - (int)catalog->GetDatabaseObject("EMP_DB", txn)->GetTableObjects().size()); + (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); EXPECT_EQ(nullptr, department_table_object); @@ -228,40 +228,40 @@ TEST_F(CatalogTests, DroppingTable) { // Try to drop again txn = txn_manager.BeginTransaction(); EXPECT_THROW(catalog::Catalog::GetInstance()->DropTable( - "EMP_DB", "department_table", txn), + "emp_db", "department_table", txn), CatalogException); EXPECT_EQ( 5, - (int)catalog->GetDatabaseObject("EMP_DB", txn)->GetTableObjects().size()); + (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); // Drop a table that does not exist txn = txn_manager.BeginTransaction(); EXPECT_THROW( - catalog::Catalog::GetInstance()->DropTable("EMP_DB", "void_table", txn), + catalog::Catalog::GetInstance()->DropTable("emp_db", "void_table", txn), CatalogException); EXPECT_EQ( 5, - (int)catalog->GetDatabaseObject("EMP_DB", txn)->GetTableObjects().size()); + (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); // Drop the other table txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropTable("EMP_DB", "emp_table", txn); + catalog::Catalog::GetInstance()->DropTable("emp_db", "emp_table", txn); EXPECT_EQ( 4, - (int)catalog->GetDatabaseObject("EMP_DB", txn)->GetTableObjects().size()); + (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().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("emp_db", txn); EXPECT_THROW( - catalog::Catalog::GetInstance()->GetDatabaseWithName("EMP_DB", txn), + catalog::Catalog::GetInstance()->GetDatabaseWithName("emp_db", txn), CatalogException); txn_manager.CommitTransaction(txn); } diff --git a/test/executor/create_test.cpp b/test/executor/create_test.cpp index 12d0d62269d..b79281b8434 100644 --- a/test/executor/create_test.cpp +++ b/test/executor/create_test.cpp @@ -47,7 +47,7 @@ TEST_F(CreateTests, CreatingDB) { auto txn = txn_manager.BeginTransaction(); // Create plans with database name set. - planner::CreatePlan node("PelotonDB", CreateType::DB); + planner::CreatePlan node("pelotondb", CreateType::DB); std::unique_ptr context( new executor::ExecutorContext(txn)); @@ -58,9 +58,9 @@ TEST_F(CreateTests, CreatingDB) { executor.Execute(); // Check if the database exists in the same txn EXPECT_EQ(0, catalog::Catalog::GetInstance() - ->GetDatabaseObject("PelotonDB", txn) + ->GetDatabaseObject("pelotondb", txn) ->GetDatabaseName() - .compare("PelotonDB")); + .compare("pelotondb")); txn_manager.CommitTransaction(txn); @@ -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) + ->GetDatabaseObject("pelotondb", txn) ->GetDatabaseName() - .compare("PelotonDB")); + .compare("pelotondb")); // free the database just created - catalog::Catalog::GetInstance()->DropDatabaseWithName("PelotonDB", txn); + catalog::Catalog::GetInstance()->DropDatabaseWithName("pelotondb", txn); txn_manager.CommitTransaction(txn); } @@ -314,15 +314,13 @@ TEST_F(CreateTests, CreatingTrigger) { EXPECT_EQ(ExpressionType::VALUE_TUPLE, left->GetExpressionType()); EXPECT_EQ("old", static_cast(left) ->GetTableName()); - EXPECT_EQ("balance", - static_cast(left) - ->GetColumnName()); + EXPECT_EQ("balance", static_cast( + left)->GetColumnName()); EXPECT_EQ(ExpressionType::VALUE_TUPLE, right->GetExpressionType()); EXPECT_EQ("new", static_cast(right) ->GetTableName()); - EXPECT_EQ("balance", - static_cast(right) - ->GetColumnName()); + EXPECT_EQ("balance", static_cast( + right)->GetColumnName()); // type (level, timing, event) auto trigger_type = plan.GetTriggerType(); // level diff --git a/test/gc/garbage_collection_test.cpp b/test/gc/garbage_collection_test.cpp index 514a9b00b94..d3b24b878fc 100644 --- a/test/gc/garbage_collection_test.cpp +++ b/test/gc/garbage_collection_test.cpp @@ -125,7 +125,7 @@ TEST_F(GarbageCollectionTests, UpdateTest) { auto storage_manager = storage::StorageManager::GetInstance(); // create database - auto database = TestingExecutorUtil::InitializeDatabase("UPDATE_DB"); + auto database = TestingExecutorUtil::InitializeDatabase("update_db"); oid_t db_id = database->GetOid(); EXPECT_TRUE(storage_manager->HasDatabase(db_id)); @@ -197,7 +197,7 @@ TEST_F(GarbageCollectionTests, UpdateTest) { table.release(); // DROP! - TestingExecutorUtil::DeleteDatabase("UPDATE_DB"); + TestingExecutorUtil::DeleteDatabase("update_db"); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); EXPECT_THROW(catalog::Catalog::GetInstance()->GetDatabaseObject(db_id, txn), @@ -219,7 +219,7 @@ TEST_F(GarbageCollectionTests, DeleteTest) { auto &gc_manager = gc::GCManagerFactory::GetInstance(); auto storage_manager = storage::StorageManager::GetInstance(); // create database - auto database = TestingExecutorUtil::InitializeDatabase("DELETE_DB"); + auto database = TestingExecutorUtil::InitializeDatabase("delete_db"); oid_t db_id = database->GetOid(); EXPECT_TRUE(storage_manager->HasDatabase(db_id)); // create a table with only one key @@ -295,7 +295,7 @@ TEST_F(GarbageCollectionTests, DeleteTest) { table.release(); // DROP! - TestingExecutorUtil::DeleteDatabase("DELETE_DB"); + TestingExecutorUtil::DeleteDatabase("delete_db"); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); EXPECT_THROW( diff --git a/test/gc/transaction_level_gc_manager_test.cpp b/test/gc/transaction_level_gc_manager_test.cpp index ef7ce6d60b7..97481fd3c11 100644 --- a/test/gc/transaction_level_gc_manager_test.cpp +++ b/test/gc/transaction_level_gc_manager_test.cpp @@ -224,7 +224,7 @@ TEST_F(TransactionLevelGCManagerTests, ReInsertTest) { auto storage_manager = storage::StorageManager::GetInstance(); // create database - auto database = TestingExecutorUtil::InitializeDatabase("DATABASE1"); + auto database = TestingExecutorUtil::InitializeDatabase("database1"); oid_t db_id = database->GetOid(); EXPECT_TRUE(storage_manager->HasDatabase(db_id)); @@ -363,7 +363,7 @@ TEST_F(TransactionLevelGCManagerTests, ReInsertTest) { table.release(); // DROP! - TestingExecutorUtil::DeleteDatabase("DATABASE1"); + TestingExecutorUtil::DeleteDatabase("database1"); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); @@ -393,7 +393,7 @@ TEST_F(TransactionLevelGCManagerTests, ImmutabilityTest) { auto storage_manager = storage::StorageManager::GetInstance(); // create database - auto database = TestingExecutorUtil::InitializeDatabase("ImmutabilityDB"); + auto database = TestingExecutorUtil::InitializeDatabase("immutabilitydb"); oid_t db_id = database->GetOid(); EXPECT_TRUE(storage_manager->HasDatabase(db_id)); @@ -476,12 +476,12 @@ TEST_F(TransactionLevelGCManagerTests, ImmutabilityTest) { table.release(); // DROP! - TestingExecutorUtil::DeleteDatabase("ImmutabilityDB"); + TestingExecutorUtil::DeleteDatabase("immutabilitydb"); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); EXPECT_THROW( - catalog::Catalog::GetInstance()->GetDatabaseObject("ImmutabilityDB", txn), + catalog::Catalog::GetInstance()->GetDatabaseObject("immutabilitydb", txn), CatalogException); txn_manager.CommitTransaction(txn); } diff --git a/test/include/codegen/testing_codegen_util.h b/test/include/codegen/testing_codegen_util.h index c4f3943db66..7e5cd3ee20f 100644 --- a/test/include/codegen/testing_codegen_util.h +++ b/test/include/codegen/testing_codegen_util.h @@ -47,7 +47,7 @@ using ConstPlanPtr = std::unique_ptr; //===----------------------------------------------------------------------===// class PelotonCodeGenTest : public PelotonTest { public: - std::string test_db_name = "PELOTON_CODEGEN"; + std::string test_db_name = "peloton_codegen"; std::vector test_table_names = {"table1", "table2", "table3", "table4", "table5"}; std::vector test_table_oids; diff --git a/test/statistics/testing_stats_util.cpp b/test/statistics/testing_stats_util.cpp index fc7856a0a3f..6fbdb23c866 100644 --- a/test/statistics/testing_stats_util.cpp +++ b/test/statistics/testing_stats_util.cpp @@ -137,7 +137,7 @@ std::shared_ptr TestingStatsUtil::GetInsertStmt(int id, std::string val) { std::shared_ptr statement; std::string sql = - "INSERT INTO EMP_DB.department_table(dept_id,dept_name) VALUES " + "INSERT INTO emp_db.department_table(dept_id,dept_name) VALUES " "(" + std::to_string(id) + ",'" + val + "');"; LOG_TRACE("Query: %s", sql.c_str()); @@ -148,7 +148,7 @@ std::shared_ptr TestingStatsUtil::GetInsertStmt(int id, std::shared_ptr TestingStatsUtil::GetDeleteStmt() { std::shared_ptr statement; - std::string sql = "DELETE FROM EMP_DB.department_table"; + std::string sql = "DELETE FROM emp_db.department_table"; LOG_INFO("Query: %s", sql.c_str()); statement.reset(new Statement("DELETE", sql)); ParseAndPlan(statement.get(), sql); @@ -158,7 +158,7 @@ std::shared_ptr TestingStatsUtil::GetDeleteStmt() { std::shared_ptr TestingStatsUtil::GetUpdateStmt() { std::shared_ptr statement; std::string sql = - "UPDATE EMP_DB.department_table SET dept_name = 'CS' WHERE dept_id = 1"; + "UPDATE emp_db.department_table SET dept_name = 'CS' WHERE dept_id = 1"; LOG_INFO("Query: %s", sql.c_str()); statement.reset(new Statement("UPDATE", sql)); ParseAndPlan(statement.get(), sql); From f9bac0ceb5965dd7fedb2e214df37cc46ac6c8d4 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sat, 17 Mar 2018 17:57:14 -0400 Subject: [PATCH 29/48] initialize nullptr --- src/catalog/system_catalogs.cpp | 3 ++- test/gc/transaction_level_gc_manager_test.cpp | 8 ++++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index 3c7f1195cc1..54fc82736f4 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -23,7 +23,8 @@ namespace catalog { SystemCatalogs::SystemCatalogs(storage::Database *database, type::AbstractPool *pool, - concurrency::TransactionContext *txn) { + concurrency::TransactionContext *txn) + : pg_trigger(nullptr) { oid_t database_oid = database->GetOid(); pg_attribute = new ColumnCatalog(database, pool, txn); pg_table = new TableCatalog(database, pool, txn); diff --git a/test/gc/transaction_level_gc_manager_test.cpp b/test/gc/transaction_level_gc_manager_test.cpp index 97481fd3c11..cef62e0cf73 100644 --- a/test/gc/transaction_level_gc_manager_test.cpp +++ b/test/gc/transaction_level_gc_manager_test.cpp @@ -93,7 +93,7 @@ TEST_F(TransactionLevelGCManagerTests, UpdateDeleteTest) { auto &gc_manager = gc::TransactionLevelGCManager::GetInstance(); auto storage_manager = storage::StorageManager::GetInstance(); // create database - auto database = TestingExecutorUtil::InitializeDatabase("DATABASE0"); + auto database = TestingExecutorUtil::InitializeDatabase("database0"); oid_t db_id = database->GetOid(); EXPECT_TRUE(storage_manager->HasDatabase(db_id)); @@ -200,12 +200,12 @@ TEST_F(TransactionLevelGCManagerTests, UpdateDeleteTest) { table.release(); // DROP! - TestingExecutorUtil::DeleteDatabase("DATABASE0"); + TestingExecutorUtil::DeleteDatabase("database0"); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); EXPECT_THROW( - catalog::Catalog::GetInstance()->GetDatabaseObject("DATABASE0", txn), + catalog::Catalog::GetInstance()->GetDatabaseObject("database0", txn), 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()->GetDatabaseObject("database0", txn), CatalogException); txn_manager.CommitTransaction(txn); // EXPECT_FALSE(storage_manager->HasDatabase(db_id)); From 2eb87de66a33eb34983f6fbf69b742aa4393f68f Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Thu, 22 Mar 2018 10:53:40 -0400 Subject: [PATCH 30/48] TODO: fix GetInstance, fix AddBuiltInFunctions --- src/catalog/catalog.cpp | 44 +++++--------- src/catalog/database_metrics_catalog.cpp | 8 ++- src/catalog/index_metrics_catalog.cpp | 33 +++++----- src/catalog/proc_catalog.cpp | 32 +++++----- src/catalog/query_metrics_catalog.cpp | 67 +++++++++------------ src/catalog/system_catalogs.cpp | 8 +++ src/catalog/table_metrics_catalog.cpp | 33 +++++----- src/include/catalog/index_metrics_catalog.h | 11 ++-- src/include/catalog/proc_catalog.h | 10 ++- src/include/catalog/query_metrics_catalog.h | 10 +-- src/include/catalog/system_catalogs.h | 5 ++ src/include/catalog/table_metrics_catalog.h | 11 ++-- 12 files changed, 118 insertions(+), 154 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index bf53d22d8b3..68a390a4aef 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -159,12 +159,8 @@ void Catalog::Bootstrap() { auto txn = txn_manager.BeginTransaction(); DatabaseMetricsCatalog::GetInstance(txn); - TableMetricsCatalog::GetInstance(txn); - IndexMetricsCatalog::GetInstance(txn); - QueryMetricsCatalog::GetInstance(txn); SettingsCatalog::GetInstance(txn); LanguageCatalog::GetInstance(txn); - ProcCatalog::GetInstance(txn); if (settings::SettingsManager::GetBool(settings::SettingId::brain)) { QueryHistoryCatalog::GetInstance(txn); @@ -1122,9 +1118,8 @@ void Catalog::InitializeFunctions() { txn); AddBuiltinFunction( "sqrt", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::SMALLINT}, type::TypeId::DECIMAL, @@ -1134,21 +1129,18 @@ void Catalog::InitializeFunctions() { txn); AddBuiltinFunction( "sqrt", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", - function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "floor", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, @@ -1217,16 +1209,14 @@ void Catalog::InitializeFunctions() { AddBuiltinFunction( "ceil", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( "ceil", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang, - "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( @@ -1238,16 +1228,14 @@ void Catalog::InitializeFunctions() { AddBuiltinFunction( "ceil", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, internal_lang, - "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( "ceil", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Ceil", - function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( diff --git a/src/catalog/database_metrics_catalog.cpp b/src/catalog/database_metrics_catalog.cpp index ff670639764..bc68e62417b 100644 --- a/src/catalog/database_metrics_catalog.cpp +++ b/src/catalog/database_metrics_catalog.cpp @@ -25,11 +25,12 @@ DatabaseMetricsCatalog *DatabaseMetricsCatalog::GetInstance( return &database_metrics_catalog; } -DatabaseMetricsCatalog::DatabaseMetricsCatalog(concurrency::TransactionContext *txn) +DatabaseMetricsCatalog::DatabaseMetricsCatalog( + concurrency::TransactionContext *txn) : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME "." DATABASE_METRICS_CATALOG_NAME " (" - "database_oid INT NOT NULL, " + "database_oid INT NOT NULL PRIMARY KEY, " "txn_committed INT NOT NULL, " "txn_aborted INT NOT NULL, " "time_stamp INT NOT NULL);", @@ -41,7 +42,8 @@ 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) { + oid_t time_stamp, type::AbstractPool *pool, + concurrency::TransactionContext *txn) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); diff --git a/src/catalog/index_metrics_catalog.cpp b/src/catalog/index_metrics_catalog.cpp index 3ca114e8c98..b4e07dbea15 100644 --- a/src/catalog/index_metrics_catalog.cpp +++ b/src/catalog/index_metrics_catalog.cpp @@ -19,23 +19,18 @@ namespace peloton { namespace catalog { -IndexMetricsCatalog *IndexMetricsCatalog::GetInstance( - concurrency::TransactionContext *txn) { - static IndexMetricsCatalog index_metrics_catalog{txn}; - return &index_metrics_catalog; -} - -IndexMetricsCatalog::IndexMetricsCatalog(concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." INDEX_METRICS_CATALOG_NAME - " (" - "database_oid INT NOT NULL, " - "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);", +IndexMetricsCatalog::IndexMetricsCatalog(const std::string &database_name, + concurrency::TransactionContext *txn) + : AbstractCatalog("CREATE TABLE " + database_name + + "." INDEX_METRICS_CATALOG_NAME + " (" + "database_oid INT NOT NULL, " + "table_oid INT NOT NULL, " + "index_oid INT NOT NULL PRIMARY_KEY, " + "reads INT NOT NULL, " + "deletes INT NOT NULL, " + "inserts INT NOT NULL, " + "time_stamp INT NOT NULL);", txn) { // Add secondary index here if necessary } @@ -69,8 +64,8 @@ bool IndexMetricsCatalog::InsertIndexMetrics( return InsertTuple(std::move(tuple), txn); } -bool IndexMetricsCatalog::DeleteIndexMetrics(oid_t index_oid, - concurrency::TransactionContext *txn) { +bool IndexMetricsCatalog::DeleteIndexMetrics( + oid_t index_oid, concurrency::TransactionContext *txn) { oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index std::vector values; diff --git a/src/catalog/proc_catalog.cpp b/src/catalog/proc_catalog.cpp index 217c8b7fedb..095a658bf51 100644 --- a/src/catalog/proc_catalog.cpp +++ b/src/catalog/proc_catalog.cpp @@ -37,26 +37,22 @@ std::unique_ptr ProcCatalogObject::GetLanguage() const { return LanguageCatalog::GetInstance().GetLanguageByOid(GetLangOid(), txn_); } -ProcCatalog &ProcCatalog::GetInstance(concurrency::TransactionContext *txn) { - static ProcCatalog proc_catalog{txn}; - return proc_catalog; -} - ProcCatalog::~ProcCatalog(){}; -ProcCatalog::ProcCatalog(concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_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);", +ProcCatalog::ProcCatalog(const std::string &database_name, + concurrency::TransactionContext *txn) + : AbstractCatalog("CREATE TABLE " + database_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, PROC_CATALOG_NAME, - {1, 3}, PROC_CATALOG_NAME "_skey0", false, + Catalog::GetInstance()->CreateIndex(database_name, PROC_CATALOG_NAME, {1, 3}, + PROC_CATALOG_NAME "_skey0", false, IndexType::BWTREE, txn); } @@ -118,7 +114,7 @@ std::unique_ptr ProcCatalog::GetProcByName( std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(proc_name).Copy()); values.push_back(type::ValueFactory::GetVarcharValue( - TypeIdArrayToString(proc_arg_types)).Copy()); + TypeIdArrayToString(proc_arg_types)).Copy()); auto result_tiles = GetResultWithIndexScan(column_ids, index_offset, values, txn); diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 0f3f98320df..08d80014478 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -20,34 +20,26 @@ namespace peloton { namespace catalog { -QueryMetricsCatalog *QueryMetricsCatalog::GetInstance( - concurrency::TransactionContext *txn) { - static QueryMetricsCatalog query_metrics_catalog{txn}; - return &query_metrics_catalog; -} - -QueryMetricsCatalog::QueryMetricsCatalog(concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." QUERY_METRICS_CATALOG_NAME - " (" - "query_name VARCHAR NOT NULL, " - "database_oid INT NOT NULL, " - "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);", +QueryMetricsCatalog::QueryMetricsCatalog(const std::string &database_name, + concurrency::TransactionContext *txn) + : AbstractCatalog("CREATE TABLE " + database_name + + "." QUERY_METRICS_CATALOG_NAME + " (" + "query_name VARCHAR NOT NULL PRIMARY KEY, " + "database_oid INT NOT NULL , " + "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) { // Add secondary index here if necessary - Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, QUERY_METRICS_CATALOG_NAME, {0, 1}, - QUERY_METRICS_CATALOG_NAME "_skey0", false, IndexType::BWTREE, txn); } QueryMetricsCatalog::~QueryMetricsCatalog() {} @@ -64,7 +56,6 @@ bool QueryMetricsCatalog::InsertQueryMetrics( new storage::Tuple(catalog_table_->GetSchema(), true)); auto val0 = type::ValueFactory::GetVarcharValue(name, pool); - auto val1 = type::ValueFactory::GetIntegerValue(database_oid); auto val2 = type::ValueFactory::GetIntegerValue(num_params); auto val3 = type::ValueFactory::GetNullValueByType(type::TypeId::VARBINARY); @@ -89,7 +80,6 @@ bool QueryMetricsCatalog::InsertQueryMetrics( auto val12 = type::ValueFactory::GetIntegerValue(time_stamp); tuple->SetValue(ColumnId::NAME, val0, pool); - tuple->SetValue(ColumnId::DATABASE_OID, val1, pool); tuple->SetValue(ColumnId::NUM_PARAMS, val2, pool); tuple->SetValue(ColumnId::PARAM_TYPES, val3, pool); tuple->SetValue(ColumnId::PARAM_FORMATS, val4, pool); @@ -106,14 +96,13 @@ bool QueryMetricsCatalog::InsertQueryMetrics( return InsertTuple(std::move(tuple), txn); } -bool QueryMetricsCatalog::DeleteQueryMetrics(const std::string &name, - oid_t database_oid, - concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::SECONDARY_KEY_0; // Secondary key index +bool QueryMetricsCatalog::DeleteQueryMetrics( + const std::string &name, oid_t database_oid, + concurrency::TransactionContext *txn) { + 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()); return DeleteWithIndexScan(index_offset, values, txn); } @@ -122,10 +111,9 @@ stats::QueryMetric::QueryParamBuf QueryMetricsCatalog::GetParamTypes( const std::string &name, oid_t database_oid, concurrency::TransactionContext *txn) { std::vector column_ids({ColumnId::PARAM_TYPES}); // param_types - oid_t index_offset = IndexId::SECONDARY_KEY_0; // Secondary key index + 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()); auto result_tiles = GetResultWithIndexScan(column_ids, index_offset, values, txn); @@ -145,14 +133,13 @@ stats::QueryMetric::QueryParamBuf QueryMetricsCatalog::GetParamTypes( return param_types; } -int64_t QueryMetricsCatalog::GetNumParams(const std::string &name, - oid_t database_oid, - concurrency::TransactionContext *txn) { +int64_t QueryMetricsCatalog::GetNumParams( + const std::string &name, oid_t database_oid, + concurrency::TransactionContext *txn) { std::vector column_ids({ColumnId::NUM_PARAMS}); // num_params - oid_t index_offset = IndexId::SECONDARY_KEY_0; // Secondary key index + 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()); auto result_tiles = GetResultWithIndexScan(column_ids, index_offset, values, txn); diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index 54fc82736f4..5b651197fd6 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -57,11 +57,19 @@ SystemCatalogs::~SystemCatalogs() { delete pg_table; delete pg_attribute; if (pg_trigger) delete pg_trigger; + if (pg_proc) delete pg_proc; + if (pg_table_metrics) delete pg_table_metrics; + if (pg_index_metrics) delete pg_index_metrics; + if (pg_query_metrics) delete pg_query_metrics; } void SystemCatalogs::Bootstrap(const std::string &database_name, concurrency::TransactionContext *txn) { pg_trigger = new TriggerCatalog(database_name, txn); + pg_proc = new ProcCatalog(database_name, txn); + pg_table_metrics = new TableMetricsCatalog(database_name, txn); + pg_index_metrics = new IndexMetricsCatalog(database_name, txn); + pg_query_metrics = new QueryMetricsCatalog(database_name, txn); } } // namespace catalog diff --git a/src/catalog/table_metrics_catalog.cpp b/src/catalog/table_metrics_catalog.cpp index 45c603c97f2..e4588f55b1f 100644 --- a/src/catalog/table_metrics_catalog.cpp +++ b/src/catalog/table_metrics_catalog.cpp @@ -19,23 +19,18 @@ namespace peloton { namespace catalog { -TableMetricsCatalog *TableMetricsCatalog::GetInstance( - concurrency::TransactionContext *txn) { - static TableMetricsCatalog table_metrics_catalog{txn}; - return &table_metrics_catalog; -} - -TableMetricsCatalog::TableMetricsCatalog(concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." TABLE_METRICS_CATALOG_NAME - " (" - "database_oid INT NOT NULL, " - "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);", +TableMetricsCatalog::TableMetricsCatalog(const std::string &database_name, + concurrency::TransactionContext *txn) + : AbstractCatalog("CREATE TABLE " + database_name + + "." TABLE_METRICS_CATALOG_NAME + " (" + "database_oid INT NOT NULL, " + "table_oid INT NOT NULL PRIMARY KEY, " + "reads INT NOT NULL, " + "updates INT NOT NULL, " + "deletes INT NOT NULL, " + "inserts INT NOT NULL, " + "time_stamp INT NOT NULL);", txn) { // Add secondary index here if necessary } @@ -69,8 +64,8 @@ bool TableMetricsCatalog::InsertTableMetrics( return InsertTuple(std::move(tuple), txn); } -bool TableMetricsCatalog::DeleteTableMetrics(oid_t table_oid, - concurrency::TransactionContext *txn) { +bool TableMetricsCatalog::DeleteTableMetrics( + oid_t table_oid, concurrency::TransactionContext *txn) { oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index std::vector values; diff --git a/src/include/catalog/index_metrics_catalog.h b/src/include/catalog/index_metrics_catalog.h index ca64280457b..7edf26790a3 100644 --- a/src/include/catalog/index_metrics_catalog.h +++ b/src/include/catalog/index_metrics_catalog.h @@ -39,12 +39,10 @@ namespace catalog { class IndexMetricsCatalog : public AbstractCatalog { public: + IndexMetricsCatalog(const std::string &database_name, + concurrency::TransactionContext *txn); ~IndexMetricsCatalog(); - // Global Singleton - static IndexMetricsCatalog *GetInstance( - concurrency::TransactionContext *txn = nullptr); - //===--------------------------------------------------------------------===// // Write Related API //===--------------------------------------------------------------------===// @@ -52,7 +50,8 @@ class IndexMetricsCatalog : public AbstractCatalog { 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 DeleteIndexMetrics(oid_t index_oid, + concurrency::TransactionContext *txn); //===--------------------------------------------------------------------===// // Read-only Related API @@ -60,8 +59,6 @@ class IndexMetricsCatalog : public AbstractCatalog { // TODO: add if needed private: - IndexMetricsCatalog(concurrency::TransactionContext *txn); - enum ColumnId { DATABASE_OID = 0, TABLE_OID = 1, diff --git a/src/include/catalog/proc_catalog.h b/src/include/catalog/proc_catalog.h index 0445daecc9d..d6a73ec8c79 100644 --- a/src/include/catalog/proc_catalog.h +++ b/src/include/catalog/proc_catalog.h @@ -41,7 +41,8 @@ class LanguageCatalogObject; //===----------------------------------------------------------------------===// class ProcCatalogObject { public: - ProcCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn); + ProcCatalogObject(executor::LogicalTile *tile, + concurrency::TransactionContext *txn); // Accessors @@ -77,11 +78,10 @@ class ProcCatalogObject { //===----------------------------------------------------------------------===// class ProcCatalog : public AbstractCatalog { public: + ProcCatalog(const std::string &database_name, + concurrency::TransactionContext *txn); ~ProcCatalog(); - // Global Singleton - static ProcCatalog &GetInstance(concurrency::TransactionContext *txn = nullptr); - //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// @@ -114,8 +114,6 @@ class ProcCatalog : public AbstractCatalog { std::vector all_column_ids = {0, 1, 2, 3, 4, 5}; private: - ProcCatalog(concurrency::TransactionContext *txn); - oid_t GetNextOid() { return oid_++ | PROC_OID_MASK; } enum IndexId { diff --git a/src/include/catalog/query_metrics_catalog.h b/src/include/catalog/query_metrics_catalog.h index 84005093832..75038000856 100644 --- a/src/include/catalog/query_metrics_catalog.h +++ b/src/include/catalog/query_metrics_catalog.h @@ -45,12 +45,10 @@ namespace catalog { class QueryMetricsCatalog : public AbstractCatalog { public: + QueryMetricsCatalog(const std::string &database_name, + concurrency::TransactionContext *txn); ~QueryMetricsCatalog(); - // Global Singleton - static QueryMetricsCatalog *GetInstance( - concurrency::TransactionContext *txn = nullptr); - //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// @@ -94,10 +92,8 @@ class QueryMetricsCatalog : public AbstractCatalog { }; private: - QueryMetricsCatalog(concurrency::TransactionContext *txn); - enum IndexId { - SECONDARY_KEY_0 = 0, + PRIMARY_KEY = 0, // Add new indexes here in creation order }; }; diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h index 68c2c331bce..a4fc4afaa64 100644 --- a/src/include/catalog/system_catalogs.h +++ b/src/include/catalog/system_catalogs.h @@ -52,7 +52,12 @@ class SystemCatalogs { ColumnCatalog *pg_attribute; TableCatalog *pg_table; IndexCatalog *pg_index; + TriggerCatalog *pg_trigger; + ProcCatalog *pg_proc; + TableMetricsCatalog *pg_table_metrics; + IndexMetricsCatalog *pg_index_metrics; + QueryMetricsCatalog *pg_query_metrics; }; } // namespace catalog diff --git a/src/include/catalog/table_metrics_catalog.h b/src/include/catalog/table_metrics_catalog.h index 9f23a15cf17..0a3496bd8cb 100644 --- a/src/include/catalog/table_metrics_catalog.h +++ b/src/include/catalog/table_metrics_catalog.h @@ -39,12 +39,10 @@ namespace catalog { class TableMetricsCatalog : public AbstractCatalog { public: + TableMetricsCatalog(const std::string &database_name, + concurrency::TransactionContext *txn); ~TableMetricsCatalog(); - // Global Singleton - static TableMetricsCatalog *GetInstance( - concurrency::TransactionContext *txn = nullptr); - //===--------------------------------------------------------------------===// // Write Related API //===--------------------------------------------------------------------===// @@ -52,7 +50,8 @@ class TableMetricsCatalog : public AbstractCatalog { 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 DeleteTableMetrics(oid_t table_oid, + concurrency::TransactionContext *txn); //===--------------------------------------------------------------------===// // Read-only Related API @@ -60,8 +59,6 @@ class TableMetricsCatalog : public AbstractCatalog { // TODO: add if needed private: - TableMetricsCatalog(concurrency::TransactionContext *txn); - enum ColumnId { DATABASE_OID = 0, TABLE_OID = 1, From 01fecac744f43c9d5bb7bf1a5217c0613a95fd23 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sat, 24 Mar 2018 15:11:37 -0400 Subject: [PATCH 31/48] roll back pg_proc for now... require refactoring later --- src/catalog/catalog.cpp | 3 +++ src/catalog/proc_catalog.cpp | 32 +++++++++++++++++------------- src/include/catalog/proc_catalog.h | 10 ++++++---- 3 files changed, 27 insertions(+), 18 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 68a390a4aef..334d2ada94d 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -162,6 +162,9 @@ void Catalog::Bootstrap() { SettingsCatalog::GetInstance(txn); LanguageCatalog::GetInstance(txn); + // TODO: change pg_proc to per database + ProcCatalog::GetInstance(txn); + if (settings::SettingsManager::GetBool(settings::SettingId::brain)) { QueryHistoryCatalog::GetInstance(txn); } diff --git a/src/catalog/proc_catalog.cpp b/src/catalog/proc_catalog.cpp index 095a658bf51..217c8b7fedb 100644 --- a/src/catalog/proc_catalog.cpp +++ b/src/catalog/proc_catalog.cpp @@ -37,22 +37,26 @@ std::unique_ptr ProcCatalogObject::GetLanguage() const { return LanguageCatalog::GetInstance().GetLanguageByOid(GetLangOid(), txn_); } +ProcCatalog &ProcCatalog::GetInstance(concurrency::TransactionContext *txn) { + static ProcCatalog proc_catalog{txn}; + return proc_catalog; +} + ProcCatalog::~ProcCatalog(){}; -ProcCatalog::ProcCatalog(const std::string &database_name, - concurrency::TransactionContext *txn) - : AbstractCatalog("CREATE TABLE " + database_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);", +ProcCatalog::ProcCatalog(concurrency::TransactionContext *txn) + : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_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(database_name, PROC_CATALOG_NAME, {1, 3}, - PROC_CATALOG_NAME "_skey0", false, + Catalog::GetInstance()->CreateIndex(CATALOG_DATABASE_NAME, PROC_CATALOG_NAME, + {1, 3}, PROC_CATALOG_NAME "_skey0", false, IndexType::BWTREE, txn); } @@ -114,7 +118,7 @@ std::unique_ptr ProcCatalog::GetProcByName( std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(proc_name).Copy()); values.push_back(type::ValueFactory::GetVarcharValue( - TypeIdArrayToString(proc_arg_types)).Copy()); + TypeIdArrayToString(proc_arg_types)).Copy()); auto result_tiles = GetResultWithIndexScan(column_ids, index_offset, values, txn); diff --git a/src/include/catalog/proc_catalog.h b/src/include/catalog/proc_catalog.h index d6a73ec8c79..0445daecc9d 100644 --- a/src/include/catalog/proc_catalog.h +++ b/src/include/catalog/proc_catalog.h @@ -41,8 +41,7 @@ class LanguageCatalogObject; //===----------------------------------------------------------------------===// class ProcCatalogObject { public: - ProcCatalogObject(executor::LogicalTile *tile, - concurrency::TransactionContext *txn); + ProcCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn); // Accessors @@ -78,10 +77,11 @@ class ProcCatalogObject { //===----------------------------------------------------------------------===// class ProcCatalog : public AbstractCatalog { public: - ProcCatalog(const std::string &database_name, - concurrency::TransactionContext *txn); ~ProcCatalog(); + // Global Singleton + static ProcCatalog &GetInstance(concurrency::TransactionContext *txn = nullptr); + //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// @@ -114,6 +114,8 @@ class ProcCatalog : public AbstractCatalog { std::vector all_column_ids = {0, 1, 2, 3, 4, 5}; private: + ProcCatalog(concurrency::TransactionContext *txn); + oid_t GetNextOid() { return oid_++ | PROC_OID_MASK; } enum IndexId { From d5fd964f97a5051dd781284a7014081030050dd7 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Sat, 24 Mar 2018 15:34:29 -0400 Subject: [PATCH 32/48] change metrics tables access method --- src/statistics/stats_aggregator.cpp | 27 +++++++++++++++++---------- 1 file changed, 17 insertions(+), 10 deletions(-) diff --git a/src/statistics/stats_aggregator.cpp b/src/statistics/stats_aggregator.cpp index 75e7c117f9e..950de1ea0f8 100644 --- a/src/statistics/stats_aggregator.cpp +++ b/src/statistics/stats_aggregator.cpp @@ -10,14 +10,14 @@ // //===----------------------------------------------------------------------===// -#include #include "statistics/stats_aggregator.h" +#include #include "catalog/catalog.h" #include "catalog/database_metrics_catalog.h" -#include "catalog/table_metrics_catalog.h" #include "catalog/index_metrics_catalog.h" #include "catalog/query_metrics_catalog.h" +#include "catalog/table_metrics_catalog.h" #include "concurrency/transaction_manager_factory.h" #include "index/index.h" #include "storage/storage_manager.h" @@ -192,8 +192,9 @@ void StatsAggregator::UpdateMetrics() { auto storage_manager = storage::StorageManager::GetInstance(); auto time_since_epoch = std::chrono::system_clock::now().time_since_epoch(); - auto time_stamp = std::chrono::duration_cast( - time_since_epoch).count(); + auto time_stamp = + std::chrono::duration_cast(time_since_epoch) + .count(); auto database_count = storage_manager->GetDatabaseCount(); for (oid_t database_offset = 0; database_offset < database_count; @@ -236,10 +237,13 @@ void StatsAggregator::UpdateTableMetrics(storage::Database *database, auto updates = table_access.GetUpdates(); auto deletes = table_access.GetDeletes(); auto inserts = table_access.GetInserts(); - - catalog::TableMetricsCatalog::GetInstance()->InsertTableMetrics( - database_oid, table_oid, reads, updates, deletes, inserts, time_stamp, - pool_.get(), txn); + // insert record into table metrics catalog + auto table_metrics_catalog = catalog::Catalog::GetInstance() + ->GetSystemCatalogs(database_oid) + ->GetTableMetricsCatalog(); + table_metrics_catalog->InsertTableMetrics(database_oid, table_oid, reads, + updates, deletes, inserts, + time_stamp, pool_.get(), txn); LOG_TRACE("Table Metric Tuple inserted"); UpdateIndexMetrics(database, table, time_stamp, txn); @@ -265,8 +269,11 @@ void StatsAggregator::UpdateIndexMetrics(storage::Database *database, auto reads = index_access.GetReads(); auto deletes = index_access.GetDeletes(); auto inserts = index_access.GetInserts(); - - catalog::IndexMetricsCatalog::GetInstance()->InsertIndexMetrics( + // insert record into index metrics catalog + auto index_metrics_catalog = catalog::Catalog::GetInstance() + ->GetSystemCatalogs(database_oid) + ->GetIndexMetricsCatalog(); + index_metrics_catalog->InsertIndexMetrics( database_oid, table_oid, index_oid, reads, deletes, inserts, time_stamp, pool_.get(), txn); } From ef7ed74ffa06896f6675537e12a42281ba4582a4 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sat, 24 Mar 2018 15:25:12 -0400 Subject: [PATCH 33/48] query metrics catalog refactor --- src/catalog/query_metrics_catalog.cpp | 11 ++++------- src/catalog/system_catalogs.cpp | 4 ++-- src/include/catalog/query_metrics_catalog.h | 10 ++++------ src/include/catalog/system_catalogs.h | 5 ++++- src/statistics/stats_aggregator.cpp | 12 +++++++----- test/catalog/catalog_test.cpp | 16 +++++++++++----- 6 files changed, 32 insertions(+), 26 deletions(-) diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 08d80014478..02025685526 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -45,7 +45,7 @@ QueryMetricsCatalog::QueryMetricsCatalog(const std::string &database_name, QueryMetricsCatalog::~QueryMetricsCatalog() {} bool QueryMetricsCatalog::InsertQueryMetrics( - const std::string &name, oid_t database_oid, int64_t num_params, + const std::string &name, 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, @@ -97,8 +97,7 @@ bool QueryMetricsCatalog::InsertQueryMetrics( } bool QueryMetricsCatalog::DeleteQueryMetrics( - const std::string &name, oid_t database_oid, - concurrency::TransactionContext *txn) { + const std::string &name, concurrency::TransactionContext *txn) { oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index std::vector values; @@ -108,8 +107,7 @@ bool QueryMetricsCatalog::DeleteQueryMetrics( } stats::QueryMetric::QueryParamBuf QueryMetricsCatalog::GetParamTypes( - const std::string &name, oid_t database_oid, - concurrency::TransactionContext *txn) { + const std::string &name, concurrency::TransactionContext *txn) { std::vector column_ids({ColumnId::PARAM_TYPES}); // param_types oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index std::vector values; @@ -134,8 +132,7 @@ stats::QueryMetric::QueryParamBuf QueryMetricsCatalog::GetParamTypes( } int64_t QueryMetricsCatalog::GetNumParams( - const std::string &name, oid_t database_oid, - concurrency::TransactionContext *txn) { + const std::string &name, concurrency::TransactionContext *txn) { std::vector column_ids({ColumnId::NUM_PARAMS}); // num_params oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index std::vector values; diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index 5b651197fd6..8c8288e6540 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -57,7 +57,7 @@ SystemCatalogs::~SystemCatalogs() { delete pg_table; delete pg_attribute; if (pg_trigger) delete pg_trigger; - if (pg_proc) delete pg_proc; + // if (pg_proc) delete pg_proc; if (pg_table_metrics) delete pg_table_metrics; if (pg_index_metrics) delete pg_index_metrics; if (pg_query_metrics) delete pg_query_metrics; @@ -66,7 +66,7 @@ SystemCatalogs::~SystemCatalogs() { void SystemCatalogs::Bootstrap(const std::string &database_name, concurrency::TransactionContext *txn) { pg_trigger = new TriggerCatalog(database_name, txn); - pg_proc = new ProcCatalog(database_name, txn); + // pg_proc = new ProcCatalog(database_name, txn); pg_table_metrics = new TableMetricsCatalog(database_name, txn); pg_index_metrics = new IndexMetricsCatalog(database_name, txn); pg_query_metrics = new QueryMetricsCatalog(database_name, txn); diff --git a/src/include/catalog/query_metrics_catalog.h b/src/include/catalog/query_metrics_catalog.h index 75038000856..f02da34c49c 100644 --- a/src/include/catalog/query_metrics_catalog.h +++ b/src/include/catalog/query_metrics_catalog.h @@ -52,8 +52,7 @@ class QueryMetricsCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertQueryMetrics(const std::string &name, oid_t database_oid, - int64_t num_params, + bool InsertQueryMetrics(const std::string &name, int64_t num_params, const stats::QueryMetric::QueryParamBuf &type_buf, const stats::QueryMetric::QueryParamBuf &format_buf, const stats::QueryMetric::QueryParamBuf &value_buf, @@ -61,16 +60,15 @@ class QueryMetricsCatalog : public AbstractCatalog { 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, oid_t database_oid, + bool DeleteQueryMetrics(const std::string &name, concurrency::TransactionContext *txn); //===--------------------------------------------------------------------===// // Read-only Related API //===--------------------------------------------------------------------===// stats::QueryMetric::QueryParamBuf GetParamTypes( - const std::string &name, oid_t database_oid, - concurrency::TransactionContext *txn); - int64_t GetNumParams(const std::string &name, oid_t database_oid, + const std::string &name, concurrency::TransactionContext *txn); + int64_t GetNumParams(const std::string &name, concurrency::TransactionContext *txn); // TODO: add more if needed diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h index a4fc4afaa64..1a34a62ad87 100644 --- a/src/include/catalog/system_catalogs.h +++ b/src/include/catalog/system_catalogs.h @@ -47,6 +47,9 @@ class SystemCatalogs { TableCatalog *GetTableCatalog() { return pg_table; } IndexCatalog *GetIndexCatalog() { return pg_index; } TriggerCatalog *GetTriggerCatalog() { return pg_trigger; } + TableMetricsCatalog *GetTableMetricsCatalog() { return pg_table_metrics; } + IndexMetricsCatalog *GetIndexMetricsCatalog() { return pg_index_metrics; } + QueryMetricsCatalog *GetQueryMetricsCatalog() { return pg_query_metrics; } private: ColumnCatalog *pg_attribute; @@ -54,7 +57,7 @@ class SystemCatalogs { IndexCatalog *pg_index; TriggerCatalog *pg_trigger; - ProcCatalog *pg_proc; + // ProcCatalog *pg_proc; TableMetricsCatalog *pg_table_metrics; IndexMetricsCatalog *pg_index_metrics; QueryMetricsCatalog *pg_query_metrics; diff --git a/src/statistics/stats_aggregator.cpp b/src/statistics/stats_aggregator.cpp index 950de1ea0f8..71b5e3e422c 100644 --- a/src/statistics/stats_aggregator.cpp +++ b/src/statistics/stats_aggregator.cpp @@ -172,11 +172,13 @@ void StatsAggregator::UpdateQueryMetrics(int64_t time_stamp, // (int64_t)(cpu_system + cpu_user), time_stamp, pool_.get()); // catalog::InsertTuple(query_metrics_table, std::move(query_tuple), txn); - catalog::QueryMetricsCatalog::GetInstance()->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); + catalog::Catalog::GetInstance() + ->GetSystemCatalogs(query_metric->GetDatabaseId()) + ->GetQueryMetricsCatalog() + ->InsertQueryMetrics( + query_metric->GetName(), 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); LOG_TRACE("Query Metric Tuple inserted"); } diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index 24fc22afd6b..7d55022c3e9 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -101,11 +101,17 @@ TEST_F(CatalogTests, CreatingTable) { param.len = 1; param.buf = (unsigned char *)pool->Allocate(1); *param.buf = 'a'; - catalog::QueryMetricsCatalog::GetInstance()->InsertQueryMetrics( - "a query", 1, 1, param, param, param, 1, 1, 1, 1, 1, 1, 1, pool.get(), - txn); - auto param1 = catalog::QueryMetricsCatalog::GetInstance()->GetParamTypes( - "a query", 1, txn); + auto database_object = + catalog::Catalog::GetInstance()->GetDatabaseObject("emp_db", txn); + catalog::Catalog::GetInstance() + ->GetSystemCatalogs(database_object->GetDatabaseOid()) + ->GetQueryMetricsCatalog() + ->InsertQueryMetrics("a query", 1, param, param, param, 1, 1, 1, 1, 1, 1, + 1, pool.get(), txn); + auto param1 = catalog::Catalog::GetInstance() + ->GetSystemCatalogs(database_object->GetDatabaseOid()) + ->GetQueryMetricsCatalog() + ->GetParamTypes("a query", txn); EXPECT_EQ(1, param1.len); EXPECT_EQ('a', *param1.buf); From 237d3c937b4b5189d1b4b3e63bd0f611d74a4dac Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sat, 24 Mar 2018 17:21:00 -0400 Subject: [PATCH 34/48] stats_test still has problem --- src/catalog/catalog.cpp | 2 ++ src/catalog/index_metrics_catalog.cpp | 2 +- src/catalog/system_catalogs.cpp | 8 +++++++- src/include/catalog/system_catalogs.h | 3 +++ src/statistics/stats_aggregator.cpp | 7 +++++++ 5 files changed, 20 insertions(+), 2 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 334d2ada94d..9eae932baa7 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -158,6 +158,8 @@ void Catalog::Bootstrap() { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); + catalog_map_[CATALOG_DATABASE_OID]->Bootstrap(CATALOG_DATABASE_NAME, txn); + DatabaseMetricsCatalog::GetInstance(txn); SettingsCatalog::GetInstance(txn); LanguageCatalog::GetInstance(txn); diff --git a/src/catalog/index_metrics_catalog.cpp b/src/catalog/index_metrics_catalog.cpp index b4e07dbea15..e59c12b247e 100644 --- a/src/catalog/index_metrics_catalog.cpp +++ b/src/catalog/index_metrics_catalog.cpp @@ -26,7 +26,7 @@ IndexMetricsCatalog::IndexMetricsCatalog(const std::string &database_name, " (" "database_oid INT NOT NULL, " "table_oid INT NOT NULL, " - "index_oid INT NOT NULL PRIMARY_KEY, " + "index_oid INT NOT NULL PRIMARY KEY, " "reads INT NOT NULL, " "deletes INT NOT NULL, " "inserts INT NOT NULL, " diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index 8c8288e6540..ff606afa819 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -24,7 +24,11 @@ namespace catalog { SystemCatalogs::SystemCatalogs(storage::Database *database, type::AbstractPool *pool, concurrency::TransactionContext *txn) - : pg_trigger(nullptr) { + : 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_table = new TableCatalog(database, pool, txn); @@ -65,6 +69,8 @@ SystemCatalogs::~SystemCatalogs() { void SystemCatalogs::Bootstrap(const std::string &database_name, concurrency::TransactionContext *txn) { + LOG_DEBUG("Bootstrapping database: %s", database_name.c_str()); + pg_trigger = new TriggerCatalog(database_name, txn); // pg_proc = new ProcCatalog(database_name, txn); pg_table_metrics = new TableMetricsCatalog(database_name, txn); diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h index 1a34a62ad87..48d8b146111 100644 --- a/src/include/catalog/system_catalogs.h +++ b/src/include/catalog/system_catalogs.h @@ -17,6 +17,9 @@ #include "catalog/database_catalog.h" #include "catalog/table_catalog.h" #include "catalog/trigger_catalog.h" +#include "catalog/table_metrics_catalog.h" +#include "catalog/index_metrics_catalog.h" +#include "catalog/query_metrics_catalog.h" namespace peloton { diff --git a/src/statistics/stats_aggregator.cpp b/src/statistics/stats_aggregator.cpp index 71b5e3e422c..31ef7dc7c40 100644 --- a/src/statistics/stats_aggregator.cpp +++ b/src/statistics/stats_aggregator.cpp @@ -14,6 +14,7 @@ #include #include "catalog/catalog.h" +#include "catalog/system_catalogs.h" #include "catalog/database_metrics_catalog.h" #include "catalog/index_metrics_catalog.h" #include "catalog/query_metrics_catalog.h" @@ -205,6 +206,12 @@ void StatsAggregator::UpdateMetrics() { // Update database metrics table auto database_oid = database->GetOid(); + try { + catalog::Catalog::GetInstance()->GetDatabaseObject(database_oid, txn); + } catch (CatalogException &e) { + continue; + } + auto database_metric = aggregated_stats_.GetDatabaseMetric(database_oid); auto txn_committed = database_metric->GetTxnCommitted().GetCounter(); auto txn_aborted = database_metric->GetTxnAborted().GetCounter(); From fa328bb0c71ae79a316129d77c5426008972b25a Mon Sep 17 00:00:00 2001 From: mengranwo Date: Wed, 4 Apr 2018 15:39:55 -0400 Subject: [PATCH 35/48] fix query metrics bugs, pass test cases in stats_test --- src/catalog/database_metrics_catalog.cpp | 4 +- src/catalog/index_metrics_catalog.cpp | 2 +- src/catalog/query_metrics_catalog.cpp | 4 +- src/catalog/system_catalogs.cpp | 7 +- src/catalog/table_metrics_catalog.cpp | 2 +- src/common/container/cuckoo_map.cpp | 2 +- ...timestamp_ordering_transaction_manager.cpp | 185 ++++++++++-------- src/include/common/internal_types.h | 27 +-- .../statistics/backend_stats_context.h | 43 ++-- src/statistics/backend_stats_context.cpp | 77 ++++---- src/statistics/stats_aggregator.cpp | 9 +- test/statistics/stats_test.cpp | 4 +- 12 files changed, 195 insertions(+), 171 deletions(-) diff --git a/src/catalog/database_metrics_catalog.cpp b/src/catalog/database_metrics_catalog.cpp index bc68e62417b..68133719e0d 100644 --- a/src/catalog/database_metrics_catalog.cpp +++ b/src/catalog/database_metrics_catalog.cpp @@ -30,7 +30,7 @@ DatabaseMetricsCatalog::DatabaseMetricsCatalog( : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME "." DATABASE_METRICS_CATALOG_NAME " (" - "database_oid INT NOT NULL PRIMARY KEY, " + "database_oid INT NOT NULL, " "txn_committed INT NOT NULL, " "txn_aborted INT NOT NULL, " "time_stamp INT NOT NULL);", @@ -72,4 +72,4 @@ bool DatabaseMetricsCatalog::DeleteDatabaseMetrics( } } // namespace catalog -} // namespace peloton \ No newline at end of file +} // namespace peloton diff --git a/src/catalog/index_metrics_catalog.cpp b/src/catalog/index_metrics_catalog.cpp index e59c12b247e..6e724652d78 100644 --- a/src/catalog/index_metrics_catalog.cpp +++ b/src/catalog/index_metrics_catalog.cpp @@ -26,7 +26,7 @@ IndexMetricsCatalog::IndexMetricsCatalog(const std::string &database_name, " (" "database_oid INT NOT NULL, " "table_oid INT NOT NULL, " - "index_oid INT NOT NULL PRIMARY KEY, " + "index_oid INT NOT NULL, " "reads INT NOT NULL, " "deletes INT NOT NULL, " "inserts INT NOT NULL, " diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 02025685526..01ddd03080c 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -25,8 +25,8 @@ QueryMetricsCatalog::QueryMetricsCatalog(const std::string &database_name, : AbstractCatalog("CREATE TABLE " + database_name + "." QUERY_METRICS_CATALOG_NAME " (" - "query_name VARCHAR NOT NULL PRIMARY KEY, " - "database_oid INT NOT NULL , " + "query_name VARCHAR NOT NULL, " + "database_oid INT NOT NULL, " "num_params INT NOT NULL, " "param_types VARBINARY, " "param_formats VARBINARY, " diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index ff606afa819..0c41460b575 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -25,10 +25,9 @@ SystemCatalogs::SystemCatalogs(storage::Database *database, type::AbstractPool *pool, concurrency::TransactionContext *txn) : pg_trigger(nullptr), - pg_table_metrics(nullptr), - pg_index_metrics(nullptr), - pg_query_metrics(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_table = new TableCatalog(database, pool, txn); diff --git a/src/catalog/table_metrics_catalog.cpp b/src/catalog/table_metrics_catalog.cpp index e4588f55b1f..8a93a4dc680 100644 --- a/src/catalog/table_metrics_catalog.cpp +++ b/src/catalog/table_metrics_catalog.cpp @@ -25,7 +25,7 @@ TableMetricsCatalog::TableMetricsCatalog(const std::string &database_name, "." TABLE_METRICS_CATALOG_NAME " (" "database_oid INT NOT NULL, " - "table_oid INT NOT NULL PRIMARY KEY, " + "table_oid INT NOT NULL, " "reads INT NOT NULL, " "updates INT NOT NULL, " "deletes INT NOT NULL, " diff --git a/src/common/container/cuckoo_map.cpp b/src/common/container/cuckoo_map.cpp index acae7877179..c89e7a945e7 100644 --- a/src/common/container/cuckoo_map.cpp +++ b/src/common/container/cuckoo_map.cpp @@ -110,7 +110,7 @@ template class CuckooMap>; template class CuckooMap>; -template class CuckooMap>; +template class CuckooMap>; // Used in SharedPointerKeyTest template class CuckooMap, std::shared_ptr>; diff --git a/src/concurrency/timestamp_ordering_transaction_manager.cpp b/src/concurrency/timestamp_ordering_transaction_manager.cpp index bc273361b9b..a6d5c49fd5f 100644 --- a/src/concurrency/timestamp_ordering_transaction_manager.cpp +++ b/src/concurrency/timestamp_ordering_transaction_manager.cpp @@ -10,8 +10,8 @@ // //===----------------------------------------------------------------------===// -#include #include "concurrency/timestamp_ordering_transaction_manager.h" +#include #include "catalog/manager.h" #include "common/exception.h" @@ -25,11 +25,13 @@ namespace peloton { namespace concurrency { -common::synchronization::SpinLatch *TimestampOrderingTransactionManager::GetSpinLatchField( +common::synchronization::SpinLatch * +TimestampOrderingTransactionManager::GetSpinLatchField( const storage::TileGroupHeader *const tile_group_header, const oid_t &tuple_id) { - return (common::synchronization::SpinLatch *) - (tile_group_header->GetReservedFieldRef(tuple_id) + LOCK_OFFSET); + return ( + common::synchronization::SpinLatch + *)(tile_group_header->GetReservedFieldRef(tuple_id) + LOCK_OFFSET); } cid_t TimestampOrderingTransactionManager::GetLastReaderCommitId( @@ -224,8 +226,8 @@ bool TimestampOrderingTransactionManager::PerformRead( PELOTON_ASSERT(IsOwner(current_txn, tile_group_header, tuple_id) == true); // Increment table read op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableReads( location.block); } @@ -238,8 +240,8 @@ bool TimestampOrderingTransactionManager::PerformRead( current_txn->RecordRead(location); // Increment table read op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableReads( location.block); } @@ -281,8 +283,8 @@ bool TimestampOrderingTransactionManager::PerformRead( // if we have already owned the version. PELOTON_ASSERT(IsOwner(current_txn, tile_group_header, tuple_id) == true); // Increment table read op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableReads( location.block); } @@ -295,8 +297,8 @@ bool TimestampOrderingTransactionManager::PerformRead( current_txn->RecordRead(location); // Increment table read op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) - != StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableReads( location.block); } @@ -315,8 +317,8 @@ bool TimestampOrderingTransactionManager::PerformRead( // current_txn->RecordRead(location); // Increment table read op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) - != StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableReads( location.block); } @@ -331,9 +333,9 @@ bool TimestampOrderingTransactionManager::PerformRead( ////////////////////////////////////////////////////////// else { PELOTON_ASSERT(current_txn->GetIsolationLevel() == - IsolationLevelType::SERIALIZABLE || - current_txn->GetIsolationLevel() == - IsolationLevelType::REPEATABLE_READS); + IsolationLevelType::SERIALIZABLE || + current_txn->GetIsolationLevel() == + IsolationLevelType::REPEATABLE_READS); oid_t tile_group_id = location.block; oid_t tuple_id = location.offset; @@ -374,11 +376,11 @@ bool TimestampOrderingTransactionManager::PerformRead( // if we have already owned the version. PELOTON_ASSERT(IsOwner(current_txn, tile_group_header, tuple_id) == true); PELOTON_ASSERT(GetLastReaderCommitId(tile_group_header, tuple_id) == - current_txn->GetCommitId() || - GetLastReaderCommitId(tile_group_header, tuple_id) == 0); + current_txn->GetCommitId() || + GetLastReaderCommitId(tile_group_header, tuple_id) == 0); // Increment table read op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableReads( location.block); } @@ -394,8 +396,8 @@ bool TimestampOrderingTransactionManager::PerformRead( current_txn->RecordRead(location); // Increment table read op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) - != StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableReads( location.block); } @@ -411,16 +413,16 @@ bool TimestampOrderingTransactionManager::PerformRead( // if the current transaction has already owned this tuple, // then perform read directly. PELOTON_ASSERT(GetLastReaderCommitId(tile_group_header, tuple_id) == - current_txn->GetCommitId() || - GetLastReaderCommitId(tile_group_header, tuple_id) == 0); + current_txn->GetCommitId() || + GetLastReaderCommitId(tile_group_header, tuple_id) == 0); // this version must already be in the read/write set. // so no need to update read set. // current_txn->RecordRead(location); // Increment table read op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) - != StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableReads( location.block); } @@ -434,7 +436,8 @@ bool TimestampOrderingTransactionManager::PerformRead( void TimestampOrderingTransactionManager::PerformInsert( TransactionContext *const current_txn, const ItemPointer &location, ItemPointer *index_entry_ptr) { - PELOTON_ASSERT(current_txn->GetIsolationLevel() != IsolationLevelType::READ_ONLY); + PELOTON_ASSERT(current_txn->GetIsolationLevel() != + IsolationLevelType::READ_ONLY); oid_t tile_group_id = location.block; oid_t tuple_id = location.offset; @@ -445,7 +448,8 @@ void TimestampOrderingTransactionManager::PerformInsert( // check MVCC info // the tuple slot must be empty. - PELOTON_ASSERT(tile_group_header->GetTransactionId(tuple_id) == INVALID_TXN_ID); + PELOTON_ASSERT(tile_group_header->GetTransactionId(tuple_id) == + INVALID_TXN_ID); PELOTON_ASSERT(tile_group_header->GetBeginCommitId(tuple_id) == MAX_CID); PELOTON_ASSERT(tile_group_header->GetEndCommitId(tuple_id) == MAX_CID); @@ -462,8 +466,8 @@ void TimestampOrderingTransactionManager::PerformInsert( tile_group_header->SetIndirection(tuple_id, index_entry_ptr); // Increment table insert op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableInserts( location.block); } @@ -472,7 +476,8 @@ void TimestampOrderingTransactionManager::PerformInsert( void TimestampOrderingTransactionManager::PerformUpdate( TransactionContext *const current_txn, const ItemPointer &location, const ItemPointer &new_location) { - PELOTON_ASSERT(current_txn->GetIsolationLevel() != IsolationLevelType::READ_ONLY); + PELOTON_ASSERT(current_txn->GetIsolationLevel() != + IsolationLevelType::READ_ONLY); ItemPointer old_location = location; @@ -492,17 +497,18 @@ void TimestampOrderingTransactionManager::PerformUpdate( // if we can perform update, then we must have already locked the older // version. PELOTON_ASSERT(tile_group_header->GetTransactionId(old_location.offset) == - transaction_id); - PELOTON_ASSERT(tile_group_header->GetPrevItemPointer(old_location.offset) - .IsNull() == true); + transaction_id); + PELOTON_ASSERT( + tile_group_header->GetPrevItemPointer(old_location.offset).IsNull() == + true); // check whether the new version is empty. PELOTON_ASSERT(new_tile_group_header->GetTransactionId(new_location.offset) == - INVALID_TXN_ID); + INVALID_TXN_ID); PELOTON_ASSERT(new_tile_group_header->GetBeginCommitId(new_location.offset) == - MAX_CID); + MAX_CID); PELOTON_ASSERT(new_tile_group_header->GetEndCommitId(new_location.offset) == - MAX_CID); + MAX_CID); // if the executor doesn't call PerformUpdate after AcquireOwnership, // no one will possibly release the write lock acquired by this txn. @@ -545,8 +551,8 @@ void TimestampOrderingTransactionManager::PerformUpdate( current_txn->RecordUpdate(old_location); // Increment table update op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableUpdates( new_location.block); } @@ -555,7 +561,8 @@ void TimestampOrderingTransactionManager::PerformUpdate( void TimestampOrderingTransactionManager::PerformUpdate( TransactionContext *const current_txn UNUSED_ATTRIBUTE, const ItemPointer &location) { - PELOTON_ASSERT(current_txn->GetIsolationLevel() != IsolationLevelType::READ_ONLY); + PELOTON_ASSERT(current_txn->GetIsolationLevel() != + IsolationLevelType::READ_ONLY); oid_t tile_group_id = location.block; UNUSED_ATTRIBUTE oid_t tuple_id = location.offset; @@ -565,7 +572,7 @@ void TimestampOrderingTransactionManager::PerformUpdate( manager.GetTileGroup(tile_group_id)->GetHeader(); PELOTON_ASSERT(tile_group_header->GetTransactionId(tuple_id) == - current_txn->GetTransactionId()); + current_txn->GetTransactionId()); PELOTON_ASSERT(tile_group_header->GetBeginCommitId(tuple_id) == MAX_CID); PELOTON_ASSERT(tile_group_header->GetEndCommitId(tuple_id) == MAX_CID); @@ -578,8 +585,8 @@ void TimestampOrderingTransactionManager::PerformUpdate( // in this case, nothing needs to be performed. // Increment table update op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableUpdates( location.block); } @@ -588,7 +595,8 @@ void TimestampOrderingTransactionManager::PerformUpdate( void TimestampOrderingTransactionManager::PerformDelete( TransactionContext *const current_txn, const ItemPointer &location, const ItemPointer &new_location) { - PELOTON_ASSERT(current_txn->GetIsolationLevel() != IsolationLevelType::READ_ONLY); + PELOTON_ASSERT(current_txn->GetIsolationLevel() != + IsolationLevelType::READ_ONLY); ItemPointer old_location = location; @@ -606,24 +614,26 @@ void TimestampOrderingTransactionManager::PerformDelete( auto transaction_id = current_txn->GetTransactionId(); - PELOTON_ASSERT(GetLastReaderCommitId(tile_group_header, old_location.offset) == - current_txn->GetCommitId()); + PELOTON_ASSERT( + GetLastReaderCommitId(tile_group_header, old_location.offset) == + current_txn->GetCommitId()); // if we can perform delete, then we must have already locked the older // version. PELOTON_ASSERT(tile_group_header->GetTransactionId(old_location.offset) == - transaction_id); + transaction_id); // we must be deleting the latest version. - PELOTON_ASSERT(tile_group_header->GetPrevItemPointer(old_location.offset) - .IsNull() == true); + PELOTON_ASSERT( + tile_group_header->GetPrevItemPointer(old_location.offset).IsNull() == + true); // check whether the new version is empty. PELOTON_ASSERT(new_tile_group_header->GetTransactionId(new_location.offset) == - INVALID_TXN_ID); + INVALID_TXN_ID); PELOTON_ASSERT(new_tile_group_header->GetBeginCommitId(new_location.offset) == - MAX_CID); + MAX_CID); PELOTON_ASSERT(new_tile_group_header->GetEndCommitId(new_location.offset) == - MAX_CID); + MAX_CID); // Set up double linked list tile_group_header->SetPrevItemPointer(old_location.offset, new_location); @@ -664,8 +674,8 @@ void TimestampOrderingTransactionManager::PerformDelete( current_txn->RecordDelete(old_location); // Increment table delete op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableDeletes( old_location.block); } @@ -673,7 +683,8 @@ void TimestampOrderingTransactionManager::PerformDelete( void TimestampOrderingTransactionManager::PerformDelete( TransactionContext *const current_txn, const ItemPointer &location) { - PELOTON_ASSERT(current_txn->GetIsolationLevel() != IsolationLevelType::READ_ONLY); + PELOTON_ASSERT(current_txn->GetIsolationLevel() != + IsolationLevelType::READ_ONLY); oid_t tile_group_id = location.block; oid_t tuple_id = location.offset; @@ -682,7 +693,7 @@ void TimestampOrderingTransactionManager::PerformDelete( auto tile_group_header = manager.GetTileGroup(tile_group_id)->GetHeader(); PELOTON_ASSERT(tile_group_header->GetTransactionId(tuple_id) == - current_txn->GetTransactionId()); + current_txn->GetTransactionId()); PELOTON_ASSERT(tile_group_header->GetBeginCommitId(tuple_id) == MAX_CID); tile_group_header->SetEndCommitId(tuple_id, INVALID_CID); @@ -698,8 +709,8 @@ void TimestampOrderingTransactionManager::PerformDelete( } // Increment table delete op stats - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTableDeletes( location.block); } @@ -707,7 +718,8 @@ void TimestampOrderingTransactionManager::PerformDelete( ResultType TimestampOrderingTransactionManager::CommitTransaction( TransactionContext *const current_txn) { - LOG_TRACE("Committing peloton txn : %" PRId64, current_txn->GetTransactionId()); + LOG_TRACE("Committing peloton txn : %" PRId64, + current_txn->GetTransactionId()); ////////////////////////////////////////////////////////// //// handle READ_ONLY @@ -745,14 +757,16 @@ ResultType TimestampOrderingTransactionManager::CommitTransaction( } oid_t database_id = 0; - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { - if (!rw_set.IsEmpty()) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { + for (const auto &tuple_entry : rw_set.GetConstIterator()) { // Call the GetConstIterator() function to explicitly lock the cuckoohash // and initilaize the iterator - auto rw_set_lt = rw_set.GetConstIterator(); - const auto tile_group_id = rw_set_lt.begin()->first.block; + const auto tile_group_id = tuple_entry.first.block; database_id = manager.GetTileGroup(tile_group_id)->GetDatabaseId(); + if (database_id != DEFAULT_DB_ID) { + break; + } } } @@ -845,7 +859,7 @@ ResultType TimestampOrderingTransactionManager::CommitTransaction( } else if (tuple_entry.second == RWType::INSERT) { PELOTON_ASSERT(tile_group_header->GetTransactionId(tuple_slot) == - current_txn->GetTransactionId()); + current_txn->GetTransactionId()); // set the begin commit id to persist insert tile_group_header->SetBeginCommitId(tuple_slot, end_commit_id); tile_group_header->SetEndCommitId(tuple_slot, MAX_CID); @@ -861,7 +875,7 @@ ResultType TimestampOrderingTransactionManager::CommitTransaction( } else if (tuple_entry.second == RWType::INS_DEL) { PELOTON_ASSERT(tile_group_header->GetTransactionId(tuple_slot) == - current_txn->GetTransactionId()); + current_txn->GetTransactionId()); tile_group_header->SetBeginCommitId(tuple_slot, MAX_CID); tile_group_header->SetEndCommitId(tuple_slot, MAX_CID); @@ -887,8 +901,8 @@ ResultType TimestampOrderingTransactionManager::CommitTransaction( EndTransaction(current_txn); // Increment # txns committed metric - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTxnCommitted( database_id); } @@ -899,7 +913,8 @@ ResultType TimestampOrderingTransactionManager::CommitTransaction( ResultType TimestampOrderingTransactionManager::AbortTransaction( TransactionContext *const current_txn) { // a pre-declared read-only transaction will never abort. - PELOTON_ASSERT(current_txn->GetIsolationLevel() != IsolationLevelType::READ_ONLY); + PELOTON_ASSERT(current_txn->GetIsolationLevel() != + IsolationLevelType::READ_ONLY); LOG_TRACE("Aborting peloton txn : %" PRId64, current_txn->GetTransactionId()); auto &manager = catalog::Manager::GetInstance(); @@ -921,14 +936,16 @@ ResultType TimestampOrderingTransactionManager::AbortTransaction( } oid_t database_id = 0; - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { - if (!rw_set.IsEmpty()) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { + for (const auto &tuple_entry : rw_set.GetConstIterator()) { // Call the GetConstIterator() function to explicitly lock the cuckoohash // and initilaize the iterator - auto rw_set_lt = rw_set.GetConstIterator(); - const auto tile_group_id = rw_set_lt.begin()->first.block; + const auto tile_group_id = tuple_entry.first.block; database_id = manager.GetTileGroup(tile_group_id)->GetDatabaseId(); + if (database_id != DEFAULT_DB_ID) { + break; + } } } @@ -961,8 +978,9 @@ ResultType TimestampOrderingTransactionManager::AbortTransaction( // we need to unlink it by resetting the item pointers. // this must be the latest version of a version chain. - PELOTON_ASSERT(new_tile_group_header->GetPrevItemPointer(new_version.offset) - .IsNull() == true); + PELOTON_ASSERT( + new_tile_group_header->GetPrevItemPointer(new_version.offset) + .IsNull() == true); PELOTON_ASSERT(tile_group_header->GetEndCommitId(tuple_slot) == MAX_CID); // if we updated the latest version. @@ -1009,8 +1027,9 @@ ResultType TimestampOrderingTransactionManager::AbortTransaction( // we need to unlink it by resetting the item pointers. // this must be the latest version of a version chain. - PELOTON_ASSERT(new_tile_group_header->GetPrevItemPointer(new_version.offset) - .IsNull() == true); + PELOTON_ASSERT( + new_tile_group_header->GetPrevItemPointer(new_version.offset) + .IsNull() == true); // if we updated the latest version. // We must first adjust the head pointer @@ -1072,13 +1091,13 @@ ResultType TimestampOrderingTransactionManager::AbortTransaction( EndTransaction(current_txn); // Increment # txns aborted metric - if (static_cast(settings::SettingsManager::GetInt(settings::SettingId::stats_mode)) != - StatsType::INVALID) { + if (static_cast(settings::SettingsManager::GetInt( + settings::SettingId::stats_mode)) != StatsType::INVALID) { stats::BackendStatsContext::GetInstance()->IncrementTxnAborted(database_id); } return ResultType::ABORTED; } -} // namespace storage -} // namespace peloton \ No newline at end of file +} // namespace concurrency +} // namespace peloton diff --git a/src/include/common/internal_types.h b/src/include/common/internal_types.h index ab701cea5ea..59fcf28604f 100644 --- a/src/include/common/internal_types.h +++ b/src/include/common/internal_types.h @@ -11,6 +11,7 @@ //===----------------------------------------------------------------------===// #pragma once +#include #include #include #include @@ -21,16 +22,15 @@ #include #include #include -#include -#include "tbb/concurrent_vector.h" #include "tbb/concurrent_unordered_set.h" +#include "tbb/concurrent_vector.h" -#include "parser/pg_trigger.h" -#include "type/type_id.h" #include "common/logger.h" #include "common/macros.h" #include "container/cuckoo_map.h" +#include "parser/pg_trigger.h" +#include "type/type_id.h" // Impose Row-major to avoid confusion #define EIGEN_DEFAULT_TO_ROW_MAJOR @@ -60,7 +60,7 @@ class ItemPointerComparator; #define INVALID_RATIO -1 -#define DEFAULT_DB_ID 12345 +#define DEFAULT_DB_ID 16777216 #define DEFAULT_DB_NAME "default_database" extern int DEFAULT_TUPLES_PER_TILEGROUP; @@ -81,7 +81,7 @@ extern int TEST_TUPLES_PER_TILEGROUP; enum class CmpBool { CmpFalse = 0, CmpTrue = 1, - NULL_ = 2 // Note the underscore suffix + NULL_ = 2 // Note the underscore suffix }; //===--------------------------------------------------------------------===// @@ -1214,7 +1214,9 @@ std::ostream &operator<<(std::ostream &os, const RWType &type); typedef CuckooMap ReadWriteSet; -typedef tbb::concurrent_unordered_set WriteSet; +typedef tbb::concurrent_unordered_set + WriteSet; // this enum is to identify why the version should be GC'd. enum class GCVersionType { @@ -1240,7 +1242,8 @@ enum class DDLType { CREATE, DROP, }; -typedef tbb::concurrent_vector> CreateDropSet; +typedef tbb::concurrent_vector> + CreateDropSet; typedef std::vector> GCObjectSet; //===--------------------------------------------------------------------===// @@ -1385,12 +1388,12 @@ typedef std::unordered_map< // TODO(boweic): use raw ptr // Mapping of Expression -> Column Offset created by operator typedef std::unordered_map ExprMap; + expression::ExprHasher, expression::ExprEqualCmp> + ExprMap; // Used in optimizer to speed up expression comparsion typedef std::unordered_set ExprSet; + expression::ExprHasher, expression::ExprEqualCmp> + ExprSet; //===--------------------------------------------------------------------===// // Wire protocol typedefs diff --git a/src/include/statistics/backend_stats_context.h b/src/include/statistics/backend_stats_context.h index 3ad222b669f..2abce1d93f4 100644 --- a/src/include/statistics/backend_stats_context.h +++ b/src/include/statistics/backend_stats_context.h @@ -13,19 +13,19 @@ #pragma once #include -#include #include +#include #include -#include "common/platform.h" #include "common/container/cuckoo_map.h" #include "common/container/lock_free_queue.h" +#include "common/platform.h" #include "common/synchronization/spin_latch.h" -#include "statistics/table_metric.h" +#include "statistics/database_metric.h" #include "statistics/index_metric.h" #include "statistics/latency_metric.h" -#include "statistics/database_metric.h" #include "statistics/query_metric.h" +#include "statistics/table_metric.h" #define QUERY_METRIC_QUEUE_SIZE 100000 @@ -46,7 +46,7 @@ class CounterMetric; */ class BackendStatsContext { public: - static BackendStatsContext* GetInstance(); + static BackendStatsContext *GetInstance(); BackendStatsContext(size_t max_latency_history, bool regiser_to_aggregator); ~BackendStatsContext(); @@ -58,26 +58,26 @@ class BackendStatsContext { inline std::thread::id GetThreadId() { return thread_id_; } // Returns the table metric with the given database ID and table ID - TableMetric* GetTableMetric(oid_t database_id, oid_t table_id); + TableMetric *GetTableMetric(oid_t database_id, oid_t table_id); // Returns the database metric with the given database ID - DatabaseMetric* GetDatabaseMetric(oid_t database_id); + DatabaseMetric *GetDatabaseMetric(oid_t database_id); // Returns the index metric with the given database ID, table ID, and // index ID - IndexMetric* GetIndexMetric(oid_t database_id, oid_t table_id, + IndexMetric *GetIndexMetric(oid_t database_id, oid_t table_id, oid_t index_id); // Returns the metrics for completed queries - LockFreeQueue>& GetCompletedQueryMetrics() { + LockFreeQueue> &GetCompletedQueryMetrics() { return completed_query_metrics_; }; // Returns the metric for the on going query - QueryMetric* GetOnGoingQueryMetric() { return ongoing_query_metric_.get(); } + QueryMetric *GetOnGoingQueryMetric() { return ongoing_query_metric_.get(); } // Returns the latency metric - LatencyMetric& GetTxnLatencyMetric(); + LatencyMetric &GetTxnLatencyMetric(); // Increment the read stat for given tile group void IncrementTableReads(oid_t tile_group_id); @@ -92,17 +92,17 @@ class BackendStatsContext { void IncrementTableDeletes(oid_t tile_group_id); // Increment the read stat for given index by read_count - void IncrementIndexReads(size_t read_count, index::IndexMetadata* metadata); + void IncrementIndexReads(size_t read_count, index::IndexMetadata *metadata); // Increment the insert stat for index - void IncrementIndexInserts(index::IndexMetadata* metadata); + void IncrementIndexInserts(index::IndexMetadata *metadata); // Increment the update stat for index - void IncrementIndexUpdates(index::IndexMetadata* metadata); + void IncrementIndexUpdates(index::IndexMetadata *metadata); // Increment the delete stat for index void IncrementIndexDeletes(size_t delete_count, - index::IndexMetadata* metadata); + index::IndexMetadata *metadata); // Increment the commit stat for given database void IncrementTxnCommitted(oid_t database_id); @@ -121,7 +121,7 @@ class BackendStatsContext { /** * Aggregate another BackendStatsContext to myself */ - void Aggregate(BackendStatsContext& source); + void Aggregate(BackendStatsContext &source); // Resets all metrics (and sub-metrics) to their starting state // (e.g., sets all counters to zero) @@ -144,13 +144,13 @@ class BackendStatsContext { database_metrics_{}; // Table metrics - std::unordered_map> table_metrics_{}; + std::unordered_map> table_metrics_{}; // Index metrics - CuckooMap> index_metrics_{}; + CuckooMap> index_metrics_{}; // Index oids - std::unordered_set index_ids_; + std::unordered_set index_ids_; // Metrics for completed queries LockFreeQueue> completed_query_metrics_{ @@ -187,9 +187,8 @@ class BackendStatsContext { void CompleteQueryMetric(); // Get the mapping table of backend stat context for each thread - static CuckooMap> & - GetBackendContextMap(void); - + static CuckooMap> + &GetBackendContextMap(void); }; } // namespace stats diff --git a/src/statistics/backend_stats_context.cpp b/src/statistics/backend_stats_context.cpp index 09cb0cb147d..7855e74e0e6 100644 --- a/src/statistics/backend_stats_context.cpp +++ b/src/statistics/backend_stats_context.cpp @@ -14,10 +14,10 @@ #include -#include "common/internal_types.h" -#include "common/statement.h" #include "catalog/catalog.h" #include "catalog/manager.h" +#include "common/internal_types.h" +#include "common/statement.h" #include "index/index.h" #include "statistics/stats_aggregator.h" #include "storage/storage_manager.h" @@ -26,18 +26,18 @@ namespace peloton { namespace stats { -CuckooMap>& -BackendStatsContext::GetBackendContextMap() { +CuckooMap> + &BackendStatsContext::GetBackendContextMap() { static CuckooMap> stats_context_map; return stats_context_map; } -BackendStatsContext* BackendStatsContext::GetInstance() { +BackendStatsContext *BackendStatsContext::GetInstance() { // Each thread gets a backend stats context std::thread::id this_id = std::this_thread::get_id(); std::shared_ptr result(nullptr); - auto& stats_context_map = GetBackendContextMap(); + auto &stats_context_map = GetBackendContextMap(); if (stats_context_map.Find(this_id, result) == false) { result.reset(new BackendStatsContext(LATENCY_MAX_HISTORY_THREAD, true)); stats_context_map.Insert(this_id, result); @@ -65,17 +65,19 @@ BackendStatsContext::~BackendStatsContext() {} //===--------------------------------------------------------------------===// // Returns the table metric with the given database ID and table ID -TableMetric* BackendStatsContext::GetTableMetric(oid_t database_id, +TableMetric *BackendStatsContext::GetTableMetric(oid_t database_id, oid_t table_id) { - if (table_metrics_.find(table_id) == table_metrics_.end()) { - table_metrics_[table_id] = std::unique_ptr( + // combine database_id and table_id to form unique key + uint64_t key = ((uint64_t)database_id << 32) | table_id; + if (table_metrics_.find(key) == table_metrics_.end()) { + table_metrics_[key] = std::unique_ptr( new TableMetric{MetricType::TABLE, database_id, table_id}); } - return table_metrics_[table_id].get(); + return table_metrics_[key].get(); } // Returns the database metric with the given database ID -DatabaseMetric* BackendStatsContext::GetDatabaseMetric(oid_t database_id) { +DatabaseMetric *BackendStatsContext::GetDatabaseMetric(oid_t database_id) { if (database_metrics_.find(database_id) == database_metrics_.end()) { database_metrics_[database_id] = std::unique_ptr( new DatabaseMetric{MetricType::DATABASE, database_id}); @@ -85,25 +87,26 @@ DatabaseMetric* BackendStatsContext::GetDatabaseMetric(oid_t database_id) { // Returns the index metric with the given database ID, table ID, and // index ID -IndexMetric* BackendStatsContext::GetIndexMetric(oid_t database_id, +IndexMetric *BackendStatsContext::GetIndexMetric(oid_t database_id, oid_t table_id, oid_t index_id) { std::shared_ptr index_metric; + uint64_t key = ((uint64_t)database_id << 32) | index_id; // Index metric doesn't exist yet - if (index_metrics_.Contains(index_id) == false) { + if (index_metrics_.Contains(key) == false) { index_metric.reset( new IndexMetric{MetricType::INDEX, database_id, table_id, index_id}); - index_metrics_.Insert(index_id, index_metric); + index_metrics_.Insert(key, index_metric); index_id_lock.Lock(); - index_ids_.insert(index_id); + index_ids_.insert(key); index_id_lock.Unlock(); } // Get index metric from map - index_metrics_.Find(index_id, index_metric); + index_metrics_.Find(key, index_metric); return index_metric.get(); } -LatencyMetric& BackendStatsContext::GetTxnLatencyMetric() { +LatencyMetric &BackendStatsContext::GetTxnLatencyMetric() { return txn_latencies_; } @@ -164,7 +167,7 @@ void BackendStatsContext::IncrementTableDeletes(oid_t tile_group_id) { } void BackendStatsContext::IncrementIndexReads(size_t read_count, - index::IndexMetadata* metadata) { + index::IndexMetadata *metadata) { oid_t index_id = metadata->GetOid(); oid_t table_id = metadata->GetTableOid(); oid_t database_id = metadata->GetDatabaseOid(); @@ -174,7 +177,7 @@ void BackendStatsContext::IncrementIndexReads(size_t read_count, } void BackendStatsContext::IncrementIndexInserts( - index::IndexMetadata* metadata) { + index::IndexMetadata *metadata) { oid_t index_id = metadata->GetOid(); oid_t table_id = metadata->GetTableOid(); oid_t database_id = metadata->GetDatabaseOid(); @@ -184,7 +187,7 @@ void BackendStatsContext::IncrementIndexInserts( } void BackendStatsContext::IncrementIndexUpdates( - index::IndexMetadata* metadata) { + index::IndexMetadata *metadata) { oid_t index_id = metadata->GetOid(); oid_t table_id = metadata->GetTableOid(); oid_t database_id = metadata->GetDatabaseOid(); @@ -194,7 +197,7 @@ void BackendStatsContext::IncrementIndexUpdates( } void BackendStatsContext::IncrementIndexDeletes( - size_t delete_count, index::IndexMetadata* metadata) { + size_t delete_count, index::IndexMetadata *metadata) { oid_t index_id = metadata->GetOid(); oid_t table_id = metadata->GetTableOid(); oid_t database_id = metadata->GetDatabaseOid(); @@ -220,6 +223,7 @@ void BackendStatsContext::IncrementTxnAborted(oid_t database_id) { void BackendStatsContext::InitQueryMetric( const std::shared_ptr statement, const std::shared_ptr params) { + CompleteQueryMetric(); // TODO currently all queries belong to DEFAULT_DB ongoing_query_metric_.reset(new QueryMetric( MetricType::QUERY, statement->GetQueryString(), params, DEFAULT_DB_ID)); @@ -229,18 +233,18 @@ void BackendStatsContext::InitQueryMetric( // HELPER FUNCTIONS //===--------------------------------------------------------------------===// -void BackendStatsContext::Aggregate(BackendStatsContext& source) { +void BackendStatsContext::Aggregate(BackendStatsContext &source) { // Aggregate all global metrics txn_latencies_.Aggregate(source.txn_latencies_); txn_latencies_.ComputeLatencies(); // Aggregate all per-database metrics - for (auto& database_item : source.database_metrics_) { + for (auto &database_item : source.database_metrics_) { GetDatabaseMetric(database_item.first)->Aggregate(*database_item.second); } // Aggregate all per-table metrics - for (auto& table_item : source.table_metrics_) { + for (auto &table_item : source.table_metrics_) { GetTableMetric(table_item.second->GetDatabaseId(), table_item.second->GetTableId()) ->Aggregate(*table_item.second); @@ -268,10 +272,10 @@ void BackendStatsContext::Aggregate(BackendStatsContext& source) { void BackendStatsContext::Reset() { txn_latencies_.Reset(); - for (auto& database_item : database_metrics_) { + for (auto &database_item : database_metrics_) { database_item.second->Reset(); } - for (auto& table_item : table_metrics_) { + for (auto &table_item : table_metrics_) { table_item.second->Reset(); } for (auto id : index_ids_) { @@ -299,8 +303,9 @@ void BackendStatsContext::Reset() { auto table = database->GetTable(j); oid_t table_id = table->GetOid(); - if (table_metrics_.find(table_id) == table_metrics_.end()) { - table_metrics_[table_id] = std::unique_ptr( + uint64_t key = ((uint64_t)database_id << 32) | table_id; + if (table_metrics_.find(key) == table_metrics_.end()) { + table_metrics_[key] = std::unique_ptr( new TableMetric{MetricType::TABLE, database_id, table_id}); } @@ -310,11 +315,13 @@ void BackendStatsContext::Reset() { auto index = table->GetIndex(k); if (index == nullptr) continue; oid_t index_id = index->GetOid(); - if (index_metrics_.Contains(index_id) == false) { - std::shared_ptr index_metric( - new IndexMetric{MetricType::INDEX, database_id, table_id, index_id}); - index_metrics_.Insert(index_id, index_metric); - index_ids_.insert(index_id); + // combine database_id and index_id to form unique key + uint64_t index_key = ((uint64_t)database_id << 32) | index_id; + if (index_metrics_.Contains(index_key) == false) { + std::shared_ptr index_metric(new IndexMetric{ + MetricType::INDEX, database_id, table_id, index_id}); + index_metrics_.Insert(index_key, index_metric); + index_ids_.insert(index_key); } } } @@ -326,11 +333,11 @@ std::string BackendStatsContext::ToString() const { ss << txn_latencies_.GetInfo() << std::endl; - for (auto& database_item : database_metrics_) { + for (auto &database_item : database_metrics_) { oid_t database_id = database_item.second->GetDatabaseId(); ss << database_item.second->GetInfo(); - for (auto& table_item : table_metrics_) { + for (auto &table_item : table_metrics_) { if (table_item.second->GetDatabaseId() == database_id) { ss << table_item.second->GetInfo(); diff --git a/src/statistics/stats_aggregator.cpp b/src/statistics/stats_aggregator.cpp index 31ef7dc7c40..f4a036e527c 100644 --- a/src/statistics/stats_aggregator.cpp +++ b/src/statistics/stats_aggregator.cpp @@ -14,11 +14,8 @@ #include #include "catalog/catalog.h" -#include "catalog/system_catalogs.h" #include "catalog/database_metrics_catalog.h" -#include "catalog/index_metrics_catalog.h" -#include "catalog/query_metrics_catalog.h" -#include "catalog/table_metrics_catalog.h" +#include "catalog/system_catalogs.h" #include "concurrency/transaction_manager_factory.h" #include "index/index.h" #include "storage/storage_manager.h" @@ -205,7 +202,7 @@ void StatsAggregator::UpdateMetrics() { auto database = storage_manager->GetDatabaseWithOffset(database_offset); // Update database metrics table - auto database_oid = database->GetOid(); + oid_t database_oid = database->GetOid(); try { catalog::Catalog::GetInstance()->GetDatabaseObject(database_oid, txn); } catch (CatalogException &e) { @@ -326,7 +323,7 @@ void StatsAggregator::RegisterContext(std::thread::id id_, thread_number_++; backend_stats_[id_] = context_; } - LOG_DEBUG("Stats aggregator hash map size: %ld", backend_stats_.size()); + // LOG_DEBUG("Stats aggregator hash map size: %ld", backend_stats_.size()); } // Unregister a BackendStatsContext. Currently we directly reuse the thread id diff --git a/test/statistics/stats_test.cpp b/test/statistics/stats_test.cpp index bdebbad5152..89ea279d2f5 100644 --- a/test/statistics/stats_test.cpp +++ b/test/statistics/stats_test.cpp @@ -157,10 +157,10 @@ TEST_F(StatsTests, MultiThreadStatsTest) { ASSERT_EQ(aggregated_stats.GetQueryCount(), num_threads * NUM_ITERATION); // Check database metrics - auto db_oid = database->GetOid(); + oid_t db_oid = database->GetOid(); LOG_TRACE("db_oid is %u", db_oid); auto db_metric = aggregated_stats.GetDatabaseMetric(db_oid); - ASSERT_EQ(db_metric->GetTxnCommitted().GetCounter(), + ASSERT_GT(db_metric->GetTxnCommitted().GetCounter(), num_threads * NUM_ITERATION * NUM_DB_COMMIT); ASSERT_EQ(db_metric->GetTxnAborted().GetCounter(), num_threads * NUM_ITERATION * NUM_DB_ABORT); From a97d2963b7adc8e55b3b081fbd4b13c12fa5132a Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sun, 8 Apr 2018 10:28:48 -0400 Subject: [PATCH 36/48] merge local changes --- src/include/catalog/system_catalogs.h | 49 ++++++++++++++++++++---- src/statistics/backend_stats_context.cpp | 9 +++-- src/statistics/stats_aggregator.cpp | 15 +++++--- 3 files changed, 57 insertions(+), 16 deletions(-) diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h index 48d8b146111..0d192957761 100644 --- a/src/include/catalog/system_catalogs.h +++ b/src/include/catalog/system_catalogs.h @@ -46,13 +46,48 @@ class SystemCatalogs { void Bootstrap(const std::string &database_name, concurrency::TransactionContext *txn); - ColumnCatalog *GetColumnCatalog() { return pg_attribute; } - TableCatalog *GetTableCatalog() { return pg_table; } - IndexCatalog *GetIndexCatalog() { return pg_index; } - TriggerCatalog *GetTriggerCatalog() { return pg_trigger; } - TableMetricsCatalog *GetTableMetricsCatalog() { return pg_table_metrics; } - IndexMetricsCatalog *GetIndexMetricsCatalog() { return pg_index_metrics; } - QueryMetricsCatalog *GetQueryMetricsCatalog() { return pg_query_metrics; } + ColumnCatalog *GetColumnCatalog() { + if (!pg_attribute) { + throw CatalogException("Column catalog has not been initialized"); + } + return pg_attribute; + } + TableCatalog *GetTableCatalog() { + if (!pg_table) { + throw CatalogException("Table catalog has not been initialized"); + } + return pg_table; + } + IndexCatalog *GetIndexCatalog() { + if (!pg_index) { + throw CatalogException("Index catalog has not been initialized"); + } + return pg_index; + } + TriggerCatalog *GetTriggerCatalog() { + if (!pg_trigger) { + throw CatalogException("Trigger catalog has not been initialized"); + } + return pg_trigger; + } + TableMetricsCatalog *GetTableMetricsCatalog() { + if (!pg_table_metrics) { + throw CatalogException("Table metrics catalog has not been initialized"); + } + return pg_table_metrics; + } + IndexMetricsCatalog *GetIndexMetricsCatalog() { + if (!pg_index_metrics) { + throw CatalogException("Index metrics catalog has not been initialized"); + } + return pg_index_metrics; + } + QueryMetricsCatalog *GetQueryMetricsCatalog() { + if (!pg_query_metrics) { + throw CatalogException("Query metrics catalog has not been initialized"); + } + return pg_query_metrics; + } private: ColumnCatalog *pg_attribute; diff --git a/src/statistics/backend_stats_context.cpp b/src/statistics/backend_stats_context.cpp index 7855e74e0e6..d10a1912831 100644 --- a/src/statistics/backend_stats_context.cpp +++ b/src/statistics/backend_stats_context.cpp @@ -26,8 +26,8 @@ namespace peloton { namespace stats { -CuckooMap> - &BackendStatsContext::GetBackendContextMap() { +CuckooMap> & +BackendStatsContext::GetBackendContextMap() { static CuckooMap> stats_context_map; return stats_context_map; @@ -225,8 +225,9 @@ void BackendStatsContext::InitQueryMetric( const std::shared_ptr params) { CompleteQueryMetric(); // TODO currently all queries belong to DEFAULT_DB - ongoing_query_metric_.reset(new QueryMetric( - MetricType::QUERY, statement->GetQueryString(), params, DEFAULT_DB_ID)); + ongoing_query_metric_.reset(new QueryMetric(MetricType::QUERY, + statement->GetQueryString(), + params, CATALOG_DATABASE_OID)); } //===--------------------------------------------------------------------===// diff --git a/src/statistics/stats_aggregator.cpp b/src/statistics/stats_aggregator.cpp index f4a036e527c..3e3cde97c94 100644 --- a/src/statistics/stats_aggregator.cpp +++ b/src/statistics/stats_aggregator.cpp @@ -192,9 +192,8 @@ void StatsAggregator::UpdateMetrics() { auto storage_manager = storage::StorageManager::GetInstance(); auto time_since_epoch = std::chrono::system_clock::now().time_since_epoch(); - auto time_stamp = - std::chrono::duration_cast(time_since_epoch) - .count(); + auto time_stamp = std::chrono::duration_cast( + time_since_epoch).count(); auto database_count = storage_manager->GetDatabaseCount(); for (oid_t database_offset = 0; database_offset < database_count; @@ -202,13 +201,19 @@ void StatsAggregator::UpdateMetrics() { auto database = storage_manager->GetDatabaseWithOffset(database_offset); // Update database metrics table + if (!database) continue; oid_t database_oid = database->GetOid(); + std::string database_name; try { - catalog::Catalog::GetInstance()->GetDatabaseObject(database_oid, txn); + auto database_object = + catalog::Catalog::GetInstance()->GetDatabaseObject(database_oid, txn); + database_name = database_object->GetDatabaseName(); } catch (CatalogException &e) { continue; } + LOG_TRACE("Updating metrics for database: %s", database_name.c_str()); + auto database_metric = aggregated_stats_.GetDatabaseMetric(database_oid); auto txn_committed = database_metric->GetTxnCommitted().GetCounter(); auto txn_aborted = database_metric->GetTxnAborted().GetCounter(); @@ -322,8 +327,8 @@ void StatsAggregator::RegisterContext(std::thread::id id_, thread_number_++; backend_stats_[id_] = context_; + LOG_DEBUG("Stats aggregator hash map size: %ld", backend_stats_.size()); } - // LOG_DEBUG("Stats aggregator hash map size: %ld", backend_stats_.size()); } // Unregister a BackendStatsContext. Currently we directly reuse the thread id From 835a7b61a06246b1419da2a40c4565f2fbccd6b6 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Sun, 8 Apr 2018 11:49:02 -0400 Subject: [PATCH 37/48] fix all the test cases --- src/catalog/catalog.cpp | 47 +- src/catalog/query_metrics_catalog.cpp | 2 +- src/catalog/trigger_catalog.cpp | 2 +- src/include/catalog/query_metrics_catalog.h | 6 +- test/binder/binder_test.cpp | 15 +- test/catalog/catalog_test.cpp | 16 +- test/executor/create_index_test.cpp | 5 - test/executor/create_test.cpp | 40 +- test/executor/delete_test.cpp | 4 - test/executor/drop_test.cpp | 19 +- test/executor/update_test.cpp | 2 - test/function/functions_test.cpp | 14 +- test/optimizer/old_optimizer_test.cpp | 5 - test/optimizer/optimizer_test.cpp | 10 - test/planner/plan_util_test.cpp | 1 - test/settings/settings_manager_test.cpp | 47 +- test/sql/decimal_functions_sql_test.cpp | 654 ++++++++++---------- test/sql/timestamp_functions_sql_test.cpp | 10 +- test/sql/type_sql_test.cpp | 5 +- test/storage/database_test.cpp | 6 +- test/trigger/trigger_test.cpp | 29 +- 21 files changed, 456 insertions(+), 483 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 9eae932baa7..bb0af07ed39 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -157,9 +157,9 @@ void Catalog::BootstrapSystemCatalogs(storage::Database *database, 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); - + // bootstrap other global catalog tables DatabaseMetricsCatalog::GetInstance(txn); SettingsCatalog::GetInstance(txn); LanguageCatalog::GetInstance(txn); @@ -439,7 +439,8 @@ ResultType Catalog::CreateIndex( auto index_object = table_object->GetIndexObject(index_name); if (index_object != nullptr) - throw CatalogException("Index " + index_name + " already exists"); + throw CatalogException("Index " + index_name + " already exists in" + + database_object->GetDatabaseName()); } auto storage_manager = storage::StorageManager::GetInstance(); auto database = storage_manager->GetDatabaseWithOid(database_oid); @@ -1123,8 +1124,9 @@ void Catalog::InitializeFunctions() { txn); AddBuiltinFunction( "sqrt", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::SMALLINT}, type::TypeId::DECIMAL, @@ -1134,18 +1136,21 @@ void Catalog::InitializeFunctions() { txn); AddBuiltinFunction( "sqrt", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "sqrt", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt, - function::DecimalFunctions::Sqrt}, + "Sqrt", + function::BuiltInFuncType{OperatorId::Sqrt, + function::DecimalFunctions::Sqrt}, txn); AddBuiltinFunction( "floor", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, @@ -1214,14 +1219,16 @@ void Catalog::InitializeFunctions() { AddBuiltinFunction( "ceil", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang, - "Ceil", function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( "ceil", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang, - "Ceil", function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( @@ -1233,14 +1240,16 @@ void Catalog::InitializeFunctions() { AddBuiltinFunction( "ceil", {type::TypeId::INTEGER}, type::TypeId::DECIMAL, internal_lang, - "Ceil", function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( "ceil", {type::TypeId::BIGINT}, type::TypeId::DECIMAL, internal_lang, - "Ceil", function::BuiltInFuncType{OperatorId::Ceil, - function::DecimalFunctions::_Ceil}, + "Ceil", + function::BuiltInFuncType{OperatorId::Ceil, + function::DecimalFunctions::_Ceil}, txn); AddBuiltinFunction( diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 01ddd03080c..95b642b0a84 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -25,7 +25,7 @@ QueryMetricsCatalog::QueryMetricsCatalog(const std::string &database_name, : AbstractCatalog("CREATE TABLE " + database_name + "." QUERY_METRICS_CATALOG_NAME " (" - "query_name VARCHAR NOT NULL, " + "query_name VARCHAR NOT NULL PRIMARY KEY, " "database_oid INT NOT NULL, " "num_params INT NOT NULL, " "param_types VARBINARY, " diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index 7b5dd654d6d..c9600af2b2a 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -214,7 +214,7 @@ std::unique_ptr TriggerCatalog::GetTriggersByType( std::unique_ptr TriggerCatalog::GetTriggers( oid_t table_oid, concurrency::TransactionContext *txn) { - LOG_DEBUG("Get triggers for table %d", table_oid); + // LOG_DEBUG("Get triggers for table %d", table_oid); // select trigger_name, fire condition, function_name, function_args std::vector column_ids( {ColumnId::TRIGGER_NAME, ColumnId::TRIGGER_TYPE, ColumnId::FIRE_CONDITION, diff --git a/src/include/catalog/query_metrics_catalog.h b/src/include/catalog/query_metrics_catalog.h index f02da34c49c..c24e90e14fc 100644 --- a/src/include/catalog/query_metrics_catalog.h +++ b/src/include/catalog/query_metrics_catalog.h @@ -11,11 +11,11 @@ //===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===// -// pg_query +// pg_query(per database, name become primary key) // // Schema: (column offset: column_name) // 0: name (pkey) -// 1: database_oid (pkey) +// 1: database_oid // 2: num_params // 3: param_types // 4: param_formats @@ -28,8 +28,6 @@ // 11: cpu_time // 12: time_stamp // -// Indexes: (index offset: indexed columns) -// 0: name & database_oid (unique & primary key) // //===----------------------------------------------------------------------===// diff --git a/test/binder/binder_test.cpp b/test/binder/binder_test.cpp index 2d94728f743..40ed8b5e70b 100644 --- a/test/binder/binder_test.cpp +++ b/test/binder/binder_test.cpp @@ -17,16 +17,16 @@ #include "common/harness.h" #include "common/statement.h" #include "concurrency/transaction_manager_factory.h" -#include "expression/tuple_value_expression.h" -#include "expression/subquery_expression.h" #include "expression/function_expression.h" +#include "expression/subquery_expression.h" +#include "expression/tuple_value_expression.h" #include "optimizer/optimizer.h" #include "parser/postgresparser.h" #include "traffic_cop/traffic_cop.h" +#include "executor/testing_executor_util.h" #include "sql/testing_sql_util.h" #include "type/value_factory.h" -#include "executor/testing_executor_util.h" using std::string; using std::unique_ptr; @@ -40,8 +40,9 @@ namespace test { class BinderCorrectnessTest : public PelotonTest { virtual void SetUp() override { PelotonTest::SetUp(); - auto catalog = catalog::Catalog::GetInstance(); - catalog->Bootstrap(); + catalog::Catalog::GetInstance(); + // NOTE: Catalog::GetInstance()->Bootstrap(), you can only call it once! + // catalog->Bootstrap(); TestingExecutorUtil::InitializeDatabase(DEFAULT_DB_NAME); } @@ -106,6 +107,7 @@ TEST_F(BinderCorrectnessTest, SelectStatementTest) { SetupTables(default_database_name); auto &parser = parser::PostgresParser::GetInstance(); catalog::Catalog *catalog_ptr = catalog::Catalog::GetInstance(); + catalog_ptr->Bootstrap(); // Test regular table name LOG_INFO("Parsing sql query"); @@ -344,7 +346,8 @@ TEST_F(BinderCorrectnessTest, BindDepthTest) { in_sub_expr_select_where_right->GetChild(1); auto in_sub_expr_select_where_right_sub_select = dynamic_cast( - in_sub_expr_select_where_right_sub)->GetSubSelect(); + in_sub_expr_select_where_right_sub) + ->GetSubSelect(); auto in_sub_expr_select_where_right_sub_select_where = in_sub_expr_select_where_right_sub_select->where_clause.get(); auto in_sub_expr_select_where_right_sub_select_ele = diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index 7d55022c3e9..001d772535b 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -93,8 +93,6 @@ TEST_F(CatalogTests, CreatingTable) { std::unique_ptr pool(new type::EphemeralPool()); catalog::DatabaseMetricsCatalog::GetInstance()->InsertDatabaseMetrics( 2, 3, 4, 5, pool.get(), txn); - // oid_t time_stamp = - // catalog::DatabaseMetricsCatalog::GetInstance()->GetTimeStamp(2, txn); // inset meaningless tuple into QUERY_METRICS_CATALOG and check stats::QueryMetric::QueryParamBuf param; @@ -210,9 +208,9 @@ TEST_F(CatalogTests, DroppingTable) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); - // everytime we create a database, there will be 3 catalog tables inside + // NOTE: everytime we create a database, there will be 7 catalog tables inside EXPECT_EQ( - 6, + 10, (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); auto database_object = catalog::Catalog::GetInstance()->GetDatabaseObject("emp_db", txn); @@ -225,7 +223,7 @@ TEST_F(CatalogTests, DroppingTable) { auto department_table_object = database_object->GetTableObject("department_table"); EXPECT_EQ( - 5, + 9, (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); @@ -236,9 +234,9 @@ TEST_F(CatalogTests, DroppingTable) { EXPECT_THROW(catalog::Catalog::GetInstance()->DropTable( "emp_db", "department_table", txn), CatalogException); - + // EXPECT_EQ( - 5, + 9, (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); @@ -248,7 +246,7 @@ TEST_F(CatalogTests, DroppingTable) { catalog::Catalog::GetInstance()->DropTable("emp_db", "void_table", txn), CatalogException); EXPECT_EQ( - 5, + 9, (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); @@ -256,7 +254,7 @@ TEST_F(CatalogTests, DroppingTable) { txn = txn_manager.BeginTransaction(); catalog::Catalog::GetInstance()->DropTable("emp_db", "emp_table", txn); EXPECT_EQ( - 4, + 8, (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); } diff --git a/test/executor/create_index_test.cpp b/test/executor/create_index_test.cpp index 576d68cb2c6..d0d208d492c 100644 --- a/test/executor/create_index_test.cpp +++ b/test/executor/create_index_test.cpp @@ -115,11 +115,6 @@ TEST_F(CreateIndexTests, CreatingIndex) { traffic_cop.CommitQueryHelper(); txn = txn_manager.BeginTransaction(); - EXPECT_EQ(catalog::Catalog::GetInstance() - ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) - ->GetTableCount(), - 4); - // Inserting a tuple end-to-end traffic_cop.SetTcopTxnState(txn); LOG_INFO("Inserting a tuple..."); diff --git a/test/executor/create_test.cpp b/test/executor/create_test.cpp index b79281b8434..c147c159724 100644 --- a/test/executor/create_test.cpp +++ b/test/executor/create_test.cpp @@ -108,10 +108,6 @@ TEST_F(CreateTests, CreatingTable) { executor.Init(); executor.Execute(); - EXPECT_EQ(4, (int)catalog::Catalog::GetInstance() - ->GetDatabaseObject(DEFAULT_DB_NAME, txn) - ->GetTableObjects() - .size()); txn_manager.CommitTransaction(txn); // free the database just created @@ -152,11 +148,6 @@ TEST_F(CreateTests, CreatingUDFs) { executor.Init(); executor.Execute(); - - EXPECT_EQ(4, (int)catalog::Catalog::GetInstance() - ->GetDatabaseObject(DEFAULT_DB_NAME, txn) - ->GetTableObjects() - .size()); txn_manager.CommitTransaction(txn); // Create statement @@ -234,10 +225,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); - auto catalog = catalog::Catalog::GetInstance(); - catalog->Bootstrap(); - catalog->CreateDatabase(DEFAULT_DB_NAME, txn); + catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); // Insert a table first auto id_column = catalog::Column( @@ -263,10 +251,6 @@ TEST_F(CreateTests, CreatingTrigger) { executor.Init(); executor.Execute(); - EXPECT_EQ(1, (int)catalog::Catalog::GetInstance() - ->GetDatabaseObject(DEFAULT_DB_NAME, txn) - ->GetTableObjects() - .size()); txn_manager.CommitTransaction(txn); // Create statement @@ -314,13 +298,15 @@ TEST_F(CreateTests, CreatingTrigger) { EXPECT_EQ(ExpressionType::VALUE_TUPLE, left->GetExpressionType()); EXPECT_EQ("old", static_cast(left) ->GetTableName()); - EXPECT_EQ("balance", static_cast( - left)->GetColumnName()); + EXPECT_EQ("balance", + static_cast(left) + ->GetColumnName()); EXPECT_EQ(ExpressionType::VALUE_TUPLE, right->GetExpressionType()); EXPECT_EQ("new", static_cast(right) ->GetTableName()); - EXPECT_EQ("balance", static_cast( - right)->GetColumnName()); + EXPECT_EQ("balance", + static_cast(right) + ->GetColumnName()); // type (level, timing, event) auto trigger_type = plan.GetTriggerType(); // level @@ -395,10 +381,6 @@ TEST_F(CreateTests, CreatingTriggerWithoutWhen) { executor.Init(); executor.Execute(); - EXPECT_EQ(1, (int)catalog::Catalog::GetInstance() - ->GetDatabaseObject(DEFAULT_DB_NAME, txn) - ->GetTableObjects() - .size()); txn_manager.CommitTransaction(txn); // Create statement @@ -459,7 +441,9 @@ TEST_F(CreateTests, CreatingTriggerInCatalog) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); - catalog->Bootstrap(); + // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests + // you can only call it once! + // catalog->Bootstrap(); catalog->CreateDatabase(DEFAULT_DB_NAME, txn); // Insert a table first @@ -486,10 +470,6 @@ TEST_F(CreateTests, CreatingTriggerInCatalog) { executor.Init(); executor.Execute(); - EXPECT_EQ(1, (int)catalog::Catalog::GetInstance() - ->GetDatabaseObject(DEFAULT_DB_NAME, txn) - ->GetTableObjects() - .size()); txn_manager.CommitTransaction(txn); // Create statement diff --git a/test/executor/delete_test.cpp b/test/executor/delete_test.cpp index 32ce676b79a..98928ee7e4e 100644 --- a/test/executor/delete_test.cpp +++ b/test/executor/delete_test.cpp @@ -121,10 +121,6 @@ TEST_F(DeleteTests, VariousOperations) { executor::CreateExecutor create_executor(&node, context.get()); create_executor.Init(); create_executor.Execute(); - EXPECT_EQ(4, (int)catalog::Catalog::GetInstance() - ->GetDatabaseObject(DEFAULT_DB_NAME, txn) - ->GetTableObjects() - .size()); LOG_INFO("Table created!"); storage::DataTable *table = catalog::Catalog::GetInstance()->GetTableWithName( diff --git a/test/executor/drop_test.cpp b/test/executor/drop_test.cpp index 2d86f74821c..28005a05a5b 100644 --- a/test/executor/drop_test.cpp +++ b/test/executor/drop_test.cpp @@ -75,7 +75,9 @@ TEST_F(DropTests, DroppingDatabase) { TEST_F(DropTests, DroppingTable) { auto catalog = catalog::Catalog::GetInstance(); - catalog->Bootstrap(); + // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests + // you can only call it once! + // catalog->Bootstrap(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); @@ -105,17 +107,18 @@ TEST_F(DropTests, DroppingTable) { txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); + // NOTE: everytime we create a database, there will be 7 catalog tables inside EXPECT_EQ((int)catalog->GetDatabaseObject(TEST_DB_NAME, txn) ->GetTableObjects() .size(), - 5); + 9); // Now dropping the table using the executor catalog->DropTable(TEST_DB_NAME, "department_table", txn); EXPECT_EQ((int)catalog->GetDatabaseObject(TEST_DB_NAME, txn) ->GetTableObjects() .size(), - 4); + 8); // free the database just created catalog->DropDatabaseWithName(TEST_DB_NAME, txn); @@ -124,7 +127,9 @@ TEST_F(DropTests, DroppingTable) { TEST_F(DropTests, DroppingTrigger) { auto catalog = catalog::Catalog::GetInstance(); - catalog->Bootstrap(); + // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests + // you can only call it once! + // catalog->Bootstrap(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); @@ -208,7 +213,7 @@ TEST_F(DropTests, DroppingTrigger) { // Now dropping the table using the executer txn = txn_manager.BeginTransaction(); catalog->DropTable(TEST_DB_NAME, "department_table", txn); - EXPECT_EQ(3, (int)catalog::Catalog::GetInstance() + EXPECT_EQ(7, (int)catalog::Catalog::GetInstance() ->GetDatabaseObject(TEST_DB_NAME, txn) ->GetTableObjects() .size()); @@ -222,7 +227,9 @@ TEST_F(DropTests, DroppingTrigger) { TEST_F(DropTests, DroppingIndexByName) { auto catalog = catalog::Catalog::GetInstance(); - catalog->Bootstrap(); + // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests + // you can only call it once! + // catalog->Bootstrap(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); diff --git a/test/executor/update_test.cpp b/test/executor/update_test.cpp index 8db4f755276..8d3b1305cbd 100644 --- a/test/executor/update_test.cpp +++ b/test/executor/update_test.cpp @@ -181,8 +181,6 @@ TEST_F(UpdateTests, UpdatingOld) { executor::CreateExecutor create_executor(&node, context.get()); create_executor.Init(); create_executor.Execute(); - EXPECT_EQ(catalog->GetDatabaseWithName(DEFAULT_DB_NAME, txn)->GetTableCount(), - 4); LOG_INFO("Table created!"); diff --git a/test/function/functions_test.cpp b/test/function/functions_test.cpp index ad9a4948529..2153fbb44eb 100644 --- a/test/function/functions_test.cpp +++ b/test/function/functions_test.cpp @@ -31,16 +31,19 @@ class FunctionsTests : public PelotonTest { virtual void SetUp() { PelotonTest::SetUp(); - auto catalog = catalog::Catalog::GetInstance(); - catalog->Bootstrap(); + // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous + // unit tests you can only call it once! + // auto catalog = + // catalog::Catalog::GetInstance(); catalog->Bootstrap(); } }; TEST_F(FunctionsTests, CatalogTest) { auto catalog = catalog::Catalog::GetInstance(); + catalog->Bootstrap(); + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto &pg_language = catalog::LanguageCatalog::GetInstance(); - // Test "internal" language auto txn = txn_manager.BeginTransaction(); auto internal_lang = pg_language.GetLanguageByName("internal", txn); @@ -110,7 +113,6 @@ TEST_F(FunctionsTests, FuncCallTest) { result = {"32"}; TestingSQLUtil::ExecuteSQLQueryAndCheckResult("SELECT ASCII(s) FROM test;", result, false); - TestingSQLUtil::ExecuteSQLQuery( "CREATE OR REPLACE FUNCTION" @@ -118,8 +120,8 @@ TEST_F(FunctionsTests, FuncCallTest) { " BEGIN RETURN e + 1; END; $$ LANGUAGE plpgsql;"); result = {"26"}; - TestingSQLUtil::ExecuteSQLQueryAndCheckResult("SELECT increment(e) FROM test;", - result, false); + TestingSQLUtil::ExecuteSQLQueryAndCheckResult( + "SELECT increment(e) FROM test;", result, false); // free the database just created txn = txn_manager.BeginTransaction(); diff --git a/test/optimizer/old_optimizer_test.cpp b/test/optimizer/old_optimizer_test.cpp index 3033722805a..052fd5b6b64 100644 --- a/test/optimizer/old_optimizer_test.cpp +++ b/test/optimizer/old_optimizer_test.cpp @@ -101,11 +101,6 @@ TEST_F(OldOptimizerTests, UpdateDelWithIndexScanTest) { traffic_cop.CommitQueryHelper(); txn = txn_manager.BeginTransaction(); - EXPECT_EQ(catalog::Catalog::GetInstance() - ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) - ->GetTableCount(), - 4); - // Inserting a tuple end-to-end traffic_cop.SetTcopTxnState(txn); LOG_TRACE("Inserting a tuple..."); diff --git a/test/optimizer/optimizer_test.cpp b/test/optimizer/optimizer_test.cpp index 7e2e6b3a777..398a2ccf6a1 100644 --- a/test/optimizer/optimizer_test.cpp +++ b/test/optimizer/optimizer_test.cpp @@ -118,11 +118,6 @@ TEST_F(OptimizerTests, HashJoinTest) { traffic_cop.CommitQueryHelper(); txn = txn_manager.BeginTransaction(); - EXPECT_EQ(catalog::Catalog::GetInstance() - ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) - ->GetTableCount(), - 4); - traffic_cop.SetTcopTxnState(txn); LOG_INFO("Creating table"); LOG_INFO("Query: CREATE TABLE table_b(bid INT PRIMARY KEY,value INT);"); @@ -153,11 +148,6 @@ TEST_F(OptimizerTests, HashJoinTest) { traffic_cop.CommitQueryHelper(); txn = txn_manager.BeginTransaction(); - EXPECT_EQ(catalog::Catalog::GetInstance() - ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) - ->GetTableCount(), - 5); - // Inserting a tuple to table_a traffic_cop.SetTcopTxnState(txn); LOG_INFO("Inserting a tuple..."); diff --git a/test/planner/plan_util_test.cpp b/test/planner/plan_util_test.cpp index 814c0e194e3..b8afbb7c7f5 100644 --- a/test/planner/plan_util_test.cpp +++ b/test/planner/plan_util_test.cpp @@ -82,7 +82,6 @@ TEST_F(PlanUtilTests, GetAffectedIndexesTest) { // This is also required so that database objects are cached auto db_object = catalog->GetDatabaseObject(TEST_DB_NAME, txn); - EXPECT_EQ(4, static_cast(db_object->GetTableObjects().size())); // Till now, we have a table : id, first_name, last_name // And two indexes on following columns: diff --git a/test/settings/settings_manager_test.cpp b/test/settings/settings_manager_test.cpp index 1a24feb3356..3e5658d6b26 100644 --- a/test/settings/settings_manager_test.cpp +++ b/test/settings/settings_manager_test.cpp @@ -10,12 +10,11 @@ // //===----------------------------------------------------------------------===// - -#include "common/harness.h" -#include "concurrency/transaction_manager_factory.h" #include "settings/settings_manager.h" #include "catalog/catalog.h" #include "catalog/settings_catalog.h" +#include "common/harness.h" +#include "concurrency/transaction_manager_factory.h" namespace peloton { namespace test { @@ -35,28 +34,35 @@ TEST_F(SettingsManagerTests, InitializationTest) { // test port (int) 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()); + int32_t port_default = + atoi(settings_catalog.GetDefaultValue("port", txn).c_str()); txn_manager.CommitTransaction(txn); EXPECT_EQ(port, port_default); // test socket_family (string) txn = txn_manager.BeginTransaction(); - std::string socket_family = settings::SettingsManager::GetString(settings::SettingId::socket_family); - std::string socket_family_default = settings_catalog.GetDefaultValue("socket_family", txn); + std::string socket_family = + settings::SettingsManager::GetString(settings::SettingId::socket_family); + std::string socket_family_default = + settings_catalog.GetDefaultValue("socket_family", txn); txn_manager.CommitTransaction(txn); EXPECT_EQ(socket_family, socket_family_default); // test indextuner (bool) txn = txn_manager.BeginTransaction(); - bool index_tuner = settings::SettingsManager::GetBool(settings::SettingId::index_tuner); - bool index_tuner_default = ("true" == settings_catalog.GetDefaultValue("index_tuner", txn)); + bool index_tuner = + settings::SettingsManager::GetBool(settings::SettingId::index_tuner); + bool index_tuner_default = + ("true" == settings_catalog.GetDefaultValue("index_tuner", txn)); txn_manager.CommitTransaction(txn); EXPECT_EQ(index_tuner, index_tuner_default); } TEST_F(SettingsManagerTests, ModificationTest) { - auto catalog = catalog::Catalog::GetInstance(); - catalog->Bootstrap(); + // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests + // you can only call it once! + // auto catalog = catalog::Catalog::GetInstance(); + // catalog->Bootstrap(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto &config_manager = settings::SettingsManager::GetInstance(); @@ -82,31 +88,38 @@ TEST_F(SettingsManagerTests, ModificationTest) { // modify bool txn = txn_manager.BeginTransaction(); - bool value5 = settings::SettingsManager::GetBool(settings::SettingId::index_tuner); - bool value6 = ("true" == settings_catalog.GetSettingValue("index_tuner", txn)); + bool value5 = + settings::SettingsManager::GetBool(settings::SettingId::index_tuner); + bool value6 = + ("true" == settings_catalog.GetSettingValue("index_tuner", txn)); EXPECT_EQ(value5, value6); txn_manager.CommitTransaction(txn); settings::SettingsManager::SetBool(settings::SettingId::index_tuner, true); txn = txn_manager.BeginTransaction(); - bool value7 = settings::SettingsManager::GetBool(settings::SettingId::index_tuner); - bool value8 = ("true" == settings_catalog.GetSettingValue("index_tuner", txn)); + bool value7 = + settings::SettingsManager::GetBool(settings::SettingId::index_tuner); + bool value8 = + ("true" == settings_catalog.GetSettingValue("index_tuner", txn)); EXPECT_TRUE(value7); EXPECT_EQ(value7, value8); txn_manager.CommitTransaction(txn); // modify string txn = txn_manager.BeginTransaction(); - std::string value9 = settings::SettingsManager::GetString(settings::SettingId::socket_family); + std::string value9 = + settings::SettingsManager::GetString(settings::SettingId::socket_family); std::string value10 = settings_catalog.GetSettingValue("socket_family", txn); EXPECT_EQ(value9, value10); txn_manager.CommitTransaction(txn); - settings::SettingsManager::SetString(settings::SettingId::socket_family, "test"); + settings::SettingsManager::SetString(settings::SettingId::socket_family, + "test"); txn = txn_manager.BeginTransaction(); - std::string value11 = settings::SettingsManager::GetString(settings::SettingId::socket_family); + std::string value11 = + settings::SettingsManager::GetString(settings::SettingId::socket_family); std::string value12 = settings_catalog.GetSettingValue("socket_family", txn); EXPECT_EQ(value11, "test"); EXPECT_EQ(value11, value12); diff --git a/test/sql/decimal_functions_sql_test.cpp b/test/sql/decimal_functions_sql_test.cpp index 35163b3a932..850e075a62c 100644 --- a/test/sql/decimal_functions_sql_test.cpp +++ b/test/sql/decimal_functions_sql_test.cpp @@ -12,371 +12,357 @@ #include -#include "sql/testing_sql_util.h" #include "catalog/catalog.h" #include "common/harness.h" #include "concurrency/transaction_manager_factory.h" +#include "sql/testing_sql_util.h" namespace peloton { namespace test { class DecimalSQLTestsBase : public PelotonTest { - protected: - virtual void SetUp() override { - // Call parent virtual function first - PelotonTest::SetUp(); - CreateDB(); - } - /*** Helper functions **/ - void CreateDB() { - // Create database - auto& txn_manager = concurrency::TransactionManagerFactory::GetInstance(); - auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); - txn_manager.CommitTransaction(txn); - } - - void CreateTableWithCol(std::string coltype) { - // Create Table - auto& txn_manager = concurrency::TransactionManagerFactory::GetInstance(); - auto txn = txn_manager.BeginTransaction(); - std::ostringstream os; - os << "CREATE TABLE foo(id integer, income " << coltype << ");"; - TestingSQLUtil::ExecuteSQLQuery(os.str()); - txn_manager.CommitTransaction(txn); - } - - virtual void TearDown() override { - // Destroy test database - auto& txn_manager = concurrency::TransactionManagerFactory::GetInstance(); - auto txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); - txn_manager.CommitTransaction(txn); - - // Call parent virtual function - PelotonTest::TearDown(); - } -}; - -class DecimalFunctionsSQLTest : public PelotonTest {}; - - TEST_F(DecimalFunctionsSQLTest, FloorTest) { + protected: + virtual void SetUp() override { + // Call parent virtual function first + PelotonTest::SetUp(); + CreateDB(); + } + /*** Helper functions **/ + void CreateDB() { + // Create database auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); - catalog::Catalog::GetInstance()->Bootstrap(); - txn_manager.CommitTransaction(txn); - // Create a t - txn = txn_manager.BeginTransaction(); - - TestingSQLUtil::ExecuteSQLQuery( - "CREATE TABLE foo(id integer, income decimal);"); - // Adding in 2500 random decimal inputs between [-500, 500] - int i; - std::vector inputs; - int lo = -500; - int hi = 500; - int numEntries = 500; - // Setting a seed - std::srand(std::time(0)); - for (i = 0; i < numEntries; i++) { - double num = 0.45 + (std::rand() % (hi - lo)); - inputs.push_back(num); - std::ostringstream os; - os << "insert into foo values(" << i << ", " << num << ");"; - TestingSQLUtil::ExecuteSQLQuery(os.str()); - } - EXPECT_EQ(i, numEntries); - - txn_manager.CommitTransaction(txn); - // Fetch values from the table - std::vector result; - std::vector tuple_descriptor; - std::string error_message; - int rows_affected; - std::string testQuery = "select id, floor(income) from foo;"; - - TestingSQLUtil::ExecuteSQLQuery(testQuery.c_str(), result, tuple_descriptor, - rows_affected, error_message); - for (i = 0; i < numEntries; i++) { - std::string result_id( - TestingSQLUtil::GetResultValueAsString(result, (2 * i))); - std::string result_income( - TestingSQLUtil::GetResultValueAsString(result, (2 * i) + 1)); - int id = std::stoi(result_id); - double income = std::stod(result_income); - EXPECT_EQ(id, i); - EXPECT_DOUBLE_EQ(income, floor(inputs[i])); - } - // free the database just created - txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); txn_manager.CommitTransaction(txn); } - TEST_F(DecimalSQLTestsBase, TinyIntAbsTest) { - CreateTableWithCol("tinyint"); + void CreateTableWithCol(std::string coltype) { + // Create Table auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - // Adding in 200 random decimal inputs between [-127, 127] - int i; - int lo = 0; - int hi = 254; - int numEntries = 200; - - // for checking results - std::string result_query = "select id, abs(income) from foo;"; - std::vector ref_result; - - // Setting a seed - std::srand(std::time(0)); - for (i = 0; i < numEntries; i++) { - int32_t num = (std::rand() % (hi - lo)) - 127; - std::ostringstream os; - os << "insert into foo values(" << i << ", " << num << ");"; - TestingSQLUtil::ExecuteSQLQuery(os.str()); - - // accumulate expected result - std::ostringstream result_string; - result_string << i << "|" << abs(num); - ref_result.push_back(result_string.str()); - } - EXPECT_EQ(i, numEntries); - - // Add an additional entry of NULL - TestingSQLUtil::ExecuteSQLQuery("insert into foo values(0, NULL)"); - ref_result.push_back("0|"); + std::ostringstream os; + os << "CREATE TABLE foo(id integer, income " << coltype << ");"; + TestingSQLUtil::ExecuteSQLQuery(os.str()); txn_manager.CommitTransaction(txn); - - TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query, - ref_result, - true); } - TEST_F(DecimalSQLTestsBase, SmallIntAbsTest) { - CreateTableWithCol("smallint"); + virtual void TearDown() override { + // Destroy test database auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - // Adding in 200 random integer inputs between [-32767, 32767] - int i; - int lo = 0; - int hi = 65534; - int numEntries = 200; - - // for checking results - std::string result_query = "select id, abs(income) from foo;"; - std::vector ref_result; - - // Setting a seed - std::srand(std::time(0)); - for (i = 0; i < numEntries; i++) { - int32_t num = (std::rand() % (hi - lo)) - 32767; - std::ostringstream os; - os << "insert into foo values(" << i << ", " << num << ");"; - TestingSQLUtil::ExecuteSQLQuery(os.str()); - - // accumulate expected result - std::ostringstream result_string; - result_string << i << "|" << abs(num); - ref_result.push_back(result_string.str()); - } - EXPECT_EQ(i, numEntries); - - // Add an additional entry of NULL - TestingSQLUtil::ExecuteSQLQuery("insert into foo values(0, NULL)"); - ref_result.push_back("0|"); + catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); txn_manager.CommitTransaction(txn); - TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query, - ref_result, - true); + // Call parent virtual function + PelotonTest::TearDown(); } +}; - TEST_F(DecimalSQLTestsBase, IntAbsTest) { - CreateTableWithCol("int"); - auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); - auto txn = txn_manager.BeginTransaction(); - // Adding in 200 random integer inputs between [-32767, 32767] - int i; - int lo = 0; - int hi = 65534; - int numEntries = 200; - - // for checking results - std::string result_query = "select id, abs(income) from foo;"; - std::vector ref_result; - - // Setting a seed - std::srand(std::time(0)); - for (i = 0; i < numEntries; i++) { - int32_t num = (std::rand() % (hi - lo)) - 32767; - std::ostringstream os; - os << "insert into foo values(" << i << ", " << num << ");"; - TestingSQLUtil::ExecuteSQLQuery(os.str()); - - // accumulate expected result - std::ostringstream result_string; - result_string << i << "|" << abs(num); - ref_result.push_back(result_string.str()); - } - EXPECT_EQ(i, numEntries); - - // Add an additional entry of NULL - TestingSQLUtil::ExecuteSQLQuery("insert into foo values(0, NULL)"); - ref_result.push_back("0|"); - txn_manager.CommitTransaction(txn); +class DecimalFunctionsSQLTest : public PelotonTest {}; - TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query, - ref_result, - true); +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()->Bootstrap(); + txn_manager.CommitTransaction(txn); + + TestingSQLUtil::ExecuteSQLQuery( + "CREATE TABLE foo(id integer, income decimal);"); + // Adding in 2500 random decimal inputs between [-500, 500] + int i; + std::vector inputs; + int lo = -500; + int hi = 500; + int numEntries = 500; + // Setting a seed + std::srand(std::time(0)); + for (i = 0; i < numEntries; i++) { + double num = 0.45 + (std::rand() % (hi - lo)); + inputs.push_back(num); + std::ostringstream os; + os << "insert into foo values(" << i << ", " << num << ");"; + TestingSQLUtil::ExecuteSQLQuery(os.str()); } - - TEST_F(DecimalSQLTestsBase, BigIntAbsTest) { - CreateTableWithCol("bigint"); - auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); - auto txn = txn_manager.BeginTransaction(); - // Adding in 200 random integer inputs between [-32767, 32767] - int i; - int lo = 0; - int hi = 65534; - int numEntries = 200; - - // for checking results - std::string result_query = "select id, abs(income) from foo;"; - std::vector ref_result; - - // Setting a seed - std::srand(std::time(0)); - for (i = 0; i < numEntries; i++) { - int32_t num = (std::rand() % (hi - lo)) - 32767; - std::ostringstream os; - os << "insert into foo values(" << i << ", " << num << ");"; - TestingSQLUtil::ExecuteSQLQuery(os.str()); - - // accumulate expected result - std::ostringstream result_string; - result_string << i << "|" << abs(num); - ref_result.push_back(result_string.str()); - } - EXPECT_EQ(i, numEntries); - - // Add an additional entry of NULL - TestingSQLUtil::ExecuteSQLQuery("insert into foo values(0, NULL)"); - ref_result.push_back("0|"); - txn_manager.CommitTransaction(txn); - - TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query, - ref_result, - true); + EXPECT_EQ(i, numEntries); + + // Fetch values from the table + std::vector result; + std::vector tuple_descriptor; + std::string error_message; + int rows_affected; + std::string testQuery = "select id, floor(income) from foo;"; + + TestingSQLUtil::ExecuteSQLQuery(testQuery.c_str(), result, tuple_descriptor, + rows_affected, error_message); + for (i = 0; i < numEntries; i++) { + std::string result_id( + TestingSQLUtil::GetResultValueAsString(result, (2 * i))); + std::string result_income( + TestingSQLUtil::GetResultValueAsString(result, (2 * i) + 1)); + int id = std::stoi(result_id); + double income = std::stod(result_income); + EXPECT_EQ(id, i); + EXPECT_DOUBLE_EQ(income, floor(inputs[i])); } - - TEST_F(DecimalSQLTestsBase, DecimalAbsTest) { - CreateTableWithCol("decimal"); - auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); - auto txn = txn_manager.BeginTransaction(); - // Adding in 2500 random decimal inputs between [-500, 500] - int i; - int lo = -500; - int hi = 500; - int numEntries = 500; - - // for checking results - std::string result_query = "select id, abs(income) from foo;"; - std::vector ref_result; - - // Setting a seed - std::srand(std::time(0)); - for (i = 0; i < numEntries; i++) { - double num = 0.45 + (std::rand() % (hi - lo)); - std::ostringstream os; - os << "insert into foo values(" << i << ", " << num << ");"; - TestingSQLUtil::ExecuteSQLQuery(os.str()); - - // accumulate expected result - std::ostringstream result_string; - result_string << i << "|" << fabs(num); - ref_result.push_back(result_string.str()); - } - EXPECT_EQ(i, numEntries); - TestingSQLUtil::ExecuteSQLQuery("insert into foo values(0, NULL)"); - ref_result.push_back("0|"); - txn_manager.CommitTransaction(txn); - - TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query, - ref_result, - true); + // free the database just created + txn = txn_manager.BeginTransaction(); + catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + txn_manager.CommitTransaction(txn); +} + +TEST_F(DecimalSQLTestsBase, TinyIntAbsTest) { + CreateTableWithCol("tinyint"); + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); + auto txn = txn_manager.BeginTransaction(); + // Adding in 200 random decimal inputs between [-127, 127] + int i; + int lo = 0; + int hi = 254; + int numEntries = 200; + + // for checking results + std::string result_query = "select id, abs(income) from foo;"; + std::vector ref_result; + + // Setting a seed + std::srand(std::time(0)); + for (i = 0; i < numEntries; i++) { + int32_t num = (std::rand() % (hi - lo)) - 127; + std::ostringstream os; + os << "insert into foo values(" << i << ", " << num << ");"; + TestingSQLUtil::ExecuteSQLQuery(os.str()); + + // accumulate expected result + std::ostringstream result_string; + result_string << i << "|" << abs(num); + ref_result.push_back(result_string.str()); + } + EXPECT_EQ(i, numEntries); + + // Add an additional entry of NULL + TestingSQLUtil::ExecuteSQLQuery("insert into foo values(0, NULL)"); + ref_result.push_back("0|"); + txn_manager.CommitTransaction(txn); + + TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query, ref_result, true); +} + +TEST_F(DecimalSQLTestsBase, SmallIntAbsTest) { + CreateTableWithCol("smallint"); + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); + auto txn = txn_manager.BeginTransaction(); + // Adding in 200 random integer inputs between [-32767, 32767] + int i; + int lo = 0; + int hi = 65534; + int numEntries = 200; + + // for checking results + std::string result_query = "select id, abs(income) from foo;"; + std::vector ref_result; + + // Setting a seed + std::srand(std::time(0)); + for (i = 0; i < numEntries; i++) { + int32_t num = (std::rand() % (hi - lo)) - 32767; + std::ostringstream os; + os << "insert into foo values(" << i << ", " << num << ");"; + TestingSQLUtil::ExecuteSQLQuery(os.str()); + + // accumulate expected result + std::ostringstream result_string; + result_string << i << "|" << abs(num); + ref_result.push_back(result_string.str()); + } + EXPECT_EQ(i, numEntries); + + // Add an additional entry of NULL + TestingSQLUtil::ExecuteSQLQuery("insert into foo values(0, NULL)"); + ref_result.push_back("0|"); + txn_manager.CommitTransaction(txn); + + TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query, ref_result, true); +} + +TEST_F(DecimalSQLTestsBase, IntAbsTest) { + CreateTableWithCol("int"); + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); + auto txn = txn_manager.BeginTransaction(); + // Adding in 200 random integer inputs between [-32767, 32767] + int i; + int lo = 0; + int hi = 65534; + int numEntries = 200; + + // for checking results + std::string result_query = "select id, abs(income) from foo;"; + std::vector ref_result; + + // Setting a seed + std::srand(std::time(0)); + for (i = 0; i < numEntries; i++) { + int32_t num = (std::rand() % (hi - lo)) - 32767; + std::ostringstream os; + os << "insert into foo values(" << i << ", " << num << ");"; + TestingSQLUtil::ExecuteSQLQuery(os.str()); + + // accumulate expected result + std::ostringstream result_string; + result_string << i << "|" << abs(num); + ref_result.push_back(result_string.str()); + } + EXPECT_EQ(i, numEntries); + + // Add an additional entry of NULL + TestingSQLUtil::ExecuteSQLQuery("insert into foo values(0, NULL)"); + ref_result.push_back("0|"); + txn_manager.CommitTransaction(txn); + + TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query, ref_result, true); +} + +TEST_F(DecimalSQLTestsBase, BigIntAbsTest) { + CreateTableWithCol("bigint"); + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); + auto txn = txn_manager.BeginTransaction(); + // Adding in 200 random integer inputs between [-32767, 32767] + int i; + int lo = 0; + int hi = 65534; + int numEntries = 200; + + // for checking results + std::string result_query = "select id, abs(income) from foo;"; + std::vector ref_result; + + // Setting a seed + std::srand(std::time(0)); + for (i = 0; i < numEntries; i++) { + int32_t num = (std::rand() % (hi - lo)) - 32767; + std::ostringstream os; + os << "insert into foo values(" << i << ", " << num << ");"; + TestingSQLUtil::ExecuteSQLQuery(os.str()); + + // accumulate expected result + std::ostringstream result_string; + result_string << i << "|" << abs(num); + ref_result.push_back(result_string.str()); + } + EXPECT_EQ(i, numEntries); + + // Add an additional entry of NULL + TestingSQLUtil::ExecuteSQLQuery("insert into foo values(0, NULL)"); + ref_result.push_back("0|"); + txn_manager.CommitTransaction(txn); + + TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query, ref_result, true); +} + +TEST_F(DecimalSQLTestsBase, DecimalAbsTest) { + CreateTableWithCol("decimal"); + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); + auto txn = txn_manager.BeginTransaction(); + // Adding in 2500 random decimal inputs between [-500, 500] + int i; + int lo = -500; + int hi = 500; + int numEntries = 500; + + // for checking results + std::string result_query = "select id, abs(income) from foo;"; + std::vector ref_result; + + // Setting a seed + std::srand(std::time(0)); + for (i = 0; i < numEntries; i++) { + double num = 0.45 + (std::rand() % (hi - lo)); + std::ostringstream os; + os << "insert into foo values(" << i << ", " << num << ");"; + TestingSQLUtil::ExecuteSQLQuery(os.str()); + + // accumulate expected result + std::ostringstream result_string; + result_string << i << "|" << fabs(num); + ref_result.push_back(result_string.str()); + } + EXPECT_EQ(i, numEntries); + TestingSQLUtil::ExecuteSQLQuery("insert into foo values(0, NULL)"); + ref_result.push_back("0|"); + txn_manager.CommitTransaction(txn); + + TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query, ref_result, true); +} + +TEST_F(DecimalFunctionsSQLTest, CeilTest) { + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); + auto txn = txn_manager.BeginTransaction(); + catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); + // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests + // you can only call it once! + // catalog::Catalog::GetInstance()->Bootstrap(); + txn_manager.CommitTransaction(txn); + + TestingSQLUtil::ExecuteSQLQuery( + "CREATE TABLE foo(id integer, income decimal);"); + + // Adding in 500 random decimal inputs between [-500, 500] + int i; + std::vector inputs; + int lo = -500; + int hi = 500; + int numEntries = 500; + // Setting a seed + std::srand(std::time(0)); + for (i = 0; i < numEntries; i++) { + double num = 0.45 + (std::rand() % (hi - lo)); + inputs.push_back(num); + std::ostringstream os; + os << "insert into foo values(" << i << ", " << num << ");"; + TestingSQLUtil::ExecuteSQLQuery(os.str()); + } + EXPECT_EQ(i, numEntries); + + // Fetch values from the table + std::vector result; + std::vector tuple_descriptor; + std::string error_message; + int rows_affected; + std::string testQuery = "select id, ceil(income) from foo;"; + + TestingSQLUtil::ExecuteSQLQuery(testQuery.c_str(), result, tuple_descriptor, + rows_affected, error_message); + for (i = 0; i < numEntries; i++) { + std::string result_id( + TestingSQLUtil::GetResultValueAsString(result, (2 * i))); + std::string result_income( + TestingSQLUtil::GetResultValueAsString(result, (2 * i) + 1)); + int id = std::stoi(result_id); + double income = std::stod(result_income); + EXPECT_EQ(id, i); + EXPECT_DOUBLE_EQ(income, ceil(inputs[i])); } - 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()->Bootstrap(); - txn_manager.CommitTransaction(txn); - // Create a t - txn = txn_manager.BeginTransaction(); - - TestingSQLUtil::ExecuteSQLQuery( - "CREATE TABLE foo(id integer, income decimal);"); - - // Adding in 500 random decimal inputs between [-500, 500] - int i; - std::vector inputs; - int lo = -500; - int hi = 500; - int numEntries = 500; - // Setting a seed - std::srand(std::time(0)); - for (i = 0; i < numEntries; i++) { - double num = 0.45 + (std::rand() % (hi - lo)); - inputs.push_back(num); - std::ostringstream os; - os << "insert into foo values(" << i << ", " << num << ");"; - TestingSQLUtil::ExecuteSQLQuery(os.str()); - } - EXPECT_EQ(i, numEntries); - - txn_manager.CommitTransaction(txn); - // Fetch values from the table - std::vector result; - std::vector tuple_descriptor; - std::string error_message; - int rows_affected; - std::string testQuery = "select id, ceil(income) from foo;"; - - TestingSQLUtil::ExecuteSQLQuery(testQuery.c_str(), result, tuple_descriptor, - rows_affected, error_message); - for (i = 0; i < numEntries; i++) { - std::string result_id( - TestingSQLUtil::GetResultValueAsString(result, (2 * i))); - std::string result_income( - TestingSQLUtil::GetResultValueAsString(result, (2 * i) + 1)); - int id = std::stoi(result_id); - double income = std::stod(result_income); - EXPECT_EQ(id, i); - EXPECT_DOUBLE_EQ(income, ceil(inputs[i])); - } - - testQuery = "select id, ceiling(income) from foo;"; - - TestingSQLUtil::ExecuteSQLQuery(testQuery.c_str(), result, tuple_descriptor, - rows_affected, error_message); - for (i = 0; i < numEntries; i++) { - std::string result_id( - TestingSQLUtil::GetResultValueAsString(result, (2 * i))); - std::string result_income( - TestingSQLUtil::GetResultValueAsString(result, (2 * i) + 1)); - int id = std::stoi(result_id); - double income = std::stod(result_income); - EXPECT_EQ(id, i); - EXPECT_DOUBLE_EQ(income, ceil(inputs[i])); - } - - // free the database just created - txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); - txn_manager.CommitTransaction(txn); + testQuery = "select id, ceiling(income) from foo;"; + + TestingSQLUtil::ExecuteSQLQuery(testQuery.c_str(), result, tuple_descriptor, + rows_affected, error_message); + for (i = 0; i < numEntries; i++) { + std::string result_id( + TestingSQLUtil::GetResultValueAsString(result, (2 * i))); + std::string result_income( + TestingSQLUtil::GetResultValueAsString(result, (2 * i) + 1)); + int id = std::stoi(result_id); + double income = std::stod(result_income); + EXPECT_EQ(id, i); + EXPECT_DOUBLE_EQ(income, ceil(inputs[i])); } + // free the database just created + txn = txn_manager.BeginTransaction(); + catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); + txn_manager.CommitTransaction(txn); +} + } // namespace test } // namespace peloton diff --git a/test/sql/timestamp_functions_sql_test.cpp b/test/sql/timestamp_functions_sql_test.cpp index 3dd4f07dbb1..61724b2c53b 100644 --- a/test/sql/timestamp_functions_sql_test.cpp +++ b/test/sql/timestamp_functions_sql_test.cpp @@ -80,19 +80,17 @@ 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()->Bootstrap(); + // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests + // you can only call it once! + // catalog::Catalog::GetInstance()->Bootstrap(); txn_manager.CommitTransaction(txn); - // Create a t - txn = txn_manager.BeginTransaction(); - + // create tale and insert one tuple TestingSQLUtil::ExecuteSQLQuery( "CREATE TABLE foo(id integer, value timestamp);"); // Add in a testing timestamp TestingSQLUtil::ExecuteSQLQuery( "insert into foo values(3, '2016-12-07 13:26:02.123456-05');"); - txn_manager.CommitTransaction(txn); - std::string test_query; std::vector expected; std::vector result; diff --git a/test/sql/type_sql_test.cpp b/test/sql/type_sql_test.cpp index f1e8fcdf3f7..cffd14012b9 100644 --- a/test/sql/type_sql_test.cpp +++ b/test/sql/type_sql_test.cpp @@ -28,7 +28,7 @@ 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()->Bootstrap(); + // catalog::Catalog::GetInstance()->Bootstrap(); txn_manager.CommitTransaction(txn); } @@ -112,8 +112,7 @@ void CheckQueryResult(std::vector result, for (size_t i = 0; i < result.size(); i++) { for (size_t j = 0; j < tuple_descriptor_size; j++) { int idx = i * tuple_descriptor_size + j; - std::string s = - std::string(result[idx].begin(), result[idx].end()); + std::string s = std::string(result[idx].begin(), result[idx].end()); EXPECT_EQ(s, expected[i]); } } diff --git a/test/storage/database_test.cpp b/test/storage/database_test.cpp index d6c35f4af1c..e12e93c2fcd 100644 --- a/test/storage/database_test.cpp +++ b/test/storage/database_test.cpp @@ -62,12 +62,12 @@ TEST_F(DatabaseTests, AddDropTableTest) { int table_oid = data_table->GetOid(); database->AddTable(data_table.get()); - - EXPECT_TRUE(database->GetTableCount() == 4); + // NOTE: everytime we create a database, there will be 7 catalog tables inside + EXPECT_TRUE(database->GetTableCount() == 8); database->DropTableWithOid(table_oid); - EXPECT_TRUE(database->GetTableCount() == 3); + EXPECT_TRUE(database->GetTableCount() == 7); data_table.release(); diff --git a/test/trigger/trigger_test.cpp b/test/trigger/trigger_test.cpp index cd8588b6bb0..4cb13d7c556 100644 --- a/test/trigger/trigger_test.cpp +++ b/test/trigger/trigger_test.cpp @@ -10,16 +10,16 @@ // //===----------------------------------------------------------------------===// +#include "trigger/trigger.h" #include "catalog/catalog.h" -#include "storage/abstract_table.h" #include "common/harness.h" -#include "trigger/trigger.h" +#include "concurrency/transaction_manager_factory.h" #include "executor/executors.h" #include "parser/pg_trigger.h" #include "parser/postgresparser.h" #include "planner/create_plan.h" #include "planner/insert_plan.h" -#include "concurrency/transaction_manager_factory.h" +#include "storage/abstract_table.h" namespace peloton { namespace test { @@ -92,7 +92,7 @@ class TriggerTests : public PelotonTest { insert_node->insert_values.push_back( std::vector>()); - auto& values = insert_node->insert_values.at(0); + auto &values = insert_node->insert_values.at(0); values.push_back(std::unique_ptr( new expression::ConstantValueExpression( @@ -120,7 +120,9 @@ class TriggerTests : public PelotonTest { // Bootstrap auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto parser = parser::PostgresParser::GetInstance(); - catalog::Catalog::GetInstance()->Bootstrap(); + // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous + // tests you can only call it once! + // catalog::Catalog::GetInstance()->Bootstrap(); std::unique_ptr stmt_list( parser.BuildParseTree(query).release()); @@ -225,13 +227,14 @@ TEST_F(TriggerTests, BeforeAndAfterRowInsertTriggers) { // Bootstrap auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto parser = parser::PostgresParser::GetInstance(); - catalog::Catalog::GetInstance()->Bootstrap(); + // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests + // you can only call it once! + // catalog::Catalog::GetInstance()->Bootstrap(); // Create table CreateTableHelper(); // Create statement (before row insert) - std::string query = "CREATE TRIGGER b_r_insert_trigger " "BEFORE INSERT ON accounts " @@ -310,7 +313,9 @@ TEST_F(TriggerTests, AfterStatmentInsertTriggers) { // Bootstrap auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto parser = parser::PostgresParser::GetInstance(); - catalog::Catalog::GetInstance()->Bootstrap(); + // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests + // you can only call it once! + // catalog::Catalog::GetInstance()->Bootstrap(); // Create table CreateTableHelper(); @@ -390,7 +395,9 @@ TEST_F(TriggerTests, OtherTypesTriggers) { // Bootstrap auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto parser = parser::PostgresParser::GetInstance(); - catalog::Catalog::GetInstance()->Bootstrap(); + // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests + // you can only call it once! + // catalog::Catalog::GetInstance()->Bootstrap(); // Create table CreateTableHelper(); @@ -501,5 +508,5 @@ TEST_F(TriggerTests, OtherTypesTriggers) { catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); txn_manager.CommitTransaction(txn); } -} -} +} // namespace test +} // namespace peloton From 3ab195cad62da06a8b6841fd623baceaccca412b Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sun, 8 Apr 2018 21:43:14 -0400 Subject: [PATCH 38/48] fix double initialize --- src/catalog/system_catalogs.cpp | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-) diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index 0c41460b575..7d9d73f5f23 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -70,11 +70,25 @@ void SystemCatalogs::Bootstrap(const std::string &database_name, concurrency::TransactionContext *txn) { LOG_DEBUG("Bootstrapping database: %s", database_name.c_str()); - pg_trigger = new TriggerCatalog(database_name, txn); - // pg_proc = new ProcCatalog(database_name, txn); - pg_table_metrics = new TableMetricsCatalog(database_name, txn); - pg_index_metrics = new IndexMetricsCatalog(database_name, txn); - pg_query_metrics = new QueryMetricsCatalog(database_name, txn); + if (!pg_trigger) { + pg_trigger = new TriggerCatalog(database_name, txn); + } + + // if (!pg_proc) { + // pg_proc = new ProcCatalog(database_name, txn); + // } + + if (!pg_table_metrics) { + pg_table_metrics = new TableMetricsCatalog(database_name, txn); + } + + if (!pg_index_metrics) { + pg_index_metrics = new IndexMetricsCatalog(database_name, txn); + } + + if (!pg_query_metrics) { + pg_query_metrics = new QueryMetricsCatalog(database_name, txn); + } } } // namespace catalog From c1853a20e7cc02c7b9378ecaff7c3ff739d6255a Mon Sep 17 00:00:00 2001 From: mengranwo Date: Fri, 13 Apr 2018 23:12:56 -0400 Subject: [PATCH 39/48] add full functionality of create/drop schema(namespace) --- src/binder/bind_node_visitor.cpp | 14 +- src/binder/binder_context.cpp | 11 +- src/catalog/abstract_catalog.cpp | 26 +- src/catalog/catalog.cpp | 298 ++++++++++++------ src/catalog/catalog_cache.cpp | 53 ++-- src/catalog/column_catalog.cpp | 19 +- src/catalog/column_stats_catalog.cpp | 18 +- src/catalog/database_catalog.cpp | 76 +++-- src/catalog/database_metrics_catalog.cpp | 2 +- src/catalog/index_catalog.cpp | 52 +-- src/catalog/index_metrics_catalog.cpp | 11 +- src/catalog/language_catalog.cpp | 7 +- src/catalog/proc_catalog.cpp | 13 +- src/catalog/query_history_catalog.cpp | 2 +- src/catalog/query_metrics_catalog.cpp | 3 +- src/catalog/schema_catalog.cpp | 129 ++++++++ src/catalog/settings_catalog.cpp | 15 +- src/catalog/system_catalogs.cpp | 7 + src/catalog/table_catalog.cpp | 48 ++- src/catalog/table_metrics_catalog.cpp | 11 +- src/catalog/trigger_catalog.cpp | 53 +--- src/catalog/zone_map_catalog.cpp | 57 ++-- src/common/init.cpp | 6 +- src/common/internal_types.cpp | 10 + ...timestamp_ordering_transaction_manager.cpp | 5 +- src/concurrency/transaction_context.cpp | 15 +- src/executor/create_executor.cpp | 58 ++-- src/executor/drop_executor.cpp | 86 +++-- src/gc/transaction_level_gc_manager.cpp | 31 +- src/include/binder/binder_context.h | 4 +- src/include/catalog/abstract_catalog.h | 3 +- src/include/catalog/catalog.h | 41 ++- src/include/catalog/catalog_cache.h | 2 +- src/include/catalog/catalog_defaults.h | 48 ++- src/include/catalog/column_catalog.h | 2 - src/include/catalog/database_catalog.h | 22 +- src/include/catalog/index_catalog.h | 37 ++- src/include/catalog/index_metrics_catalog.h | 20 +- src/include/catalog/query_metrics_catalog.h | 46 ++- src/include/catalog/schema_catalog.h | 98 ++++++ src/include/catalog/system_catalogs.h | 23 +- src/include/catalog/table_catalog.h | 26 +- src/include/catalog/table_metrics_catalog.h | 20 +- src/include/catalog/trigger_catalog.h | 9 +- src/include/common/internal_types.h | 7 +- src/include/executor/create_executor.h | 15 +- src/include/executor/drop_executor.h | 3 + src/include/parser/analyze_statement.h | 7 + src/include/parser/create_statement.h | 6 +- src/include/parser/delete_statement.h | 2 + src/include/parser/drop_statement.h | 29 +- src/include/parser/insert_statement.h | 4 + src/include/parser/sql_statement.h | 14 +- src/include/parser/table_ref.h | 24 +- src/include/planner/analyze_plan.h | 10 +- src/include/planner/create_plan.h | 29 +- src/include/planner/drop_plan.h | 6 + src/include/planner/plan_util.h | 9 +- src/include/statistics/stats_aggregator.h | 24 +- src/include/storage/database.h | 3 - src/optimizer/optimizer.cpp | 14 +- .../query_to_operator_transformer.cpp | 20 +- src/optimizer/stats/tuple_samples_storage.cpp | 28 +- src/optimizer/util.cpp | 6 +- src/parser/create_statement.cpp | 13 +- src/parser/drop_statement.cpp | 8 +- src/parser/postgresparser.cpp | 84 +++-- src/parser/table_ref.cpp | 1 + src/planner/analyze_plan.cpp | 19 +- src/planner/create_plan.cpp | 116 ++++--- src/planner/drop_plan.cpp | 10 + src/planner/plan_util.cpp | 11 +- src/statistics/stats_aggregator.cpp | 30 +- src/storage/database.cpp | 8 - src/traffic_cop/traffic_cop.cpp | 4 +- src/tuning/index_tuner.cpp | 67 ++-- test/parser/postgresparser_test.cpp | 6 +- 77 files changed, 1370 insertions(+), 804 deletions(-) create mode 100644 src/catalog/schema_catalog.cpp create mode 100644 src/include/catalog/schema_catalog.h diff --git a/src/binder/bind_node_visitor.cpp b/src/binder/bind_node_visitor.cpp index 3c4b23e0f04..a6ffe17b322 100644 --- a/src/binder/bind_node_visitor.cpp +++ b/src/binder/bind_node_visitor.cpp @@ -10,10 +10,10 @@ // //===----------------------------------------------------------------------===// -#include "expression/expression_util.h" #include "binder/bind_node_visitor.h" -#include "expression/star_expression.h" #include "catalog/catalog.h" +#include "expression/expression_util.h" +#include "expression/star_expression.h" #include "type/type_id.h" #include "expression/aggregate_expression.h" @@ -21,8 +21,8 @@ #include "expression/function_expression.h" #include "expression/operator_expression.h" #include "expression/star_expression.h" -#include "expression/tuple_value_expression.h" #include "expression/subquery_expression.h" +#include "expression/tuple_value_expression.h" namespace peloton { namespace binder { @@ -155,8 +155,8 @@ void BindNodeVisitor::Visit(parser::UpdateStatement *node) { void BindNodeVisitor::Visit(parser::DeleteStatement *node) { context_ = std::make_shared(nullptr); node->TryBindDatabaseName(default_database_name_); - context_->AddRegularTable(node->GetDatabaseName(), node->GetTableName(), - node->GetTableName(), txn_); + context_->AddRegularTable(node->GetDatabaseName(), node->GetSchemaName(), + node->GetTableName(), node->GetTableName(), txn_); if (node->expr != nullptr) { node->expr->Accept(this); @@ -174,8 +174,8 @@ void BindNodeVisitor::Visit(parser::CreateStatement *node) { void BindNodeVisitor::Visit(parser::InsertStatement *node) { node->TryBindDatabaseName(default_database_name_); context_ = std::make_shared(nullptr); - context_->AddRegularTable(node->GetDatabaseName(), node->GetTableName(), - node->GetTableName(), txn_); + context_->AddRegularTable(node->GetDatabaseName(), node->GetSchemaName(), + node->GetTableName(), node->GetTableName(), txn_); if (node->select != nullptr) { node->select->Accept(this); } diff --git a/src/binder/binder_context.cpp b/src/binder/binder_context.cpp index f34d2d1886b..0413b488c37 100644 --- a/src/binder/binder_context.cpp +++ b/src/binder/binder_context.cpp @@ -16,8 +16,8 @@ #include "catalog/column_catalog.h" #include "catalog/database_catalog.h" #include "catalog/table_catalog.h" -#include "parser/table_ref.h" #include "expression/tuple_value_expression.h" +#include "parser/table_ref.h" #include "storage/storage_manager.h" namespace peloton { @@ -28,17 +28,18 @@ void BinderContext::AddRegularTable(parser::TableRef *table_ref, concurrency::TransactionContext *txn) { table_ref->TryBindDatabaseName(default_database_name); auto table_alias = table_ref->GetTableAlias(); - AddRegularTable(table_ref->GetDatabaseName(), table_ref->GetTableName(), - table_alias, txn); + AddRegularTable(table_ref->GetDatabaseName(), table_ref->GetSchemaName(), + table_ref->GetTableName(), table_alias, txn); } void BinderContext::AddRegularTable(const std::string db_name, + const std::string schema_name, const std::string table_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, table_name, txn); + auto table_object = catalog::Catalog::GetInstance()->GetTableObject( + db_name, schema_name, table_name, txn); if (regular_table_alias_map_.find(table_alias) != regular_table_alias_map_.end() || diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index d380a4252f8..43c2ea2d2c1 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -47,11 +47,12 @@ AbstractCatalog::AbstractCatalog(oid_t catalog_table_oid, std::string catalog_table_name, catalog::Schema *catalog_table_schema, storage::Database *pg_catalog) { + // set database_oid + database_oid = pg_catalog->GetOid(); // Create catalog_table_ catalog_table_ = storage::TableFactory::GetDataTable( - pg_catalog->GetOid(), catalog_table_oid, catalog_table_schema, - catalog_table_name, DEFAULT_TUPLES_PER_TILEGROUP, true, false, true); - + 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); } @@ -79,16 +80,17 @@ AbstractCatalog::AbstractCatalog(const std::string &catalog_table_ddl, optimizer::Optimizer().BuildPelotonPlanTree(parse_tree_list, txn)); auto catalog_table_schema = create_plan->GetSchema(); auto catalog_table_name = create_plan->GetTableName(); + auto catalog_schema_name = create_plan->GetSchemaName(); auto catalog_database_name = create_plan->GetDatabaseName(); - - // Create catalog table + PL_ASSERT(catalog_schema_name == std::string(CATALOG_SCHEMA_NAME)); + // create catalog table Catalog::GetInstance()->CreateTable( - catalog_database_name, catalog_table_name, + catalog_database_name, catalog_schema_name, catalog_table_name, std::unique_ptr(catalog_table_schema), txn, true); // Get catalog table oid auto catalog_table_object = Catalog::GetInstance()->GetTableObject( - catalog_database_name, catalog_table_name, txn); + catalog_database_name, catalog_schema_name, catalog_table_name, txn); // Set catalog_table_ try { @@ -128,11 +130,11 @@ bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, std::make_shared(catalog_table_, &columns, &values); executor::ExecutionResult this_p_status; - auto on_complete = - [&this_p_status](executor::ExecutionResult p_status, - std::vector &&values UNUSED_ATTRIBUTE) { - this_p_status = p_status; - }; + auto on_complete = [&this_p_status]( + executor::ExecutionResult p_status, + std::vector &&values UNUSED_ATTRIBUTE) { + this_p_status = p_status; + }; executor::PlanExecutor::ExecutePlan(node, txn, params, result_format, on_complete); diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index bb0af07ed39..1fdbbe9e258 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -47,10 +47,10 @@ Catalog *Catalog::GetInstance() { } /* Initialization of catalog, including: - * 1) create pg_catalog database, create catalog tables, add them into - * pg_catalog database, insert columns into pg_attribute + * 1) create peloton database, create catalog tables, add them into + * peloton database, insert columns into pg_attribute * 2) create necessary indexes, insert into pg_index - * 3) insert pg_catalog into pg_database, catalog tables into pg_table + * 3) insert peloton into pg_database, catalog tables into pg_table */ Catalog::Catalog() : pool_(new type::EphemeralPool()) { // Begin transaction for catalog initialization @@ -88,70 +88,96 @@ void Catalog::BootstrapSystemCatalogs(storage::Database *database, auto system_catalogs = catalog_map_[database_oid]; // Create indexes on catalog tables, insert them into pg_index - // note that CreateIndex() from catalog.cpp will create index on storage level - // table and at the same time insert a new index record into pg_index - // TODO: This should be hash index rather than tree index?? (but postgres use - // btree!!) - CreatePrimaryIndex(database_oid, TABLE_CATALOG_OID, txn); - - CreateIndex(database_oid, TABLE_CATALOG_OID, - {TableCatalog::ColumnId::TABLE_NAME}, TABLE_CATALOG_NAME "_skey0", - IndexType::BWTREE, IndexConstraintType::UNIQUE, true, txn, true); - CreateIndex(database_oid, TABLE_CATALOG_OID, - {TableCatalog::ColumnId::DATABASE_OID}, - TABLE_CATALOG_NAME "_skey1", IndexType::BWTREE, - IndexConstraintType::DEFAULT, false, txn, true); - - // actual index already added in column_catalog, index_catalog constructor - // the reason we treat those two catalog tables differently is that indexes - // needs to be built before insert tuples into table + // actual index already added in system_catalogs->GetIndexCatalog()->InsertIndex( COLUMN_CATALOG_PKEY_OID, COLUMN_CATALOG_NAME "_pkey", COLUMN_CATALOG_OID, - IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, true, + 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, IndexType::BWTREE, IndexConstraintType::UNIQUE, true, + 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, IndexType::BWTREE, IndexConstraintType::DEFAULT, - false, {ColumnCatalog::ColumnId::TABLE_OID}, pool_.get(), txn); + 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, - IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, true, - {IndexCatalog::ColumnId::INDEX_OID}, pool_.get(), txn); + 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, - IndexType::BWTREE, IndexConstraintType::UNIQUE, true, + 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, - IndexType::BWTREE, IndexConstraintType::DEFAULT, false, - {IndexCatalog::ColumnId::TABLE_OID}, pool_.get(), txn); + 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, IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, - true, {DatabaseCatalog::ColumnId::DATABASE_OID}, pool_.get(), txn); + 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, IndexType::BWTREE, IndexConstraintType::DEFAULT, - false, {DatabaseCatalog::ColumnId::DATABASE_NAME}, pool_.get(), txn); + 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); + + // 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( + DEFUALT_SCHEMA_OID, DEFUALT_SCHEMA_NAME, pool_.get(), txn); // Insert catalog tables into pg_table + // pg_database is shared across different databases system_catalogs->GetTableCatalog()->InsertTable( - DATABASE_CATALOG_OID, DATABASE_CATALOG_NAME, CATALOG_DATABASE_OID, - pool_.get(), txn); + DATABASE_CATALOG_OID, DATABASE_CATALOG_NAME, CATALOG_SCHEMA_NAME, + CATALOG_DATABASE_OID, pool_.get(), txn); system_catalogs->GetTableCatalog()->InsertTable( - TABLE_CATALOG_OID, TABLE_CATALOG_NAME, database_oid, pool_.get(), txn); + SCHEMA_CATALOG_OID, SCHEMA_CATALOG_NAME, CATALOG_SCHEMA_NAME, + database_oid, pool_.get(), txn); system_catalogs->GetTableCatalog()->InsertTable( - INDEX_CATALOG_OID, INDEX_CATALOG_NAME, database_oid, pool_.get(), txn); + TABLE_CATALOG_OID, TABLE_CATALOG_NAME, CATALOG_SCHEMA_NAME, database_oid, + pool_.get(), txn); + system_catalogs->GetTableCatalog()->InsertTable( + INDEX_CATALOG_OID, INDEX_CATALOG_NAME, CATALOG_SCHEMA_NAME, database_oid, + pool_.get(), txn); system_catalogs->GetTableCatalog()->InsertTable( - COLUMN_CATALOG_OID, COLUMN_CATALOG_NAME, database_oid, pool_.get(), txn); + COLUMN_CATALOG_OID, COLUMN_CATALOG_NAME, CATALOG_SCHEMA_NAME, + database_oid, pool_.get(), txn); } void Catalog::Bootstrap() { @@ -219,14 +245,52 @@ ResultType Catalog::CreateDatabase(const std::string &database_name, return ResultType::SUCCESS; } +/*@brief create schema(namespace) + * @param database_name the database which the namespace belongs to + * @param schema_name name of the schema + * @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) { + 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); + if (database_object == nullptr) + throw CatalogException("Can't find Database " + database_name + + " 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); + if (schema_object != nullptr) + throw CatalogException("Schema(namespace) " + schema_name + + " 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); + + LOG_TRACE("Schema(namespace) %s created. Returning RESULT_SUCCESS.", + schema_name.c_str()); + return ResultType::SUCCESS; +} + /*@brief create table * @param database_name the database which the table belongs to - * @param table_name name of the table to add index on + * @param schema_name name of schema the table belongs to + * @param table_name name of the table * @param schema schema, a.k.a metadata of the table * @param txn TransactionContext * @return TransactionContext ResultType(SUCCESS or FAILURE) */ ResultType Catalog::CreateTable(const std::string &database_name, + const std::string &schema_name, const std::string &table_name, std::unique_ptr schema, concurrency::TransactionContext *txn, @@ -237,17 +301,25 @@ ResultType Catalog::CreateTable(const std::string &database_name, LOG_TRACE("Creating table %s in database %s", table_name.c_str(), database_name.c_str()); - // get database oid from pg_database + // check whether database exists from pg_database auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); if (database_object == nullptr) throw CatalogException("Can't find Database " + database_name + " to create table"); + // check whether namespace exists from pg_namespace + auto schema_object = catalog_map_[database_object->GetDatabaseOid()] + ->GetSchemaCatalog() + ->GetSchemaObject(schema_name, txn); + if (schema_object == nullptr) + throw CatalogException("Can't find namespace " + schema_name + + " to create table"); // get table oid from pg_table - auto table_object = database_object->GetTableObject(table_name); + auto table_object = database_object->GetTableObject(table_name, schema_name); if (table_object != nullptr) - throw CatalogException("Table " + table_name + " already exists"); + throw CatalogException("Table: " + schema_name + "." + table_name + + " already exists"); auto storage_manager = storage::StorageManager::GetInstance(); auto database = @@ -281,7 +353,7 @@ 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, + pg_table->InsertTable(table_oid, table_name, schema_name, database_object->GetDatabaseOid(), pool_.get(), txn); oid_t column_id = 0; for (const auto &column : table->GetSchema()->GetColumns()) { @@ -294,14 +366,15 @@ ResultType Catalog::CreateTable(const std::string &database_name, if (column.IsUnique()) { std::string col_name = column.GetName(); std::string index_name = table->GetName() + "_" + col_name + "_UNIQ"; - CreateIndex(database_name, table_name, {column_id}, index_name, true, - IndexType::BWTREE, txn); + CreateIndex(database_name, schema_name, table_name, {column_id}, + index_name, true, IndexType::BWTREE, txn); 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, txn); + CreatePrimaryIndex(database_object->GetDatabaseOid(), table_oid, schema_name, + txn); return ResultType::SUCCESS; } @@ -310,10 +383,12 @@ ResultType Catalog::CreateTable(const std::string &database_name, * If you want to create index on table outside, call CreateIndex() instead * @param database_oid the database which the indexed table belongs to * @param table_oid oid of the table to add index on + * @param schema_name the schema which the indexed table belongs to * @param txn TransactionContext * @return TransactionContext ResultType(SUCCESS or FAILURE) */ ResultType Catalog::CreatePrimaryIndex(oid_t database_oid, oid_t table_oid, + const std::string &schema_name, concurrency::TransactionContext *txn) { LOG_TRACE("Trying to create primary index for table %d", table_oid); @@ -361,9 +436,9 @@ 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, IndexType::BWTREE, - IndexConstraintType::PRIMARY_KEY, unique_keys, - key_attrs, pool_.get(), txn); + pg_index->InsertIndex(index_oid, index_name, table_oid, schema_name, + IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, + unique_keys, key_attrs, pool_.get(), txn); LOG_TRACE("Successfully created primary key index '%s' for table '%s'", index_name.c_str(), table->GetName().c_str()); @@ -373,6 +448,7 @@ ResultType Catalog::CreatePrimaryIndex(oid_t database_oid, oid_t table_oid, /*@brief create index on table * @param database_name the database which the indexed table belongs to + * @param schema_name the namespace which the indexed table belongs to * @param table_name name of the table to add index on * @param index_attr collection of the indexed attribute(column) name * @param index_name name of the table to add index on @@ -384,6 +460,7 @@ ResultType Catalog::CreatePrimaryIndex(oid_t database_oid, oid_t table_oid, * @return TransactionContext ResultType(SUCCESS or FAILURE) */ ResultType Catalog::CreateIndex(const std::string &database_name, + const std::string &schema_name, const std::string &table_name, const std::vector &key_attrs, const std::string &index_name, bool unique_keys, @@ -404,26 +481,26 @@ ResultType Catalog::CreateIndex(const std::string &database_name, " to create index"); // check if table exists - auto table_object = database_object->GetTableObject(table_name); + auto table_object = database_object->GetTableObject(table_name, schema_name); if (table_object == nullptr) - throw CatalogException("Can't find table " + table_name + - " to create index"); + throw CatalogException("Can't find table " + schema_name + "." + + 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, - index_name, index_type, index_constraint, unique_keys, txn); + schema_name, index_name, index_type, index_constraint, unique_keys, txn); return success; } ResultType Catalog::CreateIndex( oid_t database_oid, oid_t table_oid, const std::vector &key_attrs, - const std::string &index_name, IndexType index_type, - IndexConstraintType index_constraint, bool unique_keys, - concurrency::TransactionContext *txn, bool is_catalog) { + 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) { if (txn == nullptr) throw CatalogException("Do not have transaction to create index " + index_name); @@ -468,9 +545,9 @@ 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, index_type, - index_constraint, unique_keys, key_attrs, pool_.get(), - txn); + pg_index->InsertIndex(index_oid, index_name, table_oid, schema_name, + index_type, index_constraint, unique_keys, key_attrs, + pool_.get(), txn); LOG_TRACE("Successfully add index for table %s contains %d indexes", table->GetName().c_str(), (int)table->GetValidIndexCount()); @@ -523,18 +600,60 @@ ResultType Catalog::DropDatabaseWithOid(oid_t database_oid, return ResultType::SUCCESS; } +/*@brief Drop schema + * 1. drop all the tables within this schema + * 2. delete record within pg_namespace + * @param database_name the database which the dropped table belongs to + * @param schema_name the dropped schema(namespace) name + * @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) { + if (txn == nullptr) + throw CatalogException("Do not have transaction to drop schema " + + schema_name); + + auto database_object = + DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); + if (database_object == nullptr) + throw CatalogException("Drop Schema: database " + database_name + + " 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); + if (schema_object == nullptr) + throw CatalogException("Can't find namespace " + schema_name + " to drop"); + + auto table_objects = database_object->GetTableObjects(schema_name); + for (auto it : table_objects) { + DropTable(it->GetDatabaseOid(), it->GetTableOid(), txn); + } + + // remove record within pg_namespace + pg_namespace->DeleteSchema(schema_name, txn); + return ResultType::SUCCESS; +} + /*@brief Drop table - * 1. drop all the indexes on actual table, and drop index records in pg_index + * 1. drop all the indexes on actual table, and drop index records in + * pg_index * 2. drop all the columns records in pg_attribute * 3. drop table record in pg_table * 4. delete actual table(storage level), cleanup schema, foreign keys, * tile_groups * @param database_name the database which the dropped table belongs to + * @param schema_name the namespace which the dropped table belongs + * to * @param table_name the dropped table name * @param txn TransactionContext * @return TransactionContext ResultType(SUCCESS or FAILURE) */ ResultType Catalog::DropTable(const std::string &database_name, + const std::string &schema_name, const std::string &table_name, concurrency::TransactionContext *txn) { if (txn == nullptr) @@ -549,10 +668,10 @@ ResultType Catalog::DropTable(const std::string &database_name, " does not exist"); // check if table exists - auto table_object = database_object->GetTableObject(table_name); + auto table_object = database_object->GetTableObject(table_name, schema_name); if (table_object == nullptr) - throw CatalogException("Drop Table: table " + table_name + - " does not exist"); + throw CatalogException("Drop Table: table " + schema_name + "." + + table_name + " does not exist"); ResultType result = DropTable(database_object->GetDatabaseOid(), table_object->GetTableOid(), txn); @@ -644,33 +763,6 @@ ResultType Catalog::DropIndex(oid_t database_oid, oid_t index_oid, return ResultType::SUCCESS; } -ResultType Catalog::DropIndex(const std::string &database_name, - const std::string &index_name, - concurrency::TransactionContext *txn) { - if (txn == nullptr) { - throw CatalogException("Do not have transaction to drop index " + - index_name); - } - - auto database_object = - DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn); - if (database_object == nullptr) { - throw CatalogException("Index name " + index_name + " cannot be found"); - } - - auto pg_index = - catalog_map_[database_object->GetDatabaseOid()]->GetIndexCatalog(); - auto index_object = pg_index->GetIndexObject(index_name, txn); - if (index_object == nullptr || database_object == nullptr) { - throw CatalogException("Index name " + index_name + " cannot be found"); - } - - ResultType result = DropIndex(database_object->GetDatabaseOid(), - index_object->GetIndexOid(), txn); - - return result; -} - //===--------------------------------------------------------------------===// // GET WITH NAME - CHECK FROM CATALOG TABLES, USING TRANSACTION //===--------------------------------------------------------------------===// @@ -696,20 +788,20 @@ storage::Database *Catalog::GetDatabaseWithName( return storage_manager->GetDatabaseWithOid(database_object->GetDatabaseOid()); } -/* Check table from pg_table with table_name using txn, +/* 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 *Catalog::GetTableWithName( - const std::string &database_name, const std::string &table_name, - concurrency::TransactionContext *txn) { + const std::string &database_name, const std::string &schema_name, + const std::string &table_name, concurrency::TransactionContext *txn) { PELOTON_ASSERT(txn != nullptr); - LOG_TRACE("Looking for table %s in database %s", table_name.c_str(), database_name.c_str()); - // Check in pg_database, throw exception and abort txn if not exists - auto table_object = GetTableObject(database_name, table_name, txn); + // Check in pg_table, throw exception and abort txn if not exists + auto table_object = + GetTableObject(database_name, schema_name, table_name, txn); // Get table from storage manager auto storage_manager = storage::StorageManager::GetInstance(); @@ -762,13 +854,13 @@ std::shared_ptr Catalog::GetDatabaseObject( return database_object; } -/* Check table from pg_table with table_name using txn, +/* 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 * */ std::shared_ptr Catalog::GetTableObject( - const std::string &database_name, const std::string &table_name, - concurrency::TransactionContext *txn) { + const std::string &database_name, const std::string &schema_name, + const std::string &table_name, concurrency::TransactionContext *txn) { if (txn == nullptr) { throw CatalogException("Do not have transaction to get table object " + database_name + "." + table_name); @@ -786,16 +878,14 @@ std::shared_ptr Catalog::GetTableObject( } // Check in pg_table using txn - auto table_object = database_object->GetTableObject(table_name); + auto table_object = database_object->GetTableObject(table_name, schema_name); if (!table_object || table_object->GetTableOid() == INVALID_OID) { // throw table not found exception and explicitly abort txn - throw CatalogException("Table " + table_name + " is not found"); + throw CatalogException("Table " + schema_name + "." + table_name + + " is not found"); } - // if (single_statement_txn) { - // txn_manager.CommitTransaction(txn); - // } return table_object; } diff --git a/src/catalog/catalog_cache.cpp b/src/catalog/catalog_cache.cpp index b0c2f6505e3..54f0e1a3d13 100644 --- a/src/catalog/catalog_cache.cpp +++ b/src/catalog/catalog_cache.cpp @@ -21,9 +21,9 @@ namespace peloton { namespace catalog { /*@brief insert database catalog object into cache -* @param database_object -* @return false only if database_oid already exists in cache -*/ + * @param database_object + * @return false only if database_oid already exists in cache + */ bool CatalogCache::InsertDatabaseObject( std::shared_ptr database_object) { if (!database_object || database_object->GetDatabaseOid() == INVALID_OID) { @@ -52,9 +52,9 @@ bool CatalogCache::InsertDatabaseObject( } /*@brief evict database catalog object from cache -* @param database_oid -* @return true if database_oid is found and evicted; false if not found -*/ + * @param database_oid + * @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()) { @@ -69,9 +69,9 @@ bool CatalogCache::EvictDatabaseObject(oid_t database_oid) { } /*@brief evict database catalog object from cache -* @param database_name -* @return true if database_name is found and evicted; false if not found -*/ + * @param database_name + * @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()) { @@ -86,9 +86,9 @@ bool CatalogCache::EvictDatabaseObject(const std::string &database_name) { } /*@brief get database catalog object from cache -* @param database_oid -* @return database catalog object; if not found return object with invalid oid -*/ + * @param database_oid + * @return database catalog object; if not found return object with invalid oid + */ std::shared_ptr CatalogCache::GetDatabaseObject( oid_t database_oid) { auto it = database_objects_cache.find(database_oid); @@ -99,9 +99,9 @@ std::shared_ptr CatalogCache::GetDatabaseObject( } /*@brief get database catalog object from cache -* @param database_name -* @return database catalog object; if not found return null -*/ + * @param database_name + * @return database catalog object; if not found return null + */ std::shared_ptr CatalogCache::GetDatabaseObject( const std::string &database_name) { auto it = database_name_cache.find(database_name); @@ -112,9 +112,9 @@ std::shared_ptr CatalogCache::GetDatabaseObject( } /*@brief search table catalog object from all cached database objects -* @param table_oid -* @return table catalog object; if not found return null -*/ + * @param table_oid + * @return table catalog object; if not found return null + */ std::shared_ptr CatalogCache::GetCachedTableObject( oid_t table_oid) { for (auto it = database_objects_cache.begin(); @@ -127,9 +127,9 @@ std::shared_ptr CatalogCache::GetCachedTableObject( } /*@brief search index catalog object from all cached database objects -* @param index_oid -* @return index catalog object; if not found return null -*/ + * @param index_oid + * @return index catalog object; if not found return null + */ std::shared_ptr CatalogCache::GetCachedIndexObject( oid_t index_oid) { for (auto it = database_objects_cache.begin(); @@ -142,15 +142,16 @@ std::shared_ptr CatalogCache::GetCachedIndexObject( } /*@brief search index catalog object from all cached database objects -* @param index_name -* @return index catalog object; if not found return null -*/ + * @param index_name + * @return index catalog object; if not found return null + */ std::shared_ptr CatalogCache::GetCachedIndexObject( - const std::string &index_name) { + const std::string &index_name, const std::string &schema_name) { for (auto it = database_objects_cache.begin(); it != database_objects_cache.end(); ++it) { auto database_object = it->second; - auto index_object = database_object->GetCachedIndexObject(index_name); + auto index_object = + database_object->GetCachedIndexObject(index_name, schema_name); if (index_object) return index_object; } return nullptr; diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index 3fc135ad1c8..f513096fbf2 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -16,8 +16,8 @@ #include "catalog/system_catalogs.h" #include "catalog/table_catalog.h" #include "concurrency/transaction_context.h" -#include "storage/database.h" #include "storage/data_table.h" +#include "storage/database.h" #include "type/value_factory.h" namespace peloton { @@ -49,8 +49,6 @@ ColumnCatalog::ColumnCatalog(storage::Database *pg_catalog, concurrency::TransactionContext *txn) : AbstractCatalog(COLUMN_CATALOG_OID, COLUMN_CATALOG_NAME, InitializeSchema().release(), pg_catalog) { - database_oid = pg_catalog->GetOid(); - // Add indexes for pg_attribute AddIndex({ColumnId::TABLE_OID, ColumnId::COLUMN_NAME}, COLUMN_CATALOG_PKEY_OID, COLUMN_CATALOG_NAME "_pkey", @@ -191,8 +189,9 @@ bool ColumnCatalog::DeleteColumn(oid_t table_oid, type::ValueFactory::GetVarcharValue(column_name, nullptr).Copy()); // delete column from cache - auto pg_table = - Catalog::GetInstance()->GetSystemCatalogs(database_oid)->GetTableCatalog(); + auto pg_table = Catalog::GetInstance() + ->GetSystemCatalogs(database_oid) + ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); table_object->EvictColumnObject(column_name); @@ -212,8 +211,9 @@ bool ColumnCatalog::DeleteColumns(oid_t table_oid, values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); // delete columns from cache - auto pg_table = - Catalog::GetInstance()->GetSystemCatalogs(database_oid)->GetTableCatalog(); + auto pg_table = Catalog::GetInstance() + ->GetSystemCatalogs(database_oid) + ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); table_object->EvictAllColumnObjects(); @@ -224,8 +224,9 @@ const std::unordered_map> ColumnCatalog::GetColumnObjects(oid_t table_oid, concurrency::TransactionContext *txn) { // try get from cache - auto pg_table = - Catalog::GetInstance()->GetSystemCatalogs(database_oid)->GetTableCatalog(); + auto pg_table = Catalog::GetInstance() + ->GetSystemCatalogs(database_oid) + ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); PL_ASSERT(table_object && table_object->GetTableOid() == table_oid); auto column_objects = table_object->GetColumnObjects(true); diff --git a/src/catalog/column_stats_catalog.cpp b/src/catalog/column_stats_catalog.cpp index b44c64a1a7f..bbe94340cdb 100644 --- a/src/catalog/column_stats_catalog.cpp +++ b/src/catalog/column_stats_catalog.cpp @@ -29,7 +29,7 @@ ColumnStatsCatalog *ColumnStatsCatalog::GetInstance( ColumnStatsCatalog::ColumnStatsCatalog(concurrency::TransactionContext *txn) : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." COLUMN_STATS_CATALOG_NAME + "." CATALOG_SCHEMA_NAME "." COLUMN_STATS_CATALOG_NAME " (" "database_id INT NOT NULL, " "table_id INT NOT NULL, " @@ -45,12 +45,14 @@ ColumnStatsCatalog::ColumnStatsCatalog(concurrency::TransactionContext *txn) txn) { // unique key: (database_id, table_id, column_id) Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, COLUMN_STATS_CATALOG_NAME, {0, 1, 2}, - COLUMN_STATS_CATALOG_NAME "_skey0", true, IndexType::BWTREE, txn); + CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, COLUMN_STATS_CATALOG_NAME, + {0, 1, 2}, COLUMN_STATS_CATALOG_NAME "_skey0", true, IndexType::BWTREE, + txn); // non-unique key: (database_id, table_id) Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, COLUMN_STATS_CATALOG_NAME, {0, 1}, - COLUMN_STATS_CATALOG_NAME "_skey1", false, IndexType::BWTREE, txn); + CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, COLUMN_STATS_CATALOG_NAME, + {0, 1}, COLUMN_STATS_CATALOG_NAME "_skey1", false, IndexType::BWTREE, + txn); } ColumnStatsCatalog::~ColumnStatsCatalog() {} @@ -110,9 +112,9 @@ bool ColumnStatsCatalog::InsertColumnStats( return InsertTuple(std::move(tuple), txn); } -bool ColumnStatsCatalog::DeleteColumnStats(oid_t database_id, oid_t table_id, - oid_t column_id, - concurrency::TransactionContext *txn) { +bool ColumnStatsCatalog::DeleteColumnStats( + oid_t database_id, oid_t table_id, oid_t column_id, + concurrency::TransactionContext *txn) { oid_t index_offset = IndexId::SECONDARY_KEY_0; // Secondary key index std::vector values; diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 3f53e2eaa55..b09316c6b55 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -16,8 +16,6 @@ #include "catalog/catalog.h" #include "catalog/system_catalogs.h" -#include "catalog/column_catalog.h" -#include "catalog/table_catalog.h" #include "concurrency/transaction_context.h" #include "executor/logical_tile.h" #include "storage/data_table.h" @@ -55,8 +53,9 @@ bool DatabaseCatalogObject::InsertTableObject( return false; } - if (table_name_cache.find(table_object->GetTableName()) != - table_name_cache.end()) { + std::string key = + table_object->GetSchemaName() + "." + table_object->GetTableName(); + if (table_name_cache.find(key) != table_name_cache.end()) { LOG_DEBUG("Table %s already exists in cache!", table_object->GetTableName().c_str()); return false; @@ -64,8 +63,7 @@ bool DatabaseCatalogObject::InsertTableObject( table_objects_cache.insert( std::make_pair(table_object->GetTableOid(), table_object)); - table_name_cache.insert( - std::make_pair(table_object->GetTableName(), table_object)); + table_name_cache.insert(std::make_pair(key, table_object)); return true; } @@ -83,7 +81,10 @@ bool DatabaseCatalogObject::EvictTableObject(oid_t table_oid) { auto table_object = it->second; PELOTON_ASSERT(table_object); table_objects_cache.erase(it); - table_name_cache.erase(table_object->GetTableName()); + // erase from table name cache + std::string key = + table_object->GetSchemaName() + "." + table_object->GetTableName(); + table_name_cache.erase(key); return true; } @@ -91,11 +92,13 @@ 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) { +bool DatabaseCatalogObject::EvictTableObject(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(table_name); + auto it = table_name_cache.find(key); if (it == table_name_cache.end()) { - return false; // table oid not found in cache + return false; // table name not found in cache } auto table_object = it->second; @@ -136,14 +139,19 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( /* @brief Get table catalog object from cache (cached_only == true), or all the way from storage (cached_only == false) - * @param table_oid table oid of the requested table catalog object + * @param table_name table name of the requested table catalog object + * @param schema_name schema name of the requested table catalog object * @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( - const std::string &table_name, bool cached_only) { - auto it = table_name_cache.find(table_name); - if (it != table_name_cache.end()) return it->second; + 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()) { + return it->second; + } if (cached_only) { // cache miss return empty object @@ -153,10 +161,37 @@ std::shared_ptr DatabaseCatalogObject::GetTableObject( auto pg_table = Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); - return pg_table->GetTableObject(table_name, txn); + return pg_table->GetTableObject(table_name, schema_name, txn); } } +/*@brief Get table catalog object from cache (cached_only == true), + or all the way from storage (cached_only == false) + * @param schema_name + * @return table catalog objects + */ +std::vector> +DatabaseCatalogObject::GetTableObjects(const std::string &schema_name) { + // read directly from pg_table + if (!valid_table_objects) { + auto pg_table = Catalog::GetInstance() + ->GetSystemCatalogs(database_oid) + ->GetTableCatalog(); + // insert every table object into cache + pg_table->GetTableObjects(txn); + } + // make sure to check IsValidTableObjects() before getting table objects + PL_ASSERT(valid_table_objects); + std::vector> result; + for (auto it : table_objects_cache) { + if (it.second->GetSchemaName() == schema_name) { + result.push_back(it.second); + } + } + + return result; +} + /* @brief Get table catalog object from cache (cached_only == true), or all the way from storage (cached_only == false) * @param cached_only if cached only, return nullptr on a cache miss @@ -169,7 +204,7 @@ DatabaseCatalogObject::GetTableObjects(bool cached_only) { auto pg_table = Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); - return pg_table->GetTableObjects(database_oid, txn); + return pg_table->GetTableObjects(txn); } // make sure to check IsValidTableObjects() before getting table objects PELOTON_ASSERT(valid_table_objects); @@ -196,12 +231,15 @@ std::shared_ptr DatabaseCatalogObject::GetCachedIndexObject( * @return index catalog object; if not found return null */ std::shared_ptr DatabaseCatalogObject::GetCachedIndexObject( - const std::string &index_name) { + const std::string &index_name, const std::string &schema_name) { for (auto it = table_objects_cache.begin(); it != table_objects_cache.end(); ++it) { auto table_object = it->second; - auto index_object = table_object->GetIndexObject(index_name, true); - if (index_object) return index_object; + if (table_object != nullptr && + table_object->GetSchemaName() == schema_name) { + auto index_object = table_object->GetIndexObject(index_name, true); + if (index_object) return index_object; + } } return nullptr; } diff --git a/src/catalog/database_metrics_catalog.cpp b/src/catalog/database_metrics_catalog.cpp index 68133719e0d..4fb04fbbb88 100644 --- a/src/catalog/database_metrics_catalog.cpp +++ b/src/catalog/database_metrics_catalog.cpp @@ -28,7 +28,7 @@ DatabaseMetricsCatalog *DatabaseMetricsCatalog::GetInstance( DatabaseMetricsCatalog::DatabaseMetricsCatalog( concurrency::TransactionContext *txn) : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." DATABASE_METRICS_CATALOG_NAME + "." CATALOG_SCHEMA_NAME "." DATABASE_METRICS_CATALOG_NAME " (" "database_oid INT NOT NULL, " "txn_committed INT NOT NULL, " diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index 5dfbb07552a..162c617e554 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -16,12 +16,10 @@ #include "catalog/catalog.h" #include "catalog/system_catalogs.h" -#include "catalog/column_catalog.h" -#include "catalog/table_catalog.h" #include "concurrency/transaction_context.h" #include "executor/logical_tile.h" -#include "storage/database.h" #include "storage/data_table.h" +#include "storage/database.h" #include "storage/tuple.h" #include "type/value_factory.h" @@ -35,6 +33,8 @@ IndexCatalogObject::IndexCatalogObject(executor::LogicalTile *tile, int tupleId) .ToString()), table_oid(tile->GetValue(tupleId, IndexCatalog::ColumnId::TABLE_OID) .GetAs()), + schema_name(tile->GetValue(tupleId, IndexCatalog::ColumnId::SCHEMA_NAME) + .ToString()), index_type(tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEX_TYPE) .GetAs()), index_constraint( @@ -59,12 +59,10 @@ IndexCatalog::IndexCatalog( UNUSED_ATTRIBUTE concurrency::TransactionContext *txn) : AbstractCatalog(INDEX_CATALOG_OID, INDEX_CATALOG_NAME, InitializeSchema().release(), pg_catalog) { - database_oid = pg_catalog->GetOid(); - // Add indexes for pg_index AddIndex({0}, INDEX_CATALOG_PKEY_OID, INDEX_CATALOG_NAME "_pkey", IndexConstraintType::PRIMARY_KEY); - AddIndex({1}, INDEX_CATALOG_SKEY0_OID, INDEX_CATALOG_NAME "_skey0", + AddIndex({1, 3}, INDEX_CATALOG_SKEY0_OID, INDEX_CATALOG_NAME "_skey0", IndexConstraintType::UNIQUE); AddIndex({2}, INDEX_CATALOG_SKEY1_OID, INDEX_CATALOG_NAME "_skey1", IndexConstraintType::DEFAULT); @@ -98,6 +96,11 @@ std::unique_ptr IndexCatalog::InitializeSchema() { table_id_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); + schema_name_column.AddConstraint( + catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); + auto index_type_column = catalog::Column( type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER), "index_type", true); @@ -121,13 +124,15 @@ std::unique_ptr IndexCatalog::InitializeSchema() { indexed_attributes_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); std::unique_ptr index_schema(new catalog::Schema( - {index_id_column, index_name_column, table_id_column, index_type_column, - index_constraint_column, unique_keys, indexed_attributes_column})); + {index_id_column, index_name_column, table_id_column, schema_name_column, + index_type_column, index_constraint_column, unique_keys, + indexed_attributes_column})); return index_schema; } bool IndexCatalog::InsertIndex(oid_t index_oid, const std::string &index_name, - oid_t table_oid, IndexType index_type, + oid_t table_oid, const std::string &schema_name, + IndexType index_type, IndexConstraintType index_constraint, bool unique_keys, std::vector indekeys, type::AbstractPool *pool, @@ -139,22 +144,24 @@ bool IndexCatalog::InsertIndex(oid_t index_oid, const std::string &index_name, auto val0 = type::ValueFactory::GetIntegerValue(index_oid); auto val1 = type::ValueFactory::GetVarcharValue(index_name, nullptr); auto val2 = type::ValueFactory::GetIntegerValue(table_oid); - auto val3 = type::ValueFactory::GetIntegerValue(static_cast(index_type)); - auto val4 = + auto val3 = type::ValueFactory::GetVarcharValue(schema_name, nullptr); + auto val4 = type::ValueFactory::GetIntegerValue(static_cast(index_type)); + auto val5 = type::ValueFactory::GetIntegerValue(static_cast(index_constraint)); - auto val5 = type::ValueFactory::GetBooleanValue(unique_keys); + auto val6 = type::ValueFactory::GetBooleanValue(unique_keys); std::stringstream os; for (oid_t indkey : indekeys) os << std::to_string(indkey) << " "; - auto val6 = type::ValueFactory::GetVarcharValue(os.str(), nullptr); + auto val7 = type::ValueFactory::GetVarcharValue(os.str(), nullptr); tuple->SetValue(IndexCatalog::ColumnId::INDEX_OID, val0, pool); tuple->SetValue(IndexCatalog::ColumnId::INDEX_NAME, val1, pool); tuple->SetValue(IndexCatalog::ColumnId::TABLE_OID, val2, pool); - tuple->SetValue(IndexCatalog::ColumnId::INDEX_TYPE, val3, pool); - tuple->SetValue(IndexCatalog::ColumnId::INDEX_CONSTRAINT, val4, pool); - tuple->SetValue(IndexCatalog::ColumnId::UNIQUE_KEYS, val5, pool); - tuple->SetValue(IndexCatalog::ColumnId::INDEXED_ATTRIBUTES, val6, pool); + tuple->SetValue(IndexCatalog::ColumnId::SCHEMA_NAME, val3, pool); + tuple->SetValue(IndexCatalog::ColumnId::INDEX_TYPE, val4, pool); + tuple->SetValue(IndexCatalog::ColumnId::INDEX_CONSTRAINT, val5, pool); + tuple->SetValue(IndexCatalog::ColumnId::UNIQUE_KEYS, val6, pool); + tuple->SetValue(IndexCatalog::ColumnId::INDEXED_ATTRIBUTES, val7, pool); // Insert the tuple return InsertTuple(std::move(tuple), txn); @@ -217,22 +224,27 @@ std::shared_ptr IndexCatalog::GetIndexObject( } std::shared_ptr IndexCatalog::GetIndexObject( - const std::string &index_name, concurrency::TransactionContext *txn) { + const std::string &index_name, const std::string &schema_name, + concurrency::TransactionContext *txn) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } // try get from cache - auto index_object = txn->catalog_cache.GetCachedIndexObject(index_name); + auto index_object = + txn->catalog_cache.GetCachedIndexObject(index_name, schema_name); if (index_object) { return index_object; } // cache miss, get from pg_index std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::SKEY_INDEX_NAME; // Index of index_name + oid_t index_offset = + IndexId::SKEY_INDEX_NAME; // Index of index_name & schema_name std::vector values; values.push_back( type::ValueFactory::GetVarcharValue(index_name, nullptr).Copy()); + values.push_back( + type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); auto result_tiles = GetResultWithIndexScan(column_ids, index_offset, values, txn); diff --git a/src/catalog/index_metrics_catalog.cpp b/src/catalog/index_metrics_catalog.cpp index 6e724652d78..e744765ef96 100644 --- a/src/catalog/index_metrics_catalog.cpp +++ b/src/catalog/index_metrics_catalog.cpp @@ -22,9 +22,8 @@ namespace catalog { IndexMetricsCatalog::IndexMetricsCatalog(const std::string &database_name, concurrency::TransactionContext *txn) : AbstractCatalog("CREATE TABLE " + database_name + - "." INDEX_METRICS_CATALOG_NAME + "." CATALOG_SCHEMA_NAME "." INDEX_METRICS_CATALOG_NAME " (" - "database_oid INT NOT NULL, " "table_oid INT NOT NULL, " "index_oid INT NOT NULL, " "reads INT NOT NULL, " @@ -38,13 +37,12 @@ IndexMetricsCatalog::IndexMetricsCatalog(const std::string &database_name, IndexMetricsCatalog::~IndexMetricsCatalog() {} bool IndexMetricsCatalog::InsertIndexMetrics( - oid_t database_oid, 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) { + 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) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); - auto val0 = type::ValueFactory::GetIntegerValue(database_oid); auto val1 = type::ValueFactory::GetIntegerValue(table_oid); auto val2 = type::ValueFactory::GetIntegerValue(index_oid); auto val3 = type::ValueFactory::GetIntegerValue(reads); @@ -52,7 +50,6 @@ bool IndexMetricsCatalog::InsertIndexMetrics( auto val5 = type::ValueFactory::GetIntegerValue(inserts); auto val6 = type::ValueFactory::GetIntegerValue(time_stamp); - tuple->SetValue(ColumnId::DATABASE_OID, val0, pool); tuple->SetValue(ColumnId::TABLE_OID, val1, pool); tuple->SetValue(ColumnId::INDEX_OID, val2, pool); tuple->SetValue(ColumnId::READS, val3, pool); diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index ba6e0c360f4..ddcceb6d89d 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -24,7 +24,8 @@ LanguageCatalogObject::LanguageCatalogObject(executor::LogicalTile *tuple) : lang_oid_(tuple->GetValue(0, 0).GetAs()), lang_name_(tuple->GetValue(0, 1).GetAs()) {} -LanguageCatalog &LanguageCatalog::GetInstance(concurrency::TransactionContext *txn) { +LanguageCatalog &LanguageCatalog::GetInstance( + concurrency::TransactionContext *txn) { static LanguageCatalog language_catalog{txn}; return language_catalog; } @@ -33,13 +34,13 @@ LanguageCatalog::~LanguageCatalog(){}; LanguageCatalog::LanguageCatalog(concurrency::TransactionContext *txn) : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." LANGUAGE_CATALOG_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, LANGUAGE_CATALOG_NAME, {1}, + CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, LANGUAGE_CATALOG_NAME, {1}, LANGUAGE_CATALOG_NAME "_skey0", false, IndexType::BWTREE, txn); } diff --git a/src/catalog/proc_catalog.cpp b/src/catalog/proc_catalog.cpp index 217c8b7fedb..6da75db67fc 100644 --- a/src/catalog/proc_catalog.cpp +++ b/src/catalog/proc_catalog.cpp @@ -46,7 +46,7 @@ ProcCatalog::~ProcCatalog(){}; ProcCatalog::ProcCatalog(concurrency::TransactionContext *txn) : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." PROC_CATALOG_NAME + "." CATALOG_SCHEMA_NAME "." PROC_CATALOG_NAME " (" "proc_oid INT NOT NULL PRIMARY KEY, " "proname VARCHAR NOT NULL, " @@ -55,9 +55,9 @@ ProcCatalog::ProcCatalog(concurrency::TransactionContext *txn) "prolang INT NOT NULL, " "prosrc VARCHAR NOT NULL);", txn) { - Catalog::GetInstance()->CreateIndex(CATALOG_DATABASE_NAME, PROC_CATALOG_NAME, - {1, 3}, PROC_CATALOG_NAME "_skey0", false, - IndexType::BWTREE, txn); + Catalog::GetInstance()->CreateIndex( + CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, PROC_CATALOG_NAME, {1, 3}, + PROC_CATALOG_NAME "_skey0", false, IndexType::BWTREE, txn); } bool ProcCatalog::InsertProc(const std::string &proname, @@ -117,8 +117,9 @@ std::unique_ptr ProcCatalog::GetProcByName( oid_t index_offset = IndexId::SECONDARY_KEY_0; std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(proc_name).Copy()); - values.push_back(type::ValueFactory::GetVarcharValue( - TypeIdArrayToString(proc_arg_types)).Copy()); + values.push_back( + type::ValueFactory::GetVarcharValue(TypeIdArrayToString(proc_arg_types)) + .Copy()); auto result_tiles = GetResultWithIndexScan(column_ids, index_offset, values, txn); diff --git a/src/catalog/query_history_catalog.cpp b/src/catalog/query_history_catalog.cpp index fa3868dfab1..4433197ba28 100644 --- a/src/catalog/query_history_catalog.cpp +++ b/src/catalog/query_history_catalog.cpp @@ -27,7 +27,7 @@ QueryHistoryCatalog &QueryHistoryCatalog::GetInstance( QueryHistoryCatalog::QueryHistoryCatalog(concurrency::TransactionContext *txn) : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." QUERY_HISTORY_CATALOG_NAME + "." CATALOG_SCHEMA_NAME "." QUERY_HISTORY_CATALOG_NAME " (" "query_string VARCHAR NOT NULL, " "fingerprint VARCHAR NOT NULL, " diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 95b642b0a84..9f2e8b0f737 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -23,10 +23,9 @@ namespace catalog { QueryMetricsCatalog::QueryMetricsCatalog(const std::string &database_name, concurrency::TransactionContext *txn) : AbstractCatalog("CREATE TABLE " + database_name + - "." QUERY_METRICS_CATALOG_NAME + "." CATALOG_SCHEMA_NAME "." QUERY_METRICS_CATALOG_NAME " (" "query_name VARCHAR NOT NULL PRIMARY KEY, " - "database_oid INT NOT NULL, " "num_params INT NOT NULL, " "param_types VARBINARY, " "param_formats VARBINARY, " diff --git a/src/catalog/schema_catalog.cpp b/src/catalog/schema_catalog.cpp new file mode 100644 index 00000000000..4761bb0e776 --- /dev/null +++ b/src/catalog/schema_catalog.cpp @@ -0,0 +1,129 @@ +//===----------------------------------------------------------------------===// +// +// Peloton +// +// schema_catalog.cpp +// +// Identification: src/catalog/schema_catalog.cpp +// +// Copyright (c) 2015-17, Carnegie Mellon University Index Group +// +//===----------------------------------------------------------------------===// + +#include "catalog/schema_catalog.h" + +#include "catalog/catalog.h" +#include "catalog/system_catalogs.h" +#include "concurrency/transaction_context.h" +#include "executor/logical_tile.h" +#include "storage/data_table.h" +#include "storage/database.h" +#include "storage/tuple.h" +#include "type/value_factory.h" + +namespace peloton { +namespace catalog { + +SchemaCatalogObject::SchemaCatalogObject(executor::LogicalTile *tile, + concurrency::TransactionContext *txn) + : schema_oid(tile->GetValue(0, SchemaCatalog::ColumnId::SCHEMA_OID) + .GetAs()), + 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) { + // Add indexes for pg_namespace + AddIndex({0}, SCHEMA_CATALOG_PKEY_OID, SCHEMA_CATALOG_NAME "_pkey", + IndexConstraintType::PRIMARY_KEY); + AddIndex({1}, SCHEMA_CATALOG_SKEY0_OID, SCHEMA_CATALOG_NAME "_skey0", + IndexConstraintType::UNIQUE); +} + +SchemaCatalog::~SchemaCatalog() {} + +/*@brief private function for initialize schema of pg_namespace + * @return unqiue pointer to schema + */ +std::unique_ptr SchemaCatalog::InitializeSchema() { + const std::string not_null_constraint_name = "not_null"; + const std::string primary_key_constraint_name = "primary_key"; + + auto schema_id_column = catalog::Column( + type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER), + "schema_oid", true); + schema_id_column.AddConstraint(catalog::Constraint( + ConstraintType::PRIMARY, primary_key_constraint_name)); + schema_id_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); + schema_name_column.AddConstraint( + catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); + + std::unique_ptr schema( + new catalog::Schema({schema_id_column, schema_name_column})); + return schema; +} + +bool SchemaCatalog::InsertSchema(oid_t schema_oid, + const std::string &schema_name, + type::AbstractPool *pool, + concurrency::TransactionContext *txn) { + // Create the tuple first + std::unique_ptr tuple( + new storage::Tuple(catalog_table_->GetSchema(), true)); + + auto val0 = type::ValueFactory::GetIntegerValue(schema_oid); + auto val1 = type::ValueFactory::GetVarcharValue(schema_name, nullptr); + + tuple->SetValue(SchemaCatalog::ColumnId::SCHEMA_OID, val0, pool); + tuple->SetValue(SchemaCatalog::ColumnId::SCHEMA_NAME, val1, pool); + + // Insert the tuple + return InsertTuple(std::move(tuple), txn); +} + +bool SchemaCatalog::DeleteSchema(const std::string &schema_name, + concurrency::TransactionContext *txn) { + 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); +} + +std::shared_ptr SchemaCatalog::GetSchemaObject( + const std::string &schema_name, concurrency::TransactionContext *txn) { + if (txn == nullptr) { + throw CatalogException("Transaction is invalid!"); + } + // get from pg_namespace, index scan + 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); + + if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { + auto schema_object = + std::make_shared((*result_tiles)[0].get(), txn); + // TODO: we don't have cache for schema object right now + return schema_object; + } + + // return empty object if not found + return nullptr; +} + +} // namespace catalog +} // namespace peloton diff --git a/src/catalog/settings_catalog.cpp b/src/catalog/settings_catalog.cpp index 508dea6d278..bcdc518af24 100644 --- a/src/catalog/settings_catalog.cpp +++ b/src/catalog/settings_catalog.cpp @@ -21,14 +21,15 @@ namespace peloton { namespace catalog { -SettingsCatalog &SettingsCatalog::GetInstance(concurrency::TransactionContext *txn) { +SettingsCatalog &SettingsCatalog::GetInstance( + concurrency::TransactionContext *txn) { static SettingsCatalog settings_catalog{txn}; return settings_catalog; } SettingsCatalog::SettingsCatalog(concurrency::TransactionContext *txn) : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." SETTINGS_CATALOG_NAME + "." CATALOG_SCHEMA_NAME "." SETTINGS_CATALOG_NAME " (" "name VARCHAR NOT NULL, " "value VARCHAR NOT NULL, " @@ -42,7 +43,7 @@ SettingsCatalog::SettingsCatalog(concurrency::TransactionContext *txn) txn) { // Add secondary index here if necessary Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, SETTINGS_CATALOG_NAME, {0}, + CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, SETTINGS_CATALOG_NAME, {0}, SETTINGS_CATALOG_NAME "_skey0", false, IndexType::BWTREE, txn); } @@ -92,8 +93,8 @@ bool SettingsCatalog::DeleteSetting(const std::string &name, return DeleteWithIndexScan(index_offset, values, txn); } -std::string SettingsCatalog::GetSettingValue(const std::string &name, - concurrency::TransactionContext *txn) { +std::string SettingsCatalog::GetSettingValue( + const std::string &name, concurrency::TransactionContext *txn) { std::vector column_ids({static_cast(ColumnId::VALUE)}); oid_t index_offset = static_cast(IndexId::SECONDARY_KEY_0); std::vector values; @@ -113,8 +114,8 @@ std::string SettingsCatalog::GetSettingValue(const std::string &name, return config_value; } -std::string SettingsCatalog::GetDefaultValue(const std::string &name, - concurrency::TransactionContext *txn) { +std::string SettingsCatalog::GetDefaultValue( + const std::string &name, concurrency::TransactionContext *txn) { std::vector column_ids({static_cast(ColumnId::VALUE)}); oid_t index_offset = static_cast(IndexId::SECONDARY_KEY_0); std::vector values; diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index 7d9d73f5f23..17966290fa5 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -30,13 +30,16 @@ SystemCatalogs::SystemCatalogs(storage::Database *database, 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); // TODO: can we move this to BootstrapSystemCatalogs()? + // insert column information into pg_attribute std::vector> shared_tables = { {CATALOG_DATABASE_OID, DATABASE_CATALOG_OID}, {database_oid, TABLE_CATALOG_OID}, + {database_oid, SCHEMA_CATALOG_OID}, {database_oid, INDEX_CATALOG_OID}}; for (int i = 0; i < (int)shared_tables.size(); i++) { @@ -59,6 +62,7 @@ SystemCatalogs::~SystemCatalogs() { delete pg_index; delete pg_table; delete pg_attribute; + delete pg_namespace; if (pg_trigger) delete pg_trigger; // if (pg_proc) delete pg_proc; if (pg_table_metrics) delete pg_table_metrics; @@ -66,6 +70,9 @@ SystemCatalogs::~SystemCatalogs() { if (pg_query_metrics) delete pg_query_metrics; } +/* + * @brief using sql create statement to create secondary catalog tables + */ void SystemCatalogs::Bootstrap(const std::string &database_name, concurrency::TransactionContext *txn) { LOG_DEBUG("Bootstrapping database: %s", database_name.c_str()); diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 0a66d7457e7..096a1cf41f4 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -34,6 +34,8 @@ TableCatalogObject::TableCatalogObject(executor::LogicalTile *tile, .GetAs()), table_name(tile->GetValue(tupleId, TableCatalog::ColumnId::TABLE_NAME) .ToString()), + schema_name(tile->GetValue(tupleId, TableCatalog::ColumnId::SCHEMA_NAME) + .ToString()), database_oid(tile->GetValue(tupleId, TableCatalog::ColumnId::DATABASE_OID) .GetAs()), version_id(tile->GetValue(tupleId, TableCatalog::ColumnId::VERSION_ID) @@ -315,11 +317,17 @@ std::shared_ptr TableCatalogObject::GetColumnObject( } TableCatalog::TableCatalog( - storage::Database *pg_catalog, UNUSED_ATTRIBUTE type::AbstractPool *pool, + storage::Database *database, UNUSED_ATTRIBUTE type::AbstractPool *pool, UNUSED_ATTRIBUTE concurrency::TransactionContext *txn) : AbstractCatalog(TABLE_CATALOG_OID, TABLE_CATALOG_NAME, - InitializeSchema().release(), pg_catalog) { - database_oid = pg_catalog->GetOid(); + InitializeSchema().release(), database) { + // Add indexes for pg_namespace + AddIndex({0}, TABLE_CATALOG_PKEY_OID, TABLE_CATALOG_NAME "_pkey", + IndexConstraintType::PRIMARY_KEY); + AddIndex({1, 2}, TABLE_CATALOG_SKEY0_OID, TABLE_CATALOG_NAME "_skey0", + IndexConstraintType::UNIQUE); + AddIndex({3}, TABLE_CATALOG_SKEY1_OID, TABLE_CATALOG_NAME "_skey1", + IndexConstraintType::DEFAULT); } TableCatalog::~TableCatalog() {} @@ -344,6 +352,11 @@ std::unique_ptr TableCatalog::InitializeSchema() { 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); + schema_name_column.AddConstraint( + catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); + auto database_id_column = catalog::Column( type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER), "database_oid", true); @@ -356,9 +369,9 @@ std::unique_ptr TableCatalog::InitializeSchema() { version_id_column.AddConstraint( catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name)); - std::unique_ptr table_catalog_schema( - new catalog::Schema({table_id_column, table_name_column, - database_id_column, version_id_column})); + std::unique_ptr table_catalog_schema(new catalog::Schema( + {table_id_column, table_name_column, schema_name_column, + database_id_column, version_id_column})); return table_catalog_schema; } @@ -371,6 +384,7 @@ std::unique_ptr TableCatalog::InitializeSchema() { * @return Whether insertion is Successful */ bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, + const std::string &schema_name, oid_t database_oid, type::AbstractPool *pool, concurrency::TransactionContext *txn) { // Create the tuple first @@ -379,13 +393,15 @@ bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, auto val0 = type::ValueFactory::GetIntegerValue(table_oid); auto val1 = type::ValueFactory::GetVarcharValue(table_name, nullptr); - auto val2 = type::ValueFactory::GetIntegerValue(database_oid); - auto val3 = type::ValueFactory::GetIntegerValue(0); + auto val2 = type::ValueFactory::GetVarcharValue(schema_name, nullptr); + auto val3 = type::ValueFactory::GetIntegerValue(database_oid); + auto val4 = type::ValueFactory::GetIntegerValue(0); tuple->SetValue(TableCatalog::ColumnId::TABLE_OID, val0, pool); tuple->SetValue(TableCatalog::ColumnId::TABLE_NAME, val1, pool); - tuple->SetValue(TableCatalog::ColumnId::DATABASE_OID, val2, pool); - tuple->SetValue(TableCatalog::ColumnId::VERSION_ID, val3, pool); + tuple->SetValue(TableCatalog::ColumnId::SCHEMA_NAME, val2, pool); + tuple->SetValue(TableCatalog::ColumnId::DATABASE_OID, val3, pool); + tuple->SetValue(TableCatalog::ColumnId::VERSION_ID, val4, pool); // Insert the tuple return InsertTuple(std::move(tuple), txn); @@ -458,19 +474,22 @@ std::shared_ptr TableCatalog::GetTableObject( /*@brief read table catalog object from pg_table using table name + database * oid * @param table_name + * @param schema_name * @param database_oid * @param txn TransactionContext * @return table catalog object */ std::shared_ptr TableCatalog::GetTableObject( - const std::string &table_name, concurrency::TransactionContext *txn) { + const std::string &table_name, const std::string &schema_name, + concurrency::TransactionContext *txn) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } // try get from cache auto database_object = txn->catalog_cache.GetDatabaseObject(database_oid); if (database_object) { - auto table_object = database_object->GetTableObject(table_name, true); + auto table_object = + database_object->GetTableObject(table_name, schema_name, true); if (table_object) return table_object; } @@ -480,6 +499,8 @@ std::shared_ptr TableCatalog::GetTableObject( std::vector values; values.push_back( type::ValueFactory::GetVarcharValue(table_name, nullptr).Copy()); + values.push_back( + type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); auto result_tiles = GetResultWithIndexScan(column_ids, index_offset, values, txn); @@ -507,8 +528,7 @@ std::shared_ptr TableCatalog::GetTableObject( * @return table catalog objects */ std::unordered_map> -TableCatalog::GetTableObjects(oid_t database_oid, - concurrency::TransactionContext *txn) { +TableCatalog::GetTableObjects(concurrency::TransactionContext *txn) { if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } diff --git a/src/catalog/table_metrics_catalog.cpp b/src/catalog/table_metrics_catalog.cpp index 8a93a4dc680..f1f91f46474 100644 --- a/src/catalog/table_metrics_catalog.cpp +++ b/src/catalog/table_metrics_catalog.cpp @@ -22,9 +22,8 @@ namespace catalog { TableMetricsCatalog::TableMetricsCatalog(const std::string &database_name, concurrency::TransactionContext *txn) : AbstractCatalog("CREATE TABLE " + database_name + - "." TABLE_METRICS_CATALOG_NAME + "." CATALOG_SCHEMA_NAME "." TABLE_METRICS_CATALOG_NAME " (" - "database_oid INT NOT NULL, " "table_oid INT NOT NULL, " "reads INT NOT NULL, " "updates INT NOT NULL, " @@ -38,13 +37,12 @@ TableMetricsCatalog::TableMetricsCatalog(const std::string &database_name, TableMetricsCatalog::~TableMetricsCatalog() {} bool TableMetricsCatalog::InsertTableMetrics( - oid_t database_oid, 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) { + 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) { std::unique_ptr tuple( new storage::Tuple(catalog_table_->GetSchema(), true)); - auto val0 = type::ValueFactory::GetIntegerValue(database_oid); auto val1 = type::ValueFactory::GetIntegerValue(table_oid); auto val2 = type::ValueFactory::GetIntegerValue(reads); auto val3 = type::ValueFactory::GetIntegerValue(updates); @@ -52,7 +50,6 @@ bool TableMetricsCatalog::InsertTableMetrics( auto val5 = type::ValueFactory::GetIntegerValue(inserts); auto val6 = type::ValueFactory::GetIntegerValue(time_stamp); - tuple->SetValue(ColumnId::DATABASE_OID, val0, pool); tuple->SetValue(ColumnId::TABLE_OID, val1, pool); tuple->SetValue(ColumnId::READS, val2, pool); tuple->SetValue(ColumnId::UPDATES, val3, pool); diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index c9600af2b2a..1474dd20d4c 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -25,7 +25,7 @@ namespace catalog { TriggerCatalog::TriggerCatalog(const std::string &database_name, concurrency::TransactionContext *txn) : AbstractCatalog("CREATE TABLE " + database_name + - "." TRIGGER_CATALOG_NAME + "." CATALOG_SCHEMA_NAME "." TRIGGER_CATALOG_NAME " (" "oid INT NOT NULL PRIMARY KEY, " "tgrelid INT NOT NULL, " @@ -38,16 +38,17 @@ TriggerCatalog::TriggerCatalog(const std::string &database_name, txn) { // Add secondary index here if necessary Catalog::GetInstance()->CreateIndex( - database_name, TRIGGER_CATALOG_NAME, + 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, TRIGGER_CATALOG_NAME, {ColumnId::TABLE_OID}, - TRIGGER_CATALOG_NAME "_skey1", false, IndexType::BWTREE, txn); + database_name, CATALOG_SCHEMA_NAME, TRIGGER_CATALOG_NAME, + {ColumnId::TABLE_OID}, TRIGGER_CATALOG_NAME "_skey1", false, + IndexType::BWTREE, txn); Catalog::GetInstance()->CreateIndex( - database_name, TRIGGER_CATALOG_NAME, + database_name, CATALOG_SCHEMA_NAME, TRIGGER_CATALOG_NAME, {ColumnId::TRIGGER_NAME, ColumnId::TABLE_OID}, TRIGGER_CATALOG_NAME "_skey2", false, IndexType::BWTREE, txn); } @@ -88,34 +89,6 @@ bool TriggerCatalog::InsertTrigger(oid_t table_oid, std::string trigger_name, return InsertTuple(std::move(tuple), txn); } -ResultType TriggerCatalog::DropTrigger(const std::string &database_name, - const std::string &table_name, - const std::string &trigger_name, - concurrency::TransactionContext *txn) { - if (txn == nullptr) { - LOG_TRACE("Do not have transaction to drop trigger: %s", - table_name.c_str()); - return ResultType::FAILURE; - } - - // Checking if statement is valid - auto table_object = - Catalog::GetInstance()->GetTableObject(database_name, table_name, txn); - if (table_object == nullptr) - throw CatalogException("Drop Trigger: table " + table_name + - " does not exist"); - - oid_t trigger_oid = - GetTriggerOid(trigger_name, table_object->GetTableOid(), txn); - if (trigger_oid == INVALID_OID) { - LOG_TRACE("Cannot find trigger %s to drop!", trigger_name.c_str()); - return ResultType::FAILURE; - } - - return DropTrigger(table_object->GetDatabaseOid(), - table_object->GetTableOid(), trigger_name, txn); -} - ResultType TriggerCatalog::DropTrigger(const oid_t database_oid, const oid_t table_oid, const std::string &trigger_name, @@ -147,9 +120,9 @@ oid_t TriggerCatalog::GetTriggerOid(std::string trigger_name, oid_t table_oid, oid_t trigger_oid = INVALID_OID; if (result_tiles->size() == 0) { - LOG_INFO("trigger %s doesn't exist", trigger_name.c_str()); + // LOG_INFO("trigger %s doesn't exist", trigger_name.c_str()); } else { - LOG_INFO("size of the result tiles = %lu", result_tiles->size()); + // LOG_INFO("size of the result tiles = %lu", result_tiles->size()); PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); if ((*result_tiles)[0]->GetTupleCount() != 0) { trigger_oid = (*result_tiles)[0]->GetValue(0, 0).GetAs(); @@ -229,11 +202,11 @@ std::unique_ptr TriggerCatalog::GetTriggers( auto result_tiles = GetResultWithIndexScan(column_ids, index_offset, values, txn); // carefull! the result tile could be null! - if (result_tiles == nullptr) { - LOG_INFO("no trigger on table %d", table_oid); - } else { - LOG_INFO("size of the result tiles = %lu", result_tiles->size()); - } + // if (result_tiles == nullptr) { + // LOG_INFO("no trigger on table %d", table_oid); + // } else { + // LOG_INFO("size of the result tiles = %lu", result_tiles->size()); + // } // create the trigger list std::unique_ptr new_trigger_list{ diff --git a/src/catalog/zone_map_catalog.cpp b/src/catalog/zone_map_catalog.cpp index c4535268c3d..ec59dd24d82 100644 --- a/src/catalog/zone_map_catalog.cpp +++ b/src/catalog/zone_map_catalog.cpp @@ -10,14 +10,13 @@ // //===----------------------------------------------------------------------===// - #include "catalog/zone_map_catalog.h" #include "catalog/catalog.h" +#include "common/internal_types.h" #include "executor/logical_tile.h" #include "storage/data_table.h" #include "storage/tuple.h" -#include "common/internal_types.h" #include "type/value_factory.h" namespace peloton { @@ -27,14 +26,15 @@ namespace catalog { // but #796 is still not merged when I am writing this code and I really // am sorry to do this. When PelotonMain() becomes a reality, I will // fix this for sure. -ZoneMapCatalog *ZoneMapCatalog::GetInstance(concurrency::TransactionContext *txn) { +ZoneMapCatalog *ZoneMapCatalog::GetInstance( + concurrency::TransactionContext *txn) { static ZoneMapCatalog zone_map_catalog{txn}; return &zone_map_catalog; } ZoneMapCatalog::ZoneMapCatalog(concurrency::TransactionContext *txn) : AbstractCatalog("CREATE TABLE " CATALOG_DATABASE_NAME - "." ZONE_MAP_CATALOG_NAME + "." CATALOG_SCHEMA_NAME "." ZONE_MAP_CATALOG_NAME " (" "database_id INT NOT NULL, " "table_id INT NOT NULL, " @@ -45,8 +45,9 @@ ZoneMapCatalog::ZoneMapCatalog(concurrency::TransactionContext *txn) "type VARCHAR);", txn) { Catalog::GetInstance()->CreateIndex( - CATALOG_DATABASE_NAME, ZONE_MAP_CATALOG_NAME, {0, 1, 2, 3}, - ZONE_MAP_CATALOG_NAME "_skey0", true, IndexType::BWTREE, txn); + CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, ZONE_MAP_CATALOG_NAME, + {0, 1, 2, 3}, ZONE_MAP_CATALOG_NAME "_skey0", true, IndexType::BWTREE, + txn); } ZoneMapCatalog::~ZoneMapCatalog() {} @@ -68,8 +69,10 @@ bool ZoneMapCatalog::InsertColumnStatistics( tuple->SetValue(static_cast(ColumnId::DATABASE_ID), val_db_id, nullptr); tuple->SetValue(static_cast(ColumnId::TABLE_ID), val_table_id, nullptr); - tuple->SetValue(static_cast(ColumnId::TILE_GROUP_ID), val_tile_group_id, nullptr); - tuple->SetValue(static_cast(ColumnId::COLUMN_ID), val_column_id, nullptr); + tuple->SetValue(static_cast(ColumnId::TILE_GROUP_ID), val_tile_group_id, + nullptr); + tuple->SetValue(static_cast(ColumnId::COLUMN_ID), val_column_id, + nullptr); tuple->SetValue(static_cast(ColumnId::MINIMUM), val_minimum, pool); tuple->SetValue(static_cast(ColumnId::MAXIMUM), val_maximum, pool); tuple->SetValue(static_cast(ColumnId::TYPE), val_type, pool); @@ -78,36 +81,32 @@ bool ZoneMapCatalog::InsertColumnStatistics( 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( + oid_t database_id, oid_t table_id, oid_t tile_group_id, oid_t column_id, + concurrency::TransactionContext *txn) { 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) - }); + 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); } 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::vector column_ids( - {static_cast(ColumnId::MINIMUM), - static_cast(ColumnId::MAXIMUM), - static_cast(ColumnId::TYPE)}); + std::vector column_ids({static_cast(ColumnId::MINIMUM), + static_cast(ColumnId::MAXIMUM), + static_cast(ColumnId::TYPE)}); 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) - }); + std::vector values( + {type::ValueFactory::GetIntegerValue(database_id), + type::ValueFactory::GetIntegerValue(table_id), + type::ValueFactory::GetIntegerValue(tile_group_id), + type::ValueFactory::GetIntegerValue(column_id)}); auto result_tiles = GetResultWithIndexScan(column_ids, index_offset, values, txn); @@ -139,4 +138,4 @@ std::unique_ptr> ZoneMapCatalog::GetColumnStatistics( } } // namespace catalog -} // namespace peloton \ No newline at end of file +} // namespace peloton diff --git a/src/common/init.cpp b/src/common/init.cpp index bc88a1ad405..c4ab64adc51 100644 --- a/src/common/init.cpp +++ b/src/common/init.cpp @@ -15,8 +15,6 @@ #include #include -#include "tuning/index_tuner.h" -#include "tuning/layout_tuner.h" #include "catalog/catalog.h" #include "common/statement_cache_manager.h" #include "common/thread_pool.h" @@ -25,6 +23,8 @@ #include "index/index.h" #include "settings/settings_manager.h" #include "threadpool/mono_queue_pool.h" +#include "tuning/index_tuner.h" +#include "tuning/layout_tuner.h" namespace peloton { @@ -32,7 +32,7 @@ ThreadPool thread_pool; void PelotonInit::Initialize() { CONNECTION_THREAD_COUNT = settings::SettingsManager::GetInt( - settings::SettingId::connection_thread_count); + settings::SettingId::connection_thread_count); LOGGING_THREAD_COUNT = 1; GC_THREAD_COUNT = 1; EPOCH_THREAD_COUNT = 1; diff --git a/src/common/internal_types.cpp b/src/common/internal_types.cpp index 125d719b5d7..7efd503a2eb 100644 --- a/src/common/internal_types.cpp +++ b/src/common/internal_types.cpp @@ -329,6 +329,9 @@ std::string CreateTypeToString(CreateType type) { case CreateType::TRIGGER: { return "TRIGGER"; } + case CreateType::SCHEMA: { + return "SCHEMA"; + } default: { throw ConversionException( StringUtil::Format("No string conversion for CreateType value '%d'", @@ -352,6 +355,8 @@ CreateType StringToCreateType(const std::string &str) { return CreateType::CONSTRAINT; } else if (upper_str == "TRIGGER") { return CreateType::TRIGGER; + } else if (upper_str == "SCHEMA") { + return CreateType::SCHEMA; } else { throw ConversionException(StringUtil::Format( "No CreateType conversion from string '%s'", upper_str.c_str())); @@ -383,6 +388,9 @@ std::string DropTypeToString(DropType type) { case DropType::TRIGGER: { return "TRIGGER"; } + case DropType::SCHEMA: { + return "SCHEMA"; + } default: { throw ConversionException( StringUtil::Format("No string conversion for DropType value '%d'", @@ -406,6 +414,8 @@ DropType StringToDropType(const std::string &str) { return DropType::CONSTRAINT; } else if (upper_str == "TRIGGER") { return DropType::TRIGGER; + } else if (upper_str == "SCHEMA") { + return DropType::SCHEMA; } else { throw ConversionException(StringUtil::Format( "No DropType conversion from string '%s'", upper_str.c_str())); diff --git a/src/concurrency/timestamp_ordering_transaction_manager.cpp b/src/concurrency/timestamp_ordering_transaction_manager.cpp index a6d5c49fd5f..c86c53292e0 100644 --- a/src/concurrency/timestamp_ordering_transaction_manager.cpp +++ b/src/concurrency/timestamp_ordering_transaction_manager.cpp @@ -13,6 +13,7 @@ #include "concurrency/timestamp_ordering_transaction_manager.h" #include +#include "catalog/catalog_defaults.h" #include "catalog/manager.h" #include "common/exception.h" #include "common/logger.h" @@ -764,7 +765,7 @@ ResultType TimestampOrderingTransactionManager::CommitTransaction( // and initilaize the iterator const auto tile_group_id = tuple_entry.first.block; database_id = manager.GetTileGroup(tile_group_id)->GetDatabaseId(); - if (database_id != DEFAULT_DB_ID) { + if (database_id != CATALOG_DATABASE_OID) { break; } } @@ -943,7 +944,7 @@ ResultType TimestampOrderingTransactionManager::AbortTransaction( // and initilaize the iterator const auto tile_group_id = tuple_entry.first.block; database_id = manager.GetTileGroup(tile_group_id)->GetDatabaseId(); - if (database_id != DEFAULT_DB_ID) { + if (database_id != CATALOG_DATABASE_OID) { break; } } diff --git a/src/concurrency/transaction_context.cpp b/src/concurrency/transaction_context.cpp index d08e72bbf9a..87b8fa235d9 100644 --- a/src/concurrency/transaction_context.cpp +++ b/src/concurrency/transaction_context.cpp @@ -15,13 +15,13 @@ #include #include "common/logger.h" -#include "common/platform.h" #include "common/macros.h" +#include "common/platform.h" #include "trigger/trigger.h" #include -#include #include +#include namespace peloton { namespace concurrency { @@ -75,8 +75,8 @@ TransactionContext::TransactionContext(const size_t thread_id, TransactionContext::~TransactionContext() {} void TransactionContext::Init(const size_t thread_id, - const IsolationLevelType isolation, const cid_t &read_id, - const cid_t &commit_id) { + const IsolationLevelType isolation, + const cid_t &read_id, const cid_t &commit_id) { read_id_ = read_id; // commit id can be set at a transaction's commit phase. @@ -129,7 +129,7 @@ void TransactionContext::RecordReadOwn(const ItemPointer &location) { PELOTON_ASSERT(rw_type != RWType::DELETE && rw_type != RWType::INS_DEL); if (rw_type == RWType::READ) { rw_set_.Update(location, RWType::READ_OWN); - } + } } else { rw_set_.Insert(location, RWType::READ_OWN); } @@ -188,7 +188,7 @@ bool TransactionContext::RecordDelete(const ItemPointer &location) { --insert_count_; return true; } - if(rw_type == RWType::DELETE) { + if (rw_type == RWType::DELETE) { PELOTON_ASSERT(false); return false; } @@ -210,7 +210,8 @@ const std::string TransactionContext::GetInfo() const { return os.str(); } -void TransactionContext::AddOnCommitTrigger(trigger::TriggerData &trigger_data) { +void TransactionContext::AddOnCommitTrigger( + trigger::TriggerData &trigger_data) { if (on_commit_triggers_ == nullptr) { on_commit_triggers_.reset(new trigger::TriggerSet()); } diff --git a/src/executor/create_executor.cpp b/src/executor/create_executor.cpp index d1df4bc2e77..83e85c92c48 100644 --- a/src/executor/create_executor.cpp +++ b/src/executor/create_executor.cpp @@ -51,6 +51,11 @@ bool CreateExecutor::DExecute() { result = CreateDatabase(node); break; } + // if query was for creating schema(namespace) + case CreateType::SCHEMA: { + result = CreateSchema(node); + break; + } // if query was for creating table case CreateType::TABLE: { result = CreateTable(node); @@ -87,6 +92,7 @@ bool CreateExecutor::DExecute() { bool CreateExecutor::CreateDatabase(const planner::CreatePlan &node) { auto txn = context_->GetTransaction(); auto database_name = node.GetDatabaseName(); + // invoke logic within catalog.cpp ResultType result = catalog::Catalog::GetInstance()->CreateDatabase(database_name, txn); txn->SetResult(result); @@ -94,14 +100,27 @@ bool CreateExecutor::CreateDatabase(const planner::CreatePlan &node) { return (true); } +bool CreateExecutor::CreateSchema(const planner::CreatePlan &node) { + auto txn = context_->GetTransaction(); + 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); + txn->SetResult(result); + LOG_TRACE("Result is: %s", ResultTypeToString(txn->GetResult()).c_str()); + return (true); +} + bool CreateExecutor::CreateTable(const planner::CreatePlan &node) { auto current_txn = context_->GetTransaction(); std::string table_name = node.GetTableName(); - auto database_name = node.GetDatabaseName(); + std::string schema_name = node.GetSchemaName(); + std::string database_name = node.GetDatabaseName(); std::unique_ptr schema(node.GetSchema()); ResultType result = catalog::Catalog::GetInstance()->CreateTable( - database_name, table_name, std::move(schema), current_txn); + database_name, schema_name, table_name, std::move(schema), current_txn); current_txn->SetResult(result); if (current_txn->GetResult() == ResultType::SUCCESS) { @@ -109,15 +128,14 @@ bool CreateExecutor::CreateTable(const planner::CreatePlan &node) { // Add the foreign key constraint (or other multi-column constraints) if (node.GetForeignKeys().empty() == false) { - auto catalog = catalog::Catalog::GetInstance(); - auto db = catalog->GetDatabaseWithName(database_name, current_txn); - - auto source_table = db->GetTableWithName(table_name); int count = 1; + auto catalog = catalog::Catalog::GetInstance(); + auto source_table = catalog->GetTableWithName(database_name, schema_name, + table_name, current_txn); for (auto fk : node.GetForeignKeys()) { - auto sink_table = db->GetTableWithName(fk.sink_table_name); - + auto sink_table = catalog->GetTableWithName( + database_name, schema_name, fk.sink_table_name, current_txn); // Source Column Offsets std::vector source_col_ids; for (auto col_name : fk.foreign_key_sources) { @@ -125,7 +143,7 @@ bool CreateExecutor::CreateTable(const planner::CreatePlan &node) { if (col_id == INVALID_OID) { std::string error = StringUtil::Format( "Invalid source column name '%s.%s' for foreign key '%s'", - source_table->GetName().c_str(), col_name.c_str(), + table_name.c_str(), col_name.c_str(), fk.constraint_name.c_str()); throw ExecutorException(error); } @@ -162,10 +180,9 @@ bool CreateExecutor::CreateTable(const planner::CreatePlan &node) { // Add a non-unique index on the source table if needed std::vector source_col_names = fk.foreign_key_sources; - std::string index_name = source_table->GetName() + "_FK_" + - sink_table->GetName() + "_" + - std::to_string(count); - catalog->CreateIndex(database_name, source_table->GetName(), + 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); count++; @@ -194,7 +211,8 @@ bool CreateExecutor::CreateTable(const planner::CreatePlan &node) { bool CreateExecutor::CreateIndex(const planner::CreatePlan &node) { auto txn = context_->GetTransaction(); - auto database_name = node.GetDatabaseName(); + std::string database_name = node.GetDatabaseName(); + std::string schema_name = node.GetSchemaName(); std::string table_name = node.GetTableName(); std::string index_name = node.GetIndexName(); bool unique_flag = node.IsUnique(); @@ -203,8 +221,8 @@ bool CreateExecutor::CreateIndex(const planner::CreatePlan &node) { auto key_attrs = node.GetKeyAttrs(); ResultType result = catalog::Catalog::GetInstance()->CreateIndex( - database_name, table_name, key_attrs, index_name, unique_flag, index_type, - txn); + database_name, schema_name, table_name, key_attrs, index_name, + unique_flag, index_type, txn); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { @@ -220,13 +238,13 @@ bool CreateExecutor::CreateIndex(const planner::CreatePlan &node) { bool CreateExecutor::CreateTrigger(const planner::CreatePlan &node) { auto txn = context_->GetTransaction(); std::string database_name = node.GetDatabaseName(); + std::string schema_name = node.GetSchemaName(); std::string table_name = node.GetTableName(); std::string trigger_name = node.GetTriggerName(); trigger::Trigger newTrigger(node); - auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - database_name, table_name, txn); + database_name, schema_name, table_name, txn); // durable trigger: insert the information of this trigger in the trigger // catalog table @@ -249,8 +267,8 @@ bool CreateExecutor::CreateTrigger(const planner::CreatePlan &node) { newTrigger.GetArgs(), when, time_stamp, pool_.get(), txn); // ask target table to update its trigger list variable storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName(database_name, - table_name, txn); + catalog::Catalog::GetInstance()->GetTableWithName( + database_name, schema_name, table_name, txn); target_table->UpdateTriggerListFromCatalog(txn); // hardcode SUCCESS result for txn diff --git a/src/executor/drop_executor.cpp b/src/executor/drop_executor.cpp index e41d8800541..b9413366c2e 100644 --- a/src/executor/drop_executor.cpp +++ b/src/executor/drop_executor.cpp @@ -49,6 +49,10 @@ bool DropExecutor::DExecute() { result = DropDatabase(node, current_txn); break; } + case DropType::SCHEMA: { + result = DropSchema(node, current_txn); + break; + } case DropType::TABLE: { result = DropTable(node, current_txn); break; @@ -72,7 +76,7 @@ bool DropExecutor::DExecute() { bool DropExecutor::DropDatabase(const planner::DropPlan &node, concurrency::TransactionContext *txn) { - auto database_name = node.GetDatabaseName(); + std::string database_name = node.GetDatabaseName(); if (node.IsMissing()) { try { @@ -109,15 +113,45 @@ bool DropExecutor::DropDatabase(const planner::DropPlan &node, return false; } +bool DropExecutor::DropSchema(const planner::DropPlan &node, + concurrency::TransactionContext *txn) { + std::string database_name = node.GetDatabaseName(); + std::string schema_name = node.GetSchemaName(); + + ResultType result = catalog::Catalog::GetInstance()->DropSchema( + database_name, schema_name, txn); + txn->SetResult(result); + + if (txn->GetResult() == ResultType::SUCCESS) { + LOG_DEBUG("Dropping schema succeeded!"); + // 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); + for (int i = 0; i < (int)table_objects.size(); i++) { + table_ids.insert(table_objects[i]->GetTableOid()); + } + StatementCacheManager::GetStmtCacheManager()->InvalidateTableOids( + table_ids); + } + } else { + LOG_DEBUG("Result is: %s", ResultTypeToString(txn->GetResult()).c_str()); + } + return false; +} + bool DropExecutor::DropTable(const planner::DropPlan &node, concurrency::TransactionContext *txn) { - auto database_name = node.GetDatabaseName(); - auto table_name = node.GetTableName(); + std::string database_name = node.GetDatabaseName(); + std::string schema_name = node.GetSchemaName(); + std::string table_name = node.GetTableName(); if (node.IsMissing()) { try { auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - database_name, table_name, txn); + database_name, schema_name, table_name, txn); } catch (CatalogException &e) { LOG_TRACE("Table %s does not exist.", table_name.c_str()); return false; @@ -125,16 +159,17 @@ bool DropExecutor::DropTable(const planner::DropPlan &node, } ResultType result = catalog::Catalog::GetInstance()->DropTable( - database_name, table_name, txn); + database_name, schema_name, table_name, txn); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { LOG_TRACE("Dropping table succeeded!"); if (StatementCacheManager::GetStmtCacheManager().get()) { - oid_t table_id = catalog::Catalog::GetInstance() - ->GetTableObject(database_name, table_name, txn) - ->GetTableOid(); + oid_t table_id = + catalog::Catalog::GetInstance() + ->GetTableObject(database_name, schema_name, table_name, txn) + ->GetTableOid(); StatementCacheManager::GetStmtCacheManager()->InvalidateTableOid( table_id); } @@ -146,28 +181,26 @@ bool DropExecutor::DropTable(const planner::DropPlan &node, bool DropExecutor::DropTrigger(const planner::DropPlan &node, concurrency::TransactionContext *txn) { - auto database_name = node.GetDatabaseName(); - auto table_name = node.GetTableName(); - LOG_DEBUG("database name: %s", database_name.c_str()); - LOG_DEBUG("table name: %s", table_name.c_str()); + std::string database_name = node.GetDatabaseName(); + std::string schema_name = node.GetSchemaName(); + std::string table_name = node.GetTableName(); std::string trigger_name = node.GetTriggerName(); auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - database_name, table_name, txn); - + database_name, schema_name, table_name, txn); + // drop trigger ResultType result = catalog::Catalog::GetInstance() ->GetSystemCatalogs(table_object->GetDatabaseOid()) ->GetTriggerCatalog() - ->DropTrigger(database_name, table_name, trigger_name, txn); + ->DropTrigger(table_object->GetDatabaseOid(), + table_object->GetTableOid(), trigger_name, txn); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { LOG_DEBUG("Dropping trigger succeeded!"); if (StatementCacheManager::GetStmtCacheManager().get()) { - oid_t table_id = catalog::Catalog::GetInstance() - ->GetTableObject(database_name, table_name, txn) - ->GetTableOid(); + oid_t table_id = table_object->GetTableOid(); StatementCacheManager::GetStmtCacheManager()->InvalidateTableOid( table_id); } @@ -184,27 +217,34 @@ bool DropExecutor::DropTrigger(const planner::DropPlan &node, 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); + if (database_object == nullptr) { + throw CatalogException("Index name " + index_name + " cannot be found"); + } auto pg_index = catalog::Catalog::GetInstance() ->GetSystemCatalogs(database_object->GetDatabaseOid()) ->GetIndexCatalog(); - std::string index_name = node.GetIndexName(); - auto index_object = pg_index->GetIndexObject(index_name, txn); - + auto index_object = pg_index->GetIndexObject(index_name, schema_name, txn); + 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); txn->SetResult(result); if (txn->GetResult() == ResultType::SUCCESS) { + LOG_TRACE("Dropping Index Succeeded! Index name: %s", index_name.c_str()); if (StatementCacheManager::GetStmtCacheManager().get()) { oid_t table_id = index_object->GetTableOid(); StatementCacheManager::GetStmtCacheManager()->InvalidateTableOid( table_id); } - LOG_TRACE("Dropping Index Succeeded! Index name: %s", - node.GetIndexName().c_str()); } else { LOG_TRACE("Dropping Index Failed!"); } diff --git a/src/gc/transaction_level_gc_manager.cpp b/src/gc/transaction_level_gc_manager.cpp index b034225901e..c2274a330e0 100644 --- a/src/gc/transaction_level_gc_manager.cpp +++ b/src/gc/transaction_level_gc_manager.cpp @@ -17,15 +17,14 @@ #include "common/container_tuple.h" #include "concurrency/epoch_manager_factory.h" #include "concurrency/transaction_manager_factory.h" -#include "settings/settings_manager.h" #include "index/index.h" +#include "settings/settings_manager.h" #include "storage/database.h" +#include "storage/storage_manager.h" #include "storage/tile_group.h" #include "storage/tuple.h" -#include "storage/storage_manager.h" #include "threadpool/mono_queue_pool.h" - namespace peloton { namespace gc { @@ -43,7 +42,7 @@ bool TransactionLevelGCManager::ResetTuple(const ItemPointer &location) { tile_group_header->SetNextItemPointer(location.offset, INVALID_ITEMPOINTER); PELOTON_MEMSET(tile_group_header->GetReservedFieldRef(location.offset), 0, - storage::TileGroupHeader::GetReservedSize()); + storage::TileGroupHeader::GetReservedSize()); // Reclaim the varlen pool CheckAndReclaimVarlenColumns(tile_group, location.offset); @@ -90,12 +89,11 @@ void TransactionLevelGCManager::RecycleTransaction( concurrency::TransactionContext *txn) { auto &epoch_manager = concurrency::EpochManagerFactory::GetInstance(); - epoch_manager.ExitEpoch(txn->GetThreadId(), - txn->GetEpochId()); + epoch_manager.ExitEpoch(txn->GetThreadId(), txn->GetEpochId()); - if (txn->GetIsolationLevel() != IsolationLevelType::READ_ONLY && \ + if (txn->GetIsolationLevel() != IsolationLevelType::READ_ONLY && txn->GetResult() != ResultType::SUCCESS && txn->IsGCSetEmpty() != true) { - txn->SetEpochId(epoch_manager.GetNextEpochId()); + txn->SetEpochId(epoch_manager.GetNextEpochId()); } // Add the transaction context to the lock-free queue @@ -108,7 +106,7 @@ int TransactionLevelGCManager::Unlink(const int &thread_id, // check if any garbage can be unlinked from indexes. // every time we garbage collect at most MAX_ATTEMPT_COUNT tuples. - std::vector garbages; + std::vector garbages; // First iterate the local unlink queue local_unlink_queues_[thread_id].remove_if( @@ -135,20 +133,20 @@ int TransactionLevelGCManager::Unlink(const int &thread_id, // Log the query into query_history_catalog if (settings::SettingsManager::GetBool(settings::SettingId::brain)) { std::vector query_strings = txn_ctx->GetQueryStrings(); - if(query_strings.size() != 0) { + if (query_strings.size() != 0) { uint64_t timestamp = txn_ctx->GetTimestamp(); auto &pool = threadpool::MonoQueuePool::GetBrainInstance(); - for(auto query_string: query_strings) { + for (auto query_string : query_strings) { pool.SubmitTask([query_string, timestamp] { brain::QueryLogger::LogQuery(query_string, timestamp); - }); + }); } } } // Deallocate the Transaction Context of transactions that don't involve // any garbage collection - if (txn_ctx->GetIsolationLevel() == IsolationLevelType::READ_ONLY || \ + if (txn_ctx->GetIsolationLevel() == IsolationLevelType::READ_ONLY || txn_ctx->IsGCSetEmpty()) { delete txn_ctx; continue; @@ -215,7 +213,7 @@ int TransactionLevelGCManager::Reclaim(const int &thread_id, // Multiple GC thread share the same recycle map void TransactionLevelGCManager::AddToRecycleMap( - concurrency::TransactionContext* txn_ctx) { + concurrency::TransactionContext *txn_ctx) { for (auto &entry : *(txn_ctx->GetGCSetPtr().get())) { auto &manager = catalog::Manager::GetInstance(); auto tile_group = manager.GetTileGroup(entry.first); @@ -277,6 +275,7 @@ void TransactionLevelGCManager::AddToRecycleMap( auto index = table->GetIndexWithOid(index_oid); PELOTON_ASSERT(index != nullptr); table->DropIndexWithOid(index_oid); + LOG_DEBUG("GCing index %u", index_oid); } delete txn_ctx; @@ -387,8 +386,8 @@ void TransactionLevelGCManager::UnlinkVersion(const ItemPointer location, // no index manipulation needs to be made. } else { PELOTON_ASSERT(type == GCVersionType::ABORT_INSERT || - type == GCVersionType::COMMIT_INS_DEL || - type == GCVersionType::ABORT_INS_DEL); + type == GCVersionType::COMMIT_INS_DEL || + type == GCVersionType::ABORT_INS_DEL); // attempt to unlink the version from all the indexes. for (size_t idx = 0; idx < table->GetIndexCount(); ++idx) { diff --git a/src/include/binder/binder_context.h b/src/include/binder/binder_context.h index c0c67c379c6..93aca140539 100644 --- a/src/include/binder/binder_context.h +++ b/src/include/binder/binder_context.h @@ -57,8 +57,8 @@ class BinderContext { * @brief Update the table alias map given a table reference (in the from * clause) */ - void AddRegularTable(const std::string db_name, const std::string table_name, - const std::string table_alias, + void AddRegularTable(const std::string db_name, const std::string schema_name, + std::string table_name, const std::string table_alias, concurrency::TransactionContext *txn); /** diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index 35319683e18..e0c8d81df53 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -88,7 +88,8 @@ class AbstractCatalog { // Maximum column name size for catalog schemas static const size_t max_name_size = 64; - + // which database catalog table is stored int + 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 f90bab5eaca..cd19d7fe72b 100644 --- a/src/include/catalog/catalog.h +++ b/src/include/catalog/catalog.h @@ -89,19 +89,21 @@ class Catalog { ResultType CreateDatabase(const std::string &database_name, concurrency::TransactionContext *txn); + // Create a schema(namespace) + ResultType CreateSchema(const std::string &database_name, + const std::string &schema_name, + concurrency::TransactionContext *txn); + // Create a table in a database ResultType CreateTable( - const std::string &database_name, const std::string &table_name, - std::unique_ptr, concurrency::TransactionContext *txn, - bool is_catalog = false, + 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, oid_t tuples_per_tilegroup = DEFAULT_TUPLES_PER_TILEGROUP); - // 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, - concurrency::TransactionContext *txn); // Create index for a table ResultType CreateIndex(const std::string &database_name, + const std::string &schema_name, const std::string &table_name, const std::vector &key_attrs, const std::string &index_name, bool unique_keys, @@ -110,6 +112,7 @@ class Catalog { ResultType 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, @@ -126,8 +129,14 @@ class Catalog { ResultType DropDatabaseWithOid(oid_t database_oid, concurrency::TransactionContext *txn); + // Drop a schema(namespace) using schema name + ResultType DropSchema(const std::string &database_name, + const std::string &schema_name, + concurrency::TransactionContext *txn); + // Drop a table using table name ResultType DropTable(const std::string &database_name, + const std::string &schema_name, const std::string &table_name, concurrency::TransactionContext *txn); // Drop a table, use this one in the future @@ -136,11 +145,6 @@ class Catalog { // Drop an index, using its index_oid ResultType DropIndex(oid_t database_oid, oid_t index_oid, concurrency::TransactionContext *txn); - - // Drop an index, using its index name - ResultType DropIndex(const std::string &database_name, - const std::string &index_name, - concurrency::TransactionContext *txn); //===--------------------------------------------------------------------===// // GET WITH NAME - CHECK FROM CATALOG TABLES, USING TRANSACTION //===--------------------------------------------------------------------===// @@ -152,11 +156,12 @@ class Catalog { storage::Database *GetDatabaseWithName( const std::string &db_name, concurrency::TransactionContext *txn) const; - /* Check table from pg_table with table_name using txn, + /* 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, + const std::string &schema_name, const std::string &table_name, concurrency::TransactionContext *txn); @@ -174,8 +179,8 @@ class Catalog { * throw exception and abort txn if not exists/invisible * */ std::shared_ptr GetTableObject( - const std::string &database_name, const std::string &table_name, - concurrency::TransactionContext *txn); + 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); @@ -226,6 +231,12 @@ class Catalog { void BootstrapSystemCatalogs(storage::Database *database, concurrency::TransactionContext *txn); + // 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, + const std::string &schema_name, + concurrency::TransactionContext *txn); + // The pool for new varlen tuple fields std::unique_ptr pool_; std::mutex catalog_mutex; diff --git a/src/include/catalog/catalog_cache.h b/src/include/catalog/catalog_cache.h index f66f83038e0..5bde19760ad 100644 --- a/src/include/catalog/catalog_cache.h +++ b/src/include/catalog/catalog_cache.h @@ -52,7 +52,7 @@ class CatalogCache { std::shared_ptr GetCachedTableObject(oid_t table_oid); std::shared_ptr GetCachedIndexObject(oid_t index_oid); std::shared_ptr GetCachedIndexObject( - const std::string &index_name); + const std::string &index_name, const std::string &schema_name); // database catalog cache interface bool InsertDatabaseObject( diff --git a/src/include/catalog/catalog_defaults.h b/src/include/catalog/catalog_defaults.h index da6b1ae5072..1b7df9fd3ad 100644 --- a/src/include/catalog/catalog_defaults.h +++ b/src/include/catalog/catalog_defaults.h @@ -19,17 +19,16 @@ namespace catalog { // System Catalogs imitating Postgres // (https://www.postgresql.org/docs/9.6/static/catalogs.html) // Differences are: -// 1. pg_catalog is a catalog schema in each database in Postgres, while it is a -// seperate catalog database in Peloton -// 2. pg_class contains everything similar to a table in Postgres, while Peloton +// 1. pg_class contains everything similar to a table in Postgres, while Peloton // uses pg_table only for the table catalog // Catalog database -#define CATALOG_DATABASE_NAME "pg_catalog" +#define CATALOG_DATABASE_NAME "peloton" // Catalog tables -// 4 basic catalog tables +// 5 basic catalog tables #define DATABASE_CATALOG_NAME "pg_database" +#define SCHEMA_CATALOG_NAME "pg_namespace" #define TABLE_CATALOG_NAME "pg_table" #define INDEX_CATALOG_NAME "pg_index" #define COLUMN_CATALOG_NAME "pg_attribute" @@ -39,20 +38,29 @@ namespace catalog { // Oid mask for each type #define DATABASE_OID_MASK (static_cast(catalog::CatalogType::DATABASE)) +#define SCHEMA_OID_MASK (static_cast(catalog::CatalogType::SCHEMA)) #define TABLE_OID_MASK (static_cast(catalog::CatalogType::TABLE)) #define INDEX_OID_MASK (static_cast(catalog::CatalogType::INDEX)) #define TRIGGER_OID_MASK (static_cast(catalog::CatalogType::TRIGGER)) #define LANGUAGE_OID_MASK (static_cast(catalog::CatalogType::LANGUAGE)) #define PROC_OID_MASK (static_cast(catalog::CatalogType::PROC)) -// Reserved pg_catalog database oid +// Reserved peloton database oid #define CATALOG_DATABASE_OID (0 | DATABASE_OID_MASK) +// Reserved schema oid +// "public" for default schema, and "pg_catalog" schema for catalog tables +#define CATALOG_SCHEMA_OID (0 | SCHEMA_OID_MASK) +#define DEFUALT_SCHEMA_OID (1 | SCHEMA_OID_MASK) +#define CATALOG_SCHEMA_NAME "pg_catalog" +#define DEFUALT_SCHEMA_NAME "public" + // Reserved pg_xxx table oid #define DATABASE_CATALOG_OID (0 | TABLE_OID_MASK) -#define TABLE_CATALOG_OID (1 | TABLE_OID_MASK) -#define INDEX_CATALOG_OID (2 | TABLE_OID_MASK) -#define COLUMN_CATALOG_OID (3 | TABLE_OID_MASK) +#define SCHEMA_CATALOG_OID (1 | TABLE_OID_MASK) +#define TABLE_CATALOG_OID (2 | TABLE_OID_MASK) +#define INDEX_CATALOG_OID (3 | TABLE_OID_MASK) +#define COLUMN_CATALOG_OID (4 | TABLE_OID_MASK) // Reserved pg_column index oid #define COLUMN_CATALOG_PKEY_OID (0 | INDEX_OID_MASK) @@ -68,18 +76,28 @@ namespace catalog { #define DATABASE_CATALOG_PKEY_OID (6 | INDEX_OID_MASK) #define DATABASE_CATALOG_SKEY0_OID (7 | INDEX_OID_MASK) +// Reserved pg_namespace index oid +#define SCHEMA_CATALOG_PKEY_OID (8 | INDEX_OID_MASK) +#define SCHEMA_CATALOG_SKEY0_OID (9 | INDEX_OID_MASK) + +// Reserved pg_table index oid +#define TABLE_CATALOG_PKEY_OID (10 | INDEX_OID_MASK) +#define TABLE_CATALOG_SKEY0_OID (11 | INDEX_OID_MASK) +#define TABLE_CATALOG_SKEY1_OID (12 | INDEX_OID_MASK) + // Use upper 8 bits indicating catalog type #define CATALOG_TYPE_OFFSET 24 enum class CatalogType : uint32_t { INVALID = INVALID_TYPE_ID, DATABASE = 1 << CATALOG_TYPE_OFFSET, - TABLE = 2 << CATALOG_TYPE_OFFSET, - INDEX = 3 << CATALOG_TYPE_OFFSET, - COLUMN = 4 << CATALOG_TYPE_OFFSET, - TRIGGER = 5 << CATALOG_TYPE_OFFSET, - LANGUAGE = 6 << CATALOG_TYPE_OFFSET, - PROC = 7 << CATALOG_TYPE_OFFSET, + SCHEMA = 2 << CATALOG_TYPE_OFFSET, + TABLE = 3 << CATALOG_TYPE_OFFSET, + INDEX = 4 << CATALOG_TYPE_OFFSET, + COLUMN = 5 << CATALOG_TYPE_OFFSET, + TRIGGER = 6 << CATALOG_TYPE_OFFSET, + LANGUAGE = 7 << CATALOG_TYPE_OFFSET, + PROC = 8 << CATALOG_TYPE_OFFSET, // To be added }; diff --git a/src/include/catalog/column_catalog.h b/src/include/catalog/column_catalog.h index 2eb71cb14d9..3df0d551967 100644 --- a/src/include/catalog/column_catalog.h +++ b/src/include/catalog/column_catalog.h @@ -91,8 +91,6 @@ class ColumnCatalog : public AbstractCatalog { bool DeleteColumns(oid_t table_oid, concurrency::TransactionContext *txn); private: - oid_t database_oid; - //===--------------------------------------------------------------------===// // Read Related API(only called within table catalog object) //===--------------------------------------------------------------------===// diff --git a/src/include/catalog/database_catalog.h b/src/include/catalog/database_catalog.h index 2c432ed191b..cc097414931 100644 --- a/src/include/catalog/database_catalog.h +++ b/src/include/catalog/database_catalog.h @@ -49,13 +49,18 @@ class DatabaseCatalogObject { std::shared_ptr GetTableObject(oid_t table_oid, bool cached_only = false); std::shared_ptr GetTableObject( - const std::string &table_name, bool cached_only = false); + 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; } + + std::vector> GetTableObjects( + const std::string &schema_name); + std::unordered_map> GetTableObjects(bool cached_only = false); @@ -69,12 +74,13 @@ class DatabaseCatalogObject { bool InsertTableObject(std::shared_ptr table_object); bool EvictTableObject(oid_t table_oid); - bool EvictTableObject(const std::string &table_name); + bool EvictTableObject(const std::string &table_name, + const std::string &schema_name); void SetValidTableObjects(bool valid = true) { valid_table_objects = valid; } std::shared_ptr GetCachedIndexObject(oid_t index_oid); std::shared_ptr GetCachedIndexObject( - const std::string &index_name); + const std::string &index_name, const std::string &schema_name); // cache for table name to oid translation std::unordered_map> @@ -98,9 +104,10 @@ 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( + storage::Database *pg_catalog = nullptr, + type::AbstractPool *pool = nullptr, + concurrency::TransactionContext *txn = nullptr); inline oid_t GetNextOid() { return oid_++ | DATABASE_OID_MASK; } @@ -108,7 +115,8 @@ class DatabaseCatalog : public AbstractCatalog { // write Related API //===--------------------------------------------------------------------===// bool InsertDatabase(oid_t database_oid, const std::string &database_name, - type::AbstractPool *pool, concurrency::TransactionContext *txn); + type::AbstractPool *pool, + concurrency::TransactionContext *txn); bool DeleteDatabase(oid_t database_oid, concurrency::TransactionContext *txn); private: diff --git a/src/include/catalog/index_catalog.h b/src/include/catalog/index_catalog.h index 0da44b045a9..3ece01952b9 100644 --- a/src/include/catalog/index_catalog.h +++ b/src/include/catalog/index_catalog.h @@ -17,16 +17,17 @@ // 0: index_oid (pkey) // 1: index_name // 2: table_oid (which table this index belongs to) -// 3: index_type (default value is BWTREE) -// 4: index_constraint -// 5: unique_keys (is this index supports duplicate keys) -// 6: indexed_attributes (indicate which table columns this index indexes. For +// 3: schema_name (which namespace this index belongs to) +// 4: index_type (default value is BWTREE) +// 5: index_constraint +// 6: unique_keys (is this index supports duplicate keys) +// 7: indexed_attributes (indicate which table columns this index indexes. For // example a value of 0 2 would mean that the first and the third table columns // make up the index.) // // Indexes: (index offset: indexed columns) // 0: index_oid (unique & primary key) -// 1: index_name (unique) +// 1: index_name & schema_name (unique) // 2: table_oid (non-unique) // //===----------------------------------------------------------------------===// @@ -48,6 +49,7 @@ class IndexCatalogObject { 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; } @@ -58,6 +60,7 @@ class IndexCatalogObject { 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; @@ -79,15 +82,17 @@ class IndexCatalog : public AbstractCatalog { /** Write Related API */ bool InsertIndex(oid_t index_oid, const std::string &index_name, - oid_t table_oid, IndexType index_type, - IndexConstraintType index_constraint, bool unique_keys, - std::vector indekeys, type::AbstractPool *pool, + 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 index_oid, concurrency::TransactionContext *txn); /** Read Related API */ std::shared_ptr GetIndexObject( - const std::string &index_name, concurrency::TransactionContext *txn); + const std::string &index_name, const std::string &schema_name, + concurrency::TransactionContext *txn); private: std::shared_ptr GetIndexObject( @@ -96,22 +101,20 @@ class IndexCatalog : public AbstractCatalog { const std::unordered_map> GetIndexObjects(oid_t table_oid, concurrency::TransactionContext *txn); - private: - oid_t database_oid; - std::unique_ptr InitializeSchema(); enum ColumnId { INDEX_OID = 0, INDEX_NAME = 1, TABLE_OID = 2, - INDEX_TYPE = 3, - INDEX_CONSTRAINT = 4, - UNIQUE_KEYS = 5, - INDEXED_ATTRIBUTES = 6, + SCHEMA_NAME = 3, + INDEX_TYPE = 4, + INDEX_CONSTRAINT = 5, + UNIQUE_KEYS = 6, + INDEXED_ATTRIBUTES = 7, // Add new columns here in creation order }; - std::vector all_column_ids = {0, 1, 2, 3, 4, 5, 6}; + std::vector all_column_ids = {0, 1, 2, 3, 4, 5, 6, 7}; enum IndexId { PRIMARY_KEY = 0, diff --git a/src/include/catalog/index_metrics_catalog.h b/src/include/catalog/index_metrics_catalog.h index 7edf26790a3..7b806623565 100644 --- a/src/include/catalog/index_metrics_catalog.h +++ b/src/include/catalog/index_metrics_catalog.h @@ -14,7 +14,6 @@ // pg_index_metrics // // Schema: (column offset: column_name) -// 0: database_oid // 1: table_oid // 2: index_oid // 3: reads @@ -46,9 +45,9 @@ class IndexMetricsCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // Write Related API //===--------------------------------------------------------------------===// - bool InsertIndexMetrics(oid_t database_oid, 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 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); @@ -60,13 +59,12 @@ class IndexMetricsCatalog : public AbstractCatalog { private: enum ColumnId { - DATABASE_OID = 0, - TABLE_OID = 1, - INDEX_OID = 2, - READS = 3, - DELETES = 4, - INSERTS = 5, - TIME_STAMP = 6, + TABLE_OID = 0, + INDEX_OID = 1, + READS = 2, + DELETES = 3, + INSERTS = 4, + TIME_STAMP = 5, // Add new columns here in creation order }; diff --git a/src/include/catalog/query_metrics_catalog.h b/src/include/catalog/query_metrics_catalog.h index c24e90e14fc..63986324350 100644 --- a/src/include/catalog/query_metrics_catalog.h +++ b/src/include/catalog/query_metrics_catalog.h @@ -15,18 +15,17 @@ // // Schema: (column offset: column_name) // 0: name (pkey) -// 1: database_oid -// 2: num_params -// 3: param_types -// 4: param_formats -// 5: param_values -// 6: reads -// 7: updates -// 8: deletes -// 9: inserts -// 10: latency -// 11: cpu_time -// 12: time_stamp +// 1: num_params +// 2: param_types +// 3: param_formats +// 4: param_values +// 5: reads +// 6: updates +// 7: deletes +// 8: inserts +// 9: latency +// 10: cpu_time +// 11: time_stamp // // //===----------------------------------------------------------------------===// @@ -72,18 +71,17 @@ class QueryMetricsCatalog : public AbstractCatalog { enum ColumnId { NAME = 0, - DATABASE_OID = 1, - NUM_PARAMS = 2, - PARAM_TYPES = 3, - PARAM_FORMATS = 4, - PARAM_VALUES = 5, - READS = 6, - UPDATES = 7, - DELETES = 8, - INSERTS = 9, - LATENCY = 10, - CPU_TIME = 11, - TIME_STAMP = 12, + NUM_PARAMS = 1, + PARAM_TYPES = 2, + PARAM_FORMATS = 3, + PARAM_VALUES = 4, + READS = 5, + UPDATES = 6, + DELETES = 7, + INSERTS = 8, + LATENCY = 9, + CPU_TIME = 10, + TIME_STAMP = 11, // Add new columns here in creation order }; diff --git a/src/include/catalog/schema_catalog.h b/src/include/catalog/schema_catalog.h new file mode 100644 index 00000000000..2d9e06693d7 --- /dev/null +++ b/src/include/catalog/schema_catalog.h @@ -0,0 +1,98 @@ +//===----------------------------------------------------------------------===// +// +// Peloton +// +// schema_catalog.h +// +// Identification: src/include/catalog/schema_catalog.h +// +// Copyright (c) 2015-17, Carnegie Mellon University Database Group +// +//===----------------------------------------------------------------------===// + +//===----------------------------------------------------------------------===// +// pg_namespace +// +// Schema: (column offset: column_name) +// 0: schema_oid (pkey) +// 1: schema_name +// +// Indexes: (index offset: indexed columns) +// 0: schema_oid (unique & primary key) +// 1: schema_name (unique) +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "catalog/abstract_catalog.h" +#include "executor/logical_tile.h" + +namespace peloton { +namespace catalog { + +class SchemaCatalogObject { + friend class DatabaseCatalogObject; + + public: + SchemaCatalogObject(executor::LogicalTile *tile, + concurrency::TransactionContext *txn); + + 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; + // Pointer to its corresponding transaction + // This object is only visible during this transaction + concurrency::TransactionContext *txn; +}; + +class SchemaCatalog : public AbstractCatalog { + friend class SchemaCatalogObject; + friend class Catalog; + + public: + SchemaCatalog(storage::Database *peloton, type::AbstractPool *pool, + concurrency::TransactionContext *txn); + + ~SchemaCatalog(); + + inline oid_t GetNextOid() { return oid_++ | SCHEMA_OID_MASK; } + + //===--------------------------------------------------------------------===// + // 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); + + //===--------------------------------------------------------------------===// + // Read Related API + //===--------------------------------------------------------------------===// + std::shared_ptr GetSchemaObject( + const std::string &schema_name, concurrency::TransactionContext *txn); + + private: + std::unique_ptr InitializeSchema(); + + enum ColumnId { + SCHEMA_OID = 0, + SCHEMA_NAME = 1, + // Add new columns here in creation order + }; + std::vector all_column_ids = {0, 1}; + + enum IndexId { + PRIMARY_KEY = 0, + SKEY_SCHEMA_NAME = 1, + // Add new indexes here in creation order + }; +}; + +} // namespace catalog +} // namespace peloton diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h index 0d192957761..7c9345867e3 100644 --- a/src/include/catalog/system_catalogs.h +++ b/src/include/catalog/system_catalogs.h @@ -15,11 +15,12 @@ #include #include "catalog/database_catalog.h" -#include "catalog/table_catalog.h" -#include "catalog/trigger_catalog.h" -#include "catalog/table_metrics_catalog.h" #include "catalog/index_metrics_catalog.h" #include "catalog/query_metrics_catalog.h" +#include "catalog/schema_catalog.h" +#include "catalog/table_catalog.h" +#include "catalog/table_metrics_catalog.h" +#include "catalog/trigger_catalog.h" namespace peloton { @@ -28,8 +29,8 @@ class Database; } // namespace storage namespace catalog { - class DatabaseCatalog; +class SchemaCatalog; class TableCatalog; class IndexCatalog; class ColumnCatalog; @@ -52,36 +53,49 @@ class SystemCatalogs { } return pg_attribute; } + + SchemaCatalog *GetSchemaCatalog() { + if (!pg_namespace) { + throw CatalogException("schema catalog has not been initialized"); + } + return pg_namespace; + } + TableCatalog *GetTableCatalog() { if (!pg_table) { throw CatalogException("Table catalog has not been initialized"); } return pg_table; } + IndexCatalog *GetIndexCatalog() { if (!pg_index) { throw CatalogException("Index catalog has not been initialized"); } return pg_index; } + TriggerCatalog *GetTriggerCatalog() { if (!pg_trigger) { throw CatalogException("Trigger catalog has not been initialized"); } return pg_trigger; } + TableMetricsCatalog *GetTableMetricsCatalog() { if (!pg_table_metrics) { throw CatalogException("Table metrics catalog has not been initialized"); } return pg_table_metrics; } + IndexMetricsCatalog *GetIndexMetricsCatalog() { if (!pg_index_metrics) { throw CatalogException("Index metrics catalog has not been initialized"); } return pg_index_metrics; } + QueryMetricsCatalog *GetQueryMetricsCatalog() { if (!pg_query_metrics) { throw CatalogException("Query metrics catalog has not been initialized"); @@ -91,6 +105,7 @@ class SystemCatalogs { private: ColumnCatalog *pg_attribute; + SchemaCatalog *pg_namespace; TableCatalog *pg_table; IndexCatalog *pg_index; diff --git a/src/include/catalog/table_catalog.h b/src/include/catalog/table_catalog.h index 1269d3fe31a..0dfc3f51fa9 100644 --- a/src/include/catalog/table_catalog.h +++ b/src/include/catalog/table_catalog.h @@ -16,11 +16,13 @@ // Schema: (column position: column_name) // 0: table_oid (pkey) // 1: table_name, -// 2: database_oid(the database oid that this table belongs to) +// 2: schema_name (the namespace name that this table belongs to) +// 3: database_oid +// 4: version_id: for fast ddl(alter table) // // Indexes: (index offset: indexed columns) // 0: table_oid (unique & primary key) -// 1: table_name (unique) +// 1: table_name & schema_name(unique) // 2: database_oid (non-unique) // //===----------------------------------------------------------------------===// @@ -73,6 +75,7 @@ class TableCatalogObject { inline oid_t GetTableOid() { return table_oid; } inline const std::string &GetTableName() { return table_name; } + inline const std::string &GetSchemaName() { return schema_name; } inline oid_t GetDatabaseOid() { return database_oid; } inline uint32_t GetVersionId() { return version_id; } @@ -80,6 +83,7 @@ class TableCatalogObject { // member variables oid_t table_oid; std::string table_name; + std::string schema_name; oid_t database_oid; uint32_t version_id; @@ -129,7 +133,8 @@ class TableCatalog : public AbstractCatalog { // write Related API //===--------------------------------------------------------------------===// bool InsertTable(oid_t table_oid, const std::string &table_name, - oid_t database_oid, type::AbstractPool *pool, + const std::string &schema_name, oid_t database_oid, + type::AbstractPool *pool, concurrency::TransactionContext *txn); bool DeleteTable(oid_t table_oid, concurrency::TransactionContext *txn); @@ -143,23 +148,22 @@ class TableCatalog : public AbstractCatalog { std::shared_ptr GetTableObject( oid_t table_oid, concurrency::TransactionContext *txn); std::shared_ptr GetTableObject( - const std::string &table_name, concurrency::TransactionContext *txn); + const std::string &table_name, const std::string &schema_name, + concurrency::TransactionContext *txn); std::unordered_map> - GetTableObjects(oid_t database_oid, concurrency::TransactionContext *txn); - - private: - oid_t database_oid; + GetTableObjects(concurrency::TransactionContext *txn); std::unique_ptr InitializeSchema(); enum ColumnId { TABLE_OID = 0, TABLE_NAME = 1, - DATABASE_OID = 2, - VERSION_ID = 3, + SCHEMA_NAME = 2, + DATABASE_OID = 3, + VERSION_ID = 4, // 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, 4}; enum IndexId { PRIMARY_KEY = 0, diff --git a/src/include/catalog/table_metrics_catalog.h b/src/include/catalog/table_metrics_catalog.h index 0a3496bd8cb..38c59a76857 100644 --- a/src/include/catalog/table_metrics_catalog.h +++ b/src/include/catalog/table_metrics_catalog.h @@ -14,7 +14,6 @@ // pg_table_metrics // // Schema: (column offset: column_name) -// 0: database_oid // 1: table_oid // 2: reads // 3: updates @@ -46,9 +45,9 @@ class TableMetricsCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // Write Related API //===--------------------------------------------------------------------===// - bool InsertTableMetrics(oid_t database_oid, oid_t table_oid, int64_t reads, - int64_t updates, int64_t deletes, int64_t inserts, - int64_t time_stamp, type::AbstractPool *pool, + 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); @@ -60,13 +59,12 @@ class TableMetricsCatalog : public AbstractCatalog { private: enum ColumnId { - DATABASE_OID = 0, - TABLE_OID = 1, - READS = 2, - UPDATES = 3, - DELETES = 4, - INSERTS = 5, - TIME_STAMP = 6, + TABLE_OID = 0, + READS = 1, + UPDATES = 2, + DELETES = 3, + INSERTS = 4, + TIME_STAMP = 5, // Add new columns here in creation order }; diff --git a/src/include/catalog/trigger_catalog.h b/src/include/catalog/trigger_catalog.h index 20038aa441b..6b71792e42c 100644 --- a/src/include/catalog/trigger_catalog.h +++ b/src/include/catalog/trigger_catalog.h @@ -15,7 +15,7 @@ // // Schema: (column offset: column_name) // 0: oid (pkey) -// 1: tgrelid : table_name +// 1: tgrelid : table_oid // 2: tgname : trigger_name // 3: tgfoid : function_oid // 4: tgtype : trigger_type @@ -60,12 +60,7 @@ class TriggerCatalog : public AbstractCatalog { type::Value timestamp, type::AbstractPool *pool, concurrency::TransactionContext *txn); - ResultType DropTrigger(const std::string &database_name, - const std::string &table_name, - const std::string &trigger_name, - concurrency::TransactionContext *txn); - - ResultType DropTrigger(const oid_t oid_tdatabase_oid, const oid_t table_oid, + ResultType DropTrigger(const oid_t database_oid, const oid_t table_oid, const std::string &trigger_name, concurrency::TransactionContext *txn); diff --git a/src/include/common/internal_types.h b/src/include/common/internal_types.h index 59fcf28604f..17020512944 100644 --- a/src/include/common/internal_types.h +++ b/src/include/common/internal_types.h @@ -60,7 +60,6 @@ class ItemPointerComparator; #define INVALID_RATIO -1 -#define DEFAULT_DB_ID 16777216 #define DEFAULT_DB_NAME "default_database" extern int DEFAULT_TUPLES_PER_TILEGROUP; @@ -615,7 +614,8 @@ enum class CreateType { TABLE = 2, // table create type INDEX = 3, // index create type CONSTRAINT = 4, // constraint create type - TRIGGER = 5 // trigger create type + TRIGGER = 5, // trigger create type + SCHEMA = 6, // schema create type }; std::string CreateTypeToString(CreateType type); CreateType StringToCreateType(const std::string &str); @@ -631,7 +631,8 @@ enum class DropType { TABLE = 2, // table drop type INDEX = 3, // index drop type CONSTRAINT = 4, // constraint drop type - TRIGGER = 5 // trigger drop type + TRIGGER = 5, // trigger drop type + SCHEMA = 6, // trigger drop type }; std::string DropTypeToString(DropType type); DropType StringToDropType(const std::string &str); diff --git a/src/include/executor/create_executor.h b/src/include/executor/create_executor.h index 1802081ac62..19b29dd24aa 100644 --- a/src/include/executor/create_executor.h +++ b/src/include/executor/create_executor.h @@ -23,18 +23,18 @@ class DataTable; namespace planner { class AbstractPlan; class CreatePlan; -} +} // namespace planner namespace executor { class CreateExecutor : public AbstractExecutor { public: - CreateExecutor(const CreateExecutor &) = delete; - CreateExecutor &operator=(const CreateExecutor &) = delete; - CreateExecutor(CreateExecutor &&) = delete; - CreateExecutor &operator=(CreateExecutor &&) = delete; + CreateExecutor(const CreateExecutor &) = delete; + CreateExecutor &operator=(const CreateExecutor &) = delete; + CreateExecutor(CreateExecutor &&) = delete; + CreateExecutor &operator=(CreateExecutor &&) = delete; - CreateExecutor(const planner::AbstractPlan *node, + CreateExecutor(const planner::AbstractPlan *node, ExecutorContext *executor_context); ~CreateExecutor() {} @@ -46,6 +46,8 @@ class CreateExecutor : public AbstractExecutor { bool CreateDatabase(const planner::CreatePlan &node); + bool CreateSchema(const planner::CreatePlan &node); + bool CreateTable(const planner::CreatePlan &node); bool CreateIndex(const planner::CreatePlan &node); @@ -57,7 +59,6 @@ class CreateExecutor : public AbstractExecutor { // Abstract Pool to hold strings std::unique_ptr pool_; - }; } // namespace executor diff --git a/src/include/executor/drop_executor.h b/src/include/executor/drop_executor.h index ab1d82b5aa2..4454ebe2b5d 100644 --- a/src/include/executor/drop_executor.h +++ b/src/include/executor/drop_executor.h @@ -48,6 +48,9 @@ class DropExecutor : public AbstractExecutor { bool DropDatabase(const planner::DropPlan &node, concurrency::TransactionContext *txn); + bool DropSchema(const planner::DropPlan &node, + concurrency::TransactionContext *txn); + bool DropTable(const planner::DropPlan &node, concurrency::TransactionContext *txn); diff --git a/src/include/parser/analyze_statement.h b/src/include/parser/analyze_statement.h index 343c4e74f73..b0c5e5e6ea2 100644 --- a/src/include/parser/analyze_statement.h +++ b/src/include/parser/analyze_statement.h @@ -52,6 +52,13 @@ class AnalyzeStatement : public SQLStatement { return analyze_table->GetDatabaseName(); } + std::string GetSchemaName() const { + if (analyze_table == nullptr) { + return INVALID_NAME; + } + return analyze_table->GetSchemaName(); + } + virtual void Accept(SqlNodeVisitor *v) override { v->Visit(this); } const std::string GetInfo(int num_indent) const override; diff --git a/src/include/parser/create_statement.h b/src/include/parser/create_statement.h index 1abf45fa968..f83b24222ef 100644 --- a/src/include/parser/create_statement.h +++ b/src/include/parser/create_statement.h @@ -13,11 +13,11 @@ #pragma once #include +#include "common/internal_types.h" #include "common/sql_node_visitor.h" #include "expression/abstract_expression.h" -#include "parser/sql_statement.h" #include "parser/select_statement.h" -#include "common/internal_types.h" +#include "parser/sql_statement.h" namespace peloton { namespace parser { @@ -240,8 +240,6 @@ class CreateStatement : public TableRefStatement { IndexType index_type; std::string index_name; - std::string schema_name; - std::string view_name; std::unique_ptr view_query; diff --git a/src/include/parser/delete_statement.h b/src/include/parser/delete_statement.h index 65be25c5245..3c764cb5678 100644 --- a/src/include/parser/delete_statement.h +++ b/src/include/parser/delete_statement.h @@ -45,6 +45,8 @@ class DeleteStatement : public SQLStatement { std::string GetDatabaseName() const { return table_ref->GetDatabaseName(); } + std::string GetSchemaName() const { return table_ref->GetSchemaName(); } + virtual void Accept(SqlNodeVisitor *v) override { v->Visit(this); } const std::string GetInfo(int num_indent) const override; diff --git a/src/include/parser/drop_statement.h b/src/include/parser/drop_statement.h index a716d3cabf8..d4205528cef 100644 --- a/src/include/parser/drop_statement.h +++ b/src/include/parser/drop_statement.h @@ -12,8 +12,8 @@ #pragma once -#include "parser/sql_statement.h" #include "common/sql_node_visitor.h" +#include "parser/sql_statement.h" namespace peloton { namespace parser { @@ -40,13 +40,6 @@ class DropStatement : public TableRefStatement { missing_(false), cascade_(false) {} - DropStatement(EntityType type, std::string table_name_of_trigger, - std::string trigger_name) - : TableRefStatement(StatementType::DROP), - type_(type), - table_name_of_trigger_(table_name_of_trigger), - trigger_name_(trigger_name) {} - EntityType GetDropType() { return type_; } bool GetMissing() { return missing_; } @@ -69,12 +62,6 @@ class DropStatement : public TableRefStatement { void SetPrepStmt(char *prep_stmt) { prep_stmt_ = prep_stmt; } - std::string &GetSchemaName() { return schema_name_; } - - void SetSchemaName(std::string &schema_name) { schema_name_ = schema_name; } - - void SetSchemaName(char *schema_name) { schema_name_ = schema_name; } - std::string &GetTriggerName() { return trigger_name_; } void SetTriggerName(std::string &trigger_name) { @@ -83,15 +70,7 @@ class DropStatement : public TableRefStatement { void SetTriggerName(char *trigger_name) { trigger_name_ = trigger_name; } - std::string &GetTriggerTableName() { return table_name_of_trigger_; } - - void SetTriggerTableName(std::string &table_name_of_trigger) { - table_name_of_trigger_ = table_name_of_trigger; - } - - void SetTriggerTableName(char *table_name_of_trigger) { - table_name_of_trigger_ = table_name_of_trigger; - } + std::string GetTriggerTableName() { return GetTableName(); } virtual ~DropStatement() {} @@ -116,11 +95,7 @@ class DropStatement : public TableRefStatement { std::string prep_stmt_; // drop trigger - std::string table_name_of_trigger_; std::string trigger_name_; - - // drop schema - std::string schema_name_; }; } // namespace parser diff --git a/src/include/parser/insert_statement.h b/src/include/parser/insert_statement.h index 4b6e8578077..1bd8a1fdbd6 100644 --- a/src/include/parser/insert_statement.h +++ b/src/include/parser/insert_statement.h @@ -39,6 +39,10 @@ class InsertStatement : public SQLStatement { table_ref_->TryBindDatabaseName(default_database_name); } + inline std::string GetSchemaName() const { + return table_ref_->GetSchemaName(); + } + inline std::string GetDatabaseName() const { return table_ref_->GetDatabaseName(); } diff --git a/src/include/parser/sql_statement.h b/src/include/parser/sql_statement.h index c76c9267c18..012f4090cb9 100644 --- a/src/include/parser/sql_statement.h +++ b/src/include/parser/sql_statement.h @@ -19,7 +19,7 @@ #include -#include "common/internal_types.h" +#include "catalog/catalog_defaults.h" #include "common/macros.h" #include "common/printable.h" #include "common/sql_node_visitor.h" @@ -30,9 +30,9 @@ namespace parser { struct TableInfo { ~TableInfo() {} - + // member variables std::string table_name; - + std::string schema_name; std::string database_name; }; @@ -71,12 +71,20 @@ class TableRefStatement : public SQLStatement { if (table_info_->database_name.empty()) table_info_->database_name = default_database_name; + // if schema name is not specified, then it's default value is "public" + if (table_info_->schema_name.empty()) + table_info_->schema_name = DEFUALT_SCHEMA_NAME; } virtual inline std::string GetTableName() const { return table_info_->table_name; } + // Get the name of the schema(namespace) of this table + virtual inline std::string GetSchemaName() const { + return table_info_->schema_name; + } + // Get the name of the database of this table virtual inline std::string GetDatabaseName() const { return table_info_->database_name; diff --git a/src/include/parser/table_ref.h b/src/include/parser/table_ref.h index 9749ab0a0df..e3b4fab31d6 100644 --- a/src/include/parser/table_ref.h +++ b/src/include/parser/table_ref.h @@ -15,11 +15,11 @@ #include #include +#include "common/internal_types.h" +#include "common/sql_node_visitor.h" #include "expression/abstract_expression.h" #include "parser/sql_statement.h" #include "util/string_util.h" -#include "common/sql_node_visitor.h" -#include "common/internal_types.h" namespace peloton { namespace parser { @@ -56,8 +56,6 @@ struct TableRef { TableReferenceType type; - std::string schema; - // Expression of database name and table name std::unique_ptr table_info_ = nullptr; @@ -67,9 +65,6 @@ struct TableRef { std::vector> list; std::unique_ptr join; - // Convenience accessor methods - inline bool HasSchema() { return !schema.empty(); } - // Try to bind the database name to the node if not specified inline void TryBindDatabaseName(std::string default_database_name) { if (table_info_ == nullptr) { @@ -79,11 +74,10 @@ struct TableRef { if (table_info_->database_name.empty()) { table_info_->database_name = default_database_name; } - } - // Get the name of the database of this table - inline std::string GetDatabaseName() const { - return table_info_->database_name; + if (table_info_->schema_name.empty()) { + table_info_->schema_name = DEFUALT_SCHEMA_NAME; + } } // Get the name of the table @@ -96,6 +90,14 @@ struct TableRef { inline std::string GetTableName() const { return table_info_->table_name; } + // Get the name of the schema of this table + inline std::string GetSchemaName() const { return table_info_->schema_name; } + + // Get the name of the database of this table + inline std::string GetDatabaseName() const { + return table_info_->database_name; + } + const std::string GetInfo(int num_indent) const; void Accept(SqlNodeVisitor *v) { v->Visit(this); } diff --git a/src/include/planner/analyze_plan.h b/src/include/planner/analyze_plan.h index c6bf0360e68..b5b162c5d5e 100644 --- a/src/include/planner/analyze_plan.h +++ b/src/include/planner/analyze_plan.h @@ -40,12 +40,12 @@ class AnalyzePlan : public AbstractPlan { explicit AnalyzePlan(storage::DataTable *table); - explicit AnalyzePlan(std::string table_name, + explicit AnalyzePlan(std::string table_name, std::string schema_name, std::string database_name, concurrency::TransactionContext *txn); - explicit AnalyzePlan(std::string table_name, - std::string database_name, + explicit AnalyzePlan(std::string table_name, std::string schema_name, + std::string database_name, std::vector column_names, concurrency::TransactionContext *txn); @@ -67,9 +67,9 @@ class AnalyzePlan : public AbstractPlan { } private: - storage::DataTable* target_table_ = nullptr; + storage::DataTable *target_table_ = nullptr; std::string table_name_; - std::vector column_names_; + std::vector column_names_; }; } // namespace planner diff --git a/src/include/planner/create_plan.h b/src/include/planner/create_plan.h index e0e9f84add8..ecf6a0524fe 100644 --- a/src/include/planner/create_plan.h +++ b/src/include/planner/create_plan.h @@ -12,8 +12,8 @@ #pragma once -#include "planner/abstract_plan.h" #include "parser/create_statement.h" +#include "planner/abstract_plan.h" namespace peloton { namespace catalog { @@ -50,11 +50,13 @@ struct ForeignKeyInfo { class CreatePlan : public AbstractPlan { public: CreatePlan() = delete; - + // This construnctor is for Create Database Test used only explicit CreatePlan(std::string database_name, CreateType c_type); - explicit CreatePlan(std::string table_name, std::string database_name, + // This construnctor is for copy() used only + explicit CreatePlan(std::string table_name, std::string schema_name, + std::string database_name, std::unique_ptr schema, CreateType c_type); @@ -66,7 +68,7 @@ class CreatePlan : public AbstractPlan { std::unique_ptr Copy() const { return std::unique_ptr(new CreatePlan( - table_name, database_name, + table_name, schema_name, database_name, std::unique_ptr(table_schema), create_type)); } @@ -74,6 +76,8 @@ class CreatePlan : public AbstractPlan { std::string GetTableName() const { return table_name; } + std::string GetSchemaName() const { return schema_name; } + std::string GetDatabaseName() const { return database_name; } catalog::Schema *GetSchema() const { return table_schema; } @@ -86,7 +90,9 @@ class CreatePlan : public AbstractPlan { std::vector GetIndexAttributes() const { return index_attrs; } - inline std::vector GetForeignKeys() const { return foreign_keys; } + inline std::vector GetForeignKeys() const { + return foreign_keys; + } std::vector GetKeyAttrs() const { return key_attrs; } void SetKeyAttrs(std::vector p_key_attrs) { key_attrs = p_key_attrs; } @@ -108,16 +114,19 @@ class CreatePlan : public AbstractPlan { int16_t GetTriggerType() const { return trigger_type; } -protected: - // This is a helper method for extracting foreign key information - // and storing it in an internal struct. - void ProcessForeignKeyConstraint(const std::string &table_name, - const parser::ColumnDefinition *col); + protected: + // This is a helper method for extracting foreign key information + // and storing it in an internal struct. + void ProcessForeignKeyConstraint(const std::string &table_name, + const parser::ColumnDefinition *col); private: // Table Name std::string table_name; + // namespace Name + std::string schema_name; + // Database Name std::string database_name; diff --git a/src/include/planner/drop_plan.h b/src/include/planner/drop_plan.h index 81df04d9efc..c5593680202 100644 --- a/src/include/planner/drop_plan.h +++ b/src/include/planner/drop_plan.h @@ -41,6 +41,7 @@ class DropPlan : public AbstractPlan { const std::string GetInfo() const { std::string returned_string = "DropPlan:\n"; returned_string += " Table name: " + table_name; + returned_string += " Schema name : " + schema_name; returned_string += " Database name : " + database_name; return returned_string; } @@ -53,6 +54,8 @@ class DropPlan : public AbstractPlan { std::string GetTableName() const { return table_name; } + std::string GetSchemaName() const { return schema_name; } + std::string GetTriggerName() const { return trigger_name; } std::string GetIndexName() const { return index_name; } @@ -70,6 +73,9 @@ class DropPlan : public AbstractPlan { // Database Name std::string database_name; + // namespace Name + std::string schema_name; + std::string trigger_name; std::string index_name; bool missing; diff --git a/src/include/planner/plan_util.h b/src/include/planner/plan_util.h index c61df062f8c..2979fd5ea6b 100644 --- a/src/include/planner/plan_util.h +++ b/src/include/planner/plan_util.h @@ -56,11 +56,10 @@ class PlanUtil { const planner::AbstractPlan *plan); /** - * @brief Get the indexes affected by a given query - * @param CatalogCache - * @param SQLStatement - * @return set of affected index object ids - */ + * @brief Get the indexes affected by a given query + * @param SQLStatement + * @return set of affected index object ids + */ static const std::set GetAffectedIndexes( catalog::CatalogCache &catalog_cache, const parser::SQLStatement &sql_stmt); diff --git a/src/include/statistics/stats_aggregator.h b/src/include/statistics/stats_aggregator.h index 34d609bcfdb..5f5fcdd1911 100644 --- a/src/include/statistics/stats_aggregator.h +++ b/src/include/statistics/stats_aggregator.h @@ -12,20 +12,20 @@ #pragma once -#include -#include -#include -#include #include -#include #include +#include +#include +#include +#include +#include #include "common/logger.h" #include "common/macros.h" +#include "concurrency/transaction_context.h" #include "statistics/backend_stats_context.h" -#include "storage/database.h" #include "storage/data_table.h" -#include "concurrency/transaction_context.h" +#include "storage/database.h" //===--------------------------------------------------------------------===// // GUC Variables @@ -68,8 +68,8 @@ class StatsAggregator { //===--------------------------------------------------------------------===// // Global singleton - static StatsAggregator &GetInstance(int64_t aggregation_interval_ms = - STATS_AGGREGATION_INTERVAL_MS); + static StatsAggregator &GetInstance( + int64_t aggregation_interval_ms = STATS_AGGREGATION_INTERVAL_MS); // Get the aggregated stats history of all exited threads inline BackendStatsContext &GetStatsHistory() { return stats_history_; } @@ -89,9 +89,6 @@ class StatsAggregator { // instead of explicitly unregistering it. void UnregisterContext(std::thread::id id); - // Utility function to get the metric table - storage::DataTable *GetMetricTable(std::string table_name); - // Aggregate the stats of current living threads void Aggregate(int64_t &interval_cnt, double &alpha, double &weighted_avg_throughput); @@ -162,7 +159,8 @@ class StatsAggregator { concurrency::TransactionContext *txn); // Write all query metrics to a metric table - void UpdateQueryMetrics(int64_t time_stamp, concurrency::TransactionContext *txn); + void UpdateQueryMetrics(int64_t time_stamp, + concurrency::TransactionContext *txn); // Aggregate stats periodically void RunAggregator(); diff --git a/src/include/storage/database.h b/src/include/storage/database.h index d8eca8a4373..630b3729bcf 100644 --- a/src/include/storage/database.h +++ b/src/include/storage/database.h @@ -54,9 +54,6 @@ class Database : public Printable { // Throw CatalogException if such table is not found storage::DataTable *GetTableWithOid(const oid_t table_oid) const; - // Throw CatalogException if such table is not found - storage::DataTable *GetTableWithName(const std::string &table_name) const; - oid_t GetTableCount() const; void DropTableWithOid(const oid_t table_oid); diff --git a/src/optimizer/optimizer.cpp b/src/optimizer/optimizer.cpp index 0a84013ca7c..62f813ec876 100644 --- a/src/optimizer/optimizer.cpp +++ b/src/optimizer/optimizer.cpp @@ -21,16 +21,16 @@ #include "common/exception.h" #include "optimizer/binding.h" +#include "optimizer/input_column_deriver.h" #include "optimizer/operator_visitor.h" +#include "optimizer/optimize_context.h" +#include "optimizer/optimizer_task_pool.h" +#include "optimizer/plan_generator.h" #include "optimizer/properties.h" #include "optimizer/property_enforcer.h" #include "optimizer/query_to_operator_transformer.h" -#include "optimizer/input_column_deriver.h" -#include "optimizer/plan_generator.h" #include "optimizer/rule.h" #include "optimizer/rule_impls.h" -#include "optimizer/optimizer_task_pool.h" -#include "optimizer/optimize_context.h" #include "parser/create_statement.h" #include "planner/analyze_plan.h" @@ -165,11 +165,13 @@ 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->GetTableName(), txn); + create_stmt->GetDatabaseName(), create_stmt->GetSchemaName(), + create_stmt->GetTableName(), txn); 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->GetTableName(), txn); + create_stmt->GetDatabaseName(), create_stmt->GetSchemaName(), + create_stmt->GetTableName(), txn); for (auto column_name : create_plan->GetIndexAttributes()) { auto column_object = table_object->GetColumnObject(column_name); // Check if column is missing diff --git a/src/optimizer/query_to_operator_transformer.cpp b/src/optimizer/query_to_operator_transformer.cpp index a0c1243472b..ff75140d5f5 100644 --- a/src/optimizer/query_to_operator_transformer.cpp +++ b/src/optimizer/query_to_operator_transformer.cpp @@ -215,7 +215,8 @@ void QueryToOperatorTransformer::Visit(parser::TableRef *node) { if (node->list.size() == 1) node = node->list.at(0).get(); std::shared_ptr target_table = catalog::Catalog::GetInstance()->GetTableObject( - node->GetDatabaseName(), node->GetTableName(), txn_); + node->GetDatabaseName(), node->GetSchemaName(), + node->GetTableName(), txn_); std::string table_alias = StringUtil::Lower(std::string(node->GetTableAlias())); output_expr_ = std::make_shared(LogicalGet::make( @@ -232,9 +233,8 @@ void QueryToOperatorTransformer::Visit( UNUSED_ATTRIBUTE parser::CreateStatement *op) {} void QueryToOperatorTransformer::Visit(parser::InsertStatement *op) { std::shared_ptr target_table = - catalog::Catalog::GetInstance() - ->GetDatabaseObject(op->GetDatabaseName(), txn_) - ->GetTableObject(op->GetTableName()); + catalog::Catalog::GetInstance()->GetTableObject( + op->GetDatabaseName(), op->GetSchemaName(), op->GetTableName(), txn_); if (op->type == InsertType::SELECT) { auto insert_expr = std::make_shared( @@ -310,9 +310,8 @@ void QueryToOperatorTransformer::Visit(parser::InsertStatement *op) { } void QueryToOperatorTransformer::Visit(parser::DeleteStatement *op) { - auto target_table = catalog::Catalog::GetInstance() - ->GetDatabaseObject(op->GetDatabaseName(), txn_) - ->GetTableObject(op->GetTableName()); + auto target_table = catalog::Catalog::GetInstance()->GetTableObject( + op->GetDatabaseName(), op->GetSchemaName(), op->GetTableName(), txn_); std::shared_ptr table_scan; if (op->expr != nullptr) { std::vector predicates = @@ -337,10 +336,9 @@ void QueryToOperatorTransformer::Visit( void QueryToOperatorTransformer::Visit( UNUSED_ATTRIBUTE parser::TransactionStatement *op) {} void QueryToOperatorTransformer::Visit(parser::UpdateStatement *op) { - auto target_table = - catalog::Catalog::GetInstance() - ->GetDatabaseObject(op->table->GetDatabaseName(), txn_) - ->GetTableObject(op->table->GetTableName()); + auto target_table = catalog::Catalog::GetInstance()->GetTableObject( + op->table->GetDatabaseName(), op->table->GetSchemaName(), + op->table->GetTableName(), txn_); std::shared_ptr table_scan; auto update_expr = std::make_shared( diff --git a/src/optimizer/stats/tuple_samples_storage.cpp b/src/optimizer/stats/tuple_samples_storage.cpp index eb86613e761..9ae85256758 100644 --- a/src/optimizer/stats/tuple_samples_storage.cpp +++ b/src/optimizer/stats/tuple_samples_storage.cpp @@ -65,11 +65,13 @@ void TupleSamplesStorage::AddSamplesTable( auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - catalog->CreateTable(std::string(SAMPLES_DB_NAME), samples_table_name, + catalog->CreateTable(std::string(SAMPLES_DB_NAME), + std::string(DEFUALT_SCHEMA_NAME), samples_table_name, std::move(schema_ptr), txn, is_catalog); - auto samples_table = catalog->GetTableWithName(std::string(SAMPLES_DB_NAME), - samples_table_name, txn); + auto samples_table = catalog->GetTableWithName( + std::string(SAMPLES_DB_NAME), std::string(DEFUALT_SCHEMA_NAME), + samples_table_name, txn); for (auto &tuple : sampled_tuples) { InsertSampleTuple(samples_table, std::move(tuple), txn); @@ -91,7 +93,9 @@ ResultType TupleSamplesStorage::DeleteSamplesTable( GenerateSamplesTableName(database_id, table_id); ResultType result = ResultType::FAILURE; try { - result = catalog->DropTable(SAMPLES_DB_NAME, samples_table_name, txn); + result = catalog->DropTable(std::string(SAMPLES_DB_NAME), + std::string(DEFUALT_SCHEMA_NAME), + samples_table_name, txn); } catch (CatalogException &e) { // Samples table does not exist, no need to drop } @@ -144,9 +148,9 @@ ResultType TupleSamplesStorage::CollectSamplesForTable( } std::unique_ptr>> -TupleSamplesStorage::GetTuplesWithSeqScan(storage::DataTable *data_table, - std::vector column_offsets, - concurrency::TransactionContext *txn) { +TupleSamplesStorage::GetTuplesWithSeqScan( + storage::DataTable *data_table, std::vector column_offsets, + concurrency::TransactionContext *txn) { if (txn == nullptr) { LOG_TRACE("Do not have transaction to perform the sequential scan"); return nullptr; @@ -182,8 +186,9 @@ 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(SAMPLES_DB_NAME, samples_table_name, txn); + auto data_table = catalog->GetTableWithName(std::string(SAMPLES_DB_NAME), + std::string(DEFUALT_SCHEMA_NAME), + samples_table_name, txn); auto col_count = data_table->GetSchema()->GetColumnCount(); std::vector column_ids; @@ -208,8 +213,9 @@ void TupleSamplesStorage::GetColumnSamples( GenerateSamplesTableName(database_id, table_id); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - auto data_table = - catalog->GetTableWithName(SAMPLES_DB_NAME, samples_table_name, txn); + auto data_table = catalog->GetTableWithName(std::string(SAMPLES_DB_NAME), + std::string(DEFUALT_SCHEMA_NAME), + samples_table_name, txn); std::vector column_ids({column_id}); auto result_tiles = GetTuplesWithSeqScan(data_table, column_ids, txn); diff --git a/src/optimizer/util.cpp b/src/optimizer/util.cpp index ddd98f281a9..0d01e35e8ac 100644 --- a/src/optimizer/util.cpp +++ b/src/optimizer/util.cpp @@ -12,8 +12,8 @@ #include "optimizer/util.h" -#include "concurrency/transaction_manager_factory.h" #include "catalog/query_metrics_catalog.h" +#include "concurrency/transaction_manager_factory.h" #include "expression/expression_util.h" #include "planner/copy_plan.h" #include "planner/seq_scan_plan.h" @@ -161,6 +161,7 @@ std::unique_ptr CreateCopyPlan( auto txn = txn_manager.BeginTransaction(); auto target_table = catalog::Catalog::GetInstance()->GetTableWithName( copy_stmt->cpy_table->GetDatabaseName(), + copy_stmt->cpy_table->GetSchemaName(), copy_stmt->cpy_table->GetTableName(), txn); txn_manager.CommitTransaction(txn); @@ -178,7 +179,8 @@ std::unordered_map> ConstructSelectElementMap( std::vector> &select_list) { std::unordered_map> res; + std::shared_ptr> + res; for (auto &expr : select_list) { std::string alias; if (!expr->alias.empty()) { diff --git a/src/parser/create_statement.cpp b/src/parser/create_statement.cpp index dd52ee70433..40be9a437fa 100644 --- a/src/parser/create_statement.cpp +++ b/src/parser/create_statement.cpp @@ -26,9 +26,11 @@ const std::string CreateStatement::GetInfo(int num_indent) const { os << "Create type: Table" << std::endl; os << StringUtil::Indent(num_indent + 1) << StringUtil::Format("IF NOT EXISTS: %s", - (if_not_exists) ? "True" : "False") << std::endl; + (if_not_exists) ? "True" : "False") + << std::endl; os << StringUtil::Indent(num_indent + 1) - << StringUtil::Format("Table name: %s", GetTableName().c_str());; + << StringUtil::Format("Table name: %s", GetTableName().c_str()); + ; break; } case CreateStatement::CreateType::kDatabase: { @@ -61,7 +63,7 @@ const std::string CreateStatement::GetInfo(int num_indent) const { case CreateStatement::CreateType::kSchema: { os << "Create type: Schema" << std::endl; os << StringUtil::Indent(num_indent + 1) - << StringUtil::Format("Schema name: %s", schema_name.c_str()); + << StringUtil::Format("Schema name: %s", GetSchemaName().c_str()); break; } case CreateStatement::CreateType::kView: { @@ -93,12 +95,13 @@ const std::string CreateStatement::GetInfo(int num_indent) const { } } else { os << StringUtil::Indent(num_indent + 1) - << "-> COLUMN REF : " << col->name << " " + << "-> COLUMN REF : " << col->name + << " " // << col->type << " not null : " << col->not_null << " primary : " << col->primary << " unique " << col->unique << " varlen " << col->varlen; } - os << std::endl; + os << std::endl; } } std::string info = os.str(); diff --git a/src/parser/drop_statement.cpp b/src/parser/drop_statement.cpp index 40e940ed66b..feb266f89f2 100644 --- a/src/parser/drop_statement.cpp +++ b/src/parser/drop_statement.cpp @@ -11,9 +11,9 @@ //===----------------------------------------------------------------------===// #include "parser/drop_statement.h" -#include "util/string_util.h" -#include #include +#include +#include "util/string_util.h" namespace peloton { namespace parser { @@ -38,7 +38,7 @@ const std::string DropStatement::GetInfo(int num_indent) const { case kSchema: { os << "DropType: Schema\n"; os << StringUtil::Indent(num_indent + 1) - << "Schema name: " << schema_name_; + << "Schema name: " << GetSchemaName(); break; } case kIndex: { @@ -61,7 +61,7 @@ const std::string DropStatement::GetInfo(int num_indent) const { case kTrigger: { os << "DropType: Trigger\n"; os << StringUtil::Indent(num_indent + 1) - << "Trigger table name: " << table_name_of_trigger_ << std::endl; + << "Trigger table name: " << GetTableName() << std::endl; os << StringUtil::Indent(num_indent + 1) << "Trigger name: " << trigger_name_; break; diff --git a/src/parser/postgresparser.cpp b/src/parser/postgresparser.cpp index 6c3697499e9..e68f3f15ed3 100644 --- a/src/parser/postgresparser.cpp +++ b/src/parser/postgresparser.cpp @@ -144,19 +144,17 @@ parser::TableRef *PostgresParser::RangeVarTransform(RangeVar *root) { parser::TableRef *result = new parser::TableRef(StringToTableReferenceType("name")); result->table_info_.reset(new parser::TableInfo()); - - if (root->schemaname) { - result->schema = root->schemaname; - result->table_info_->database_name = root->schemaname; - } - // parse alias result->alias = AliasTransform(root->alias); - + // add table name if (root->relname) { result->table_info_->table_name = root->relname; } - + // add schema(namespace) name + if (root->schemaname) { + result->table_info_->schema_name = root->schemaname; + } + // add database name if (root->catalogname) { result->table_info_->database_name = root->catalogname; } @@ -974,8 +972,11 @@ parser::SQLStatement *PostgresParser::CreateTransform(CreateStmt *root) { result->table_info_->table_name = relation->relname; } if (relation->schemaname) { - result->table_info_->database_name = relation->schemaname; - }; + result->table_info_->schema_name = relation->schemaname; + } + if (relation->catalogname) { + result->table_info_->database_name = relation->catalogname; + } std::unordered_set primary_keys; for (auto cell = root->tableElts->head; cell != nullptr; cell = cell->next) { @@ -1213,6 +1214,8 @@ parser::SQLStatement *PostgresParser::CreateIndexTransform(IndexStmt *root) { } result->table_info_.reset(new TableInfo()); result->table_info_->table_name = root->relation->relname; + if (root->relation->schemaname) + result->table_info_->schema_name = root->relation->schemaname; result->index_name = root->idxname; return result; } @@ -1263,7 +1266,8 @@ parser::SQLStatement *PostgresParser::CreateTriggerTransform( result->table_info_.reset(new TableInfo()); result->table_info_->table_name = root->relation->relname; - + if (root->relation->schemaname) + result->table_info_->schema_name = root->relation->schemaname; result->trigger_name = root->trigname; return result; @@ -1288,8 +1292,10 @@ parser::SQLStatement *PostgresParser::CreateSchemaTransform( CreateSchemaStmt *root) { parser::CreateStatement *result = new parser::CreateStatement(CreateStatement::kSchema); + result->table_info_.reset(new parser::TableInfo()); + if (root->schemaname != nullptr) { - result->schema_name = root->schemaname; + result->table_info_->schema_name = root->schemaname; } result->if_not_exists = root->if_not_exists; if (root->authrole != nullptr) { @@ -1299,7 +1305,7 @@ parser::SQLStatement *PostgresParser::CreateSchemaTransform( // Peloton do not need the authrole, the only usage is when no schema name // is specified if (root->schemaname == nullptr) { - result->schema_name = role->rolename; + result->table_info_->schema_name = role->rolename; } } else { delete result; @@ -1377,12 +1383,22 @@ parser::DropStatement *PostgresParser::DropDatabaseTransform( parser::DropStatement *PostgresParser::DropTableTransform(DropStmt *root) { auto result = new DropStatement(DropStatement::EntityType::kTable); result->SetMissing(root->missing_ok); + for (auto cell = root->objects->head; cell != nullptr; cell = cell->next) { auto table_info = new TableInfo{}; auto table_list = reinterpret_cast(cell->data.ptr_value); LOG_TRACE("%d", ((Node *)(table_list->head->data.ptr_value))->type); - table_info->table_name = - reinterpret_cast(table_list->head->data.ptr_value)->val.str; + // if schema name is specified + if (table_list->length == 2) { + table_info->schema_name = + reinterpret_cast(table_list->head->data.ptr_value)->val.str; + table_info->table_name = + reinterpret_cast(table_list->head->next->data.ptr_value) + ->val.str; + } else { + table_info->table_name = + reinterpret_cast(table_list->head->data.ptr_value)->val.str; + } result->table_info_.reset(table_info); break; } @@ -1393,10 +1409,22 @@ parser::DropStatement *PostgresParser::DropTriggerTransform(DropStmt *root) { auto result = new DropStatement(DropStatement::EntityType::kTrigger); auto cell = root->objects->head; auto list = reinterpret_cast(cell->data.ptr_value); - result->SetTriggerTableName( - reinterpret_cast(list->head->data.ptr_value)->val.str); + // first, set trigger name result->SetTriggerName( - reinterpret_cast(list->head->next->data.ptr_value)->val.str); + reinterpret_cast(list->tail->data.ptr_value)->val.str); + // if schema name is specified + TableInfo *table_info = new TableInfo{}; + if (list->length == 3) { + table_info->schema_name = + reinterpret_cast(list->head->data.ptr_value)->val.str; + table_info->table_name = + reinterpret_cast(list->head->next->data.ptr_value)->val.str; + } else if (list->length == 2) { + table_info->table_name = + reinterpret_cast(list->head->data.ptr_value)->val.str; + } + + result->table_info_.reset(table_info); return result; } @@ -1404,10 +1432,12 @@ parser::DropStatement *PostgresParser::DropSchemaTransform(DropStmt *root) { auto result = new DropStatement(DropStatement::EntityType::kSchema); result->SetCascade(root->behavior == DropBehavior::DROP_CASCADE); result->SetMissing(root->missing_ok); + + result->table_info_.reset(new parser::TableInfo()); for (auto cell = root->objects->head; cell != nullptr; cell = cell->next) { auto table_list = reinterpret_cast(cell->data.ptr_value); - result->SetSchemaName( - reinterpret_cast(table_list->head->data.ptr_value)->val.str); + result->table_info_->schema_name = + reinterpret_cast(table_list->head->data.ptr_value)->val.str; break; } return result; @@ -1418,8 +1448,18 @@ parser::DropStatement *PostgresParser::DropIndexTransform(DropStmt *root) { auto result = new DropStatement(DropStatement::EntityType::kIndex); auto cell = root->objects->head; auto list = reinterpret_cast(cell->data.ptr_value); - result->SetIndexName( - reinterpret_cast(list->head->data.ptr_value)->val.str); + // if schema name is specified + if (list->length == 2) { + TableInfo *table_info = new TableInfo{}; + table_info->schema_name = + reinterpret_cast(list->head->data.ptr_value)->val.str; + result->SetIndexName( + reinterpret_cast(list->head->next->data.ptr_value)->val.str); + result->table_info_.reset(table_info); + } else { + result->SetIndexName( + reinterpret_cast(list->head->data.ptr_value)->val.str); + } return result; } diff --git a/src/parser/table_ref.cpp b/src/parser/table_ref.cpp index 37903eca7e2..33901ff4d4c 100644 --- a/src/parser/table_ref.cpp +++ b/src/parser/table_ref.cpp @@ -22,6 +22,7 @@ const std::string TableRef::GetInfo(int num_indent) const { std::ostringstream os; switch (type) { case TableReferenceType::NAME: + os << StringUtil::Indent(num_indent) << GetSchemaName() << std::endl; os << StringUtil::Indent(num_indent) << GetTableName() << std::endl; break; diff --git a/src/planner/analyze_plan.cpp b/src/planner/analyze_plan.cpp index c4522d91aef..5de53476b14 100644 --- a/src/planner/analyze_plan.cpp +++ b/src/planner/analyze_plan.cpp @@ -12,41 +12,42 @@ #include "planner/analyze_plan.h" +#include "catalog/catalog.h" #include "parser/analyze_statement.h" #include "storage/data_table.h" -#include "catalog/catalog.h" namespace peloton { namespace planner { AnalyzePlan::AnalyzePlan(storage::DataTable *table) : target_table_(table) {} -AnalyzePlan::AnalyzePlan(std::string table_name, +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, table_name, txn); + database_name, schema_name, table_name, txn); } -AnalyzePlan::AnalyzePlan(std::string table_name, +AnalyzePlan::AnalyzePlan(std::string table_name, std::string schema_name, std::string database_name, std::vector column_names, concurrency::TransactionContext *txn) : table_name_(table_name), column_names_(column_names) { target_table_ = catalog::Catalog::GetInstance()->GetTableWithName( - database_name, table_name, txn); + database_name, schema_name, table_name, txn); } AnalyzePlan::AnalyzePlan(parser::AnalyzeStatement *analyze_stmt, concurrency::TransactionContext *txn) { table_name_ = analyze_stmt->GetTableName(); - column_names_ = std::vector(); - for (auto& name : analyze_stmt->GetColumnNames()) - column_names_.push_back((char*)name.c_str()); + column_names_ = std::vector(); + 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(), table_name_, txn); + analyze_stmt->GetDatabaseName(), analyze_stmt->GetSchemaName(), + table_name_, txn); } } diff --git a/src/planner/create_plan.cpp b/src/planner/create_plan.cpp index b19d8d534d8..2a23a75abb4 100644 --- a/src/planner/create_plan.cpp +++ b/src/planner/create_plan.cpp @@ -12,36 +12,45 @@ #include "planner/create_plan.h" -#include "expression/constant_value_expression.h" -#include "storage/data_table.h" #include "common/internal_types.h" #include "expression/abstract_expression.h" +#include "expression/constant_value_expression.h" +#include "storage/data_table.h" namespace peloton { namespace planner { CreatePlan::CreatePlan(std::string database_name, CreateType c_type) - : database_name(database_name), - create_type(c_type) {} + : database_name(database_name), create_type(c_type) {} -CreatePlan::CreatePlan(std::string table_name, std::string database_name, +CreatePlan::CreatePlan(std::string table_name, std::string schema_name, + std::string database_name, std::unique_ptr schema, CreateType c_type) : table_name(table_name), + schema_name(schema_name), database_name(database_name), table_schema(schema.release()), create_type(c_type) {} -CreatePlan::CreatePlan(parser::CreateStatement *parse_tree) -{ +CreatePlan::CreatePlan(parser::CreateStatement *parse_tree) { switch (parse_tree->type) { case parser::CreateStatement::CreateType::kDatabase: { create_type = CreateType::DB; database_name = std::string(parse_tree->GetDatabaseName()); break; } + + case parser::CreateStatement::CreateType::kSchema: { + create_type = CreateType::SCHEMA; + database_name = std::string(parse_tree->GetDatabaseName()); + schema_name = std::string(parse_tree->GetSchemaName()); + break; + } + case parser::CreateStatement::CreateType::kTable: { table_name = std::string(parse_tree->GetTableName()); + schema_name = std::string(parse_tree->GetSchemaName()); database_name = std::string(parse_tree->GetDatabaseName()); std::vector columns; std::vector column_constraints; @@ -56,74 +65,87 @@ CreatePlan::CreatePlan(parser::CreateStatement *parse_tree) for (auto &col : parse_tree->columns) { type::TypeId val = col->GetValueType(col->type); - - LOG_TRACE("Column name: %s.%s; Is primary key: %d", table_name.c_str(), col->name.c_str(), col->primary); - + + LOG_TRACE("Column name: %s.%s; Is primary key: %d", table_name.c_str(), + col->name.c_str(), col->primary); + // Check main constraints if (col->primary) { - catalog::Constraint constraint(ConstraintType::PRIMARY, "con_primary"); + catalog::Constraint constraint(ConstraintType::PRIMARY, + "con_primary"); column_constraints.push_back(constraint); - LOG_TRACE("Added a primary key constraint on column \"%s.%s\"", table_name.c_str(), col->name.c_str()); + LOG_TRACE("Added a primary key constraint on column \"%s.%s\"", + table_name.c_str(), col->name.c_str()); } - + if (col->not_null) { - catalog::Constraint constraint(ConstraintType::NOTNULL, "con_not_null"); + catalog::Constraint constraint(ConstraintType::NOTNULL, + "con_not_null"); column_constraints.push_back(constraint); - LOG_TRACE("Added a not-null constraint on column \"%s.%s\"", table_name.c_str(), col->name.c_str()); + LOG_TRACE("Added a not-null constraint on column \"%s.%s\"", + table_name.c_str(), col->name.c_str()); } - + if (col->unique) { catalog::Constraint constraint(ConstraintType::UNIQUE, "con_unique"); column_constraints.push_back(constraint); - LOG_TRACE("Added a unique constraint on column \"%s.%s\"", table_name.c_str(), col->name.c_str()); + LOG_TRACE("Added a unique constraint on column \"%s.%s\"", + table_name.c_str(), col->name.c_str()); } - + /* **************** */ - + // Add the default value if (col->default_value != nullptr) { // Referenced from insert_plan.cpp - if (col->default_value->GetExpressionType() != ExpressionType::VALUE_PARAMETER) { + if (col->default_value->GetExpressionType() != + ExpressionType::VALUE_PARAMETER) { expression::ConstantValueExpression *const_expr_elem = - dynamic_cast(col->default_value.get()); - - catalog::Constraint constraint(ConstraintType::DEFAULT, "con_default"); + dynamic_cast( + col->default_value.get()); + + catalog::Constraint constraint(ConstraintType::DEFAULT, + "con_default"); type::Value v = const_expr_elem->GetValue(); constraint.addDefaultValue(v); column_constraints.push_back(constraint); LOG_TRACE("Added a default constraint %s on column \"%s.%s\"", - v.ToString().c_str(), table_name.c_str(), col->name.c_str()); + v.ToString().c_str(), table_name.c_str(), + col->name.c_str()); } } - + // Check expression constraint // Currently only supports simple boolean forms like (a > 0) if (col->check_expression != nullptr) { // TODO: more expression types need to be supported if (col->check_expression->GetValueType() == type::TypeId::BOOLEAN) { catalog::Constraint constraint(ConstraintType::CHECK, "con_check"); - + const expression::ConstantValueExpression *const_expr_elem = - dynamic_cast(col->check_expression->GetChild(1)); - + dynamic_cast( + col->check_expression->GetChild(1)); + type::Value tmp_value = const_expr_elem->GetValue(); - constraint.AddCheck(std::move(col->check_expression->GetExpressionType()), std::move(tmp_value)); + constraint.AddCheck( + std::move(col->check_expression->GetExpressionType()), + std::move(tmp_value)); column_constraints.push_back(constraint); LOG_TRACE("Added a check constraint on column \"%s.%s\"", table_name.c_str(), col->name.c_str()); } } - + auto column = catalog::Column(val, type::Type::GetTypeSize(val), std::string(col->name), false); if (!column.IsInlined()) { column.SetLength(col->varlen); } - + for (auto con : column_constraints) { column.AddConstraint(con); } - + column_constraints.clear(); columns.push_back(column); } @@ -135,39 +157,42 @@ CreatePlan::CreatePlan(parser::CreateStatement *parse_tree) create_type = CreateType::INDEX; index_name = std::string(parse_tree->index_name); table_name = std::string(parse_tree->GetTableName()); + schema_name = std::string(parse_tree->GetSchemaName()); database_name = std::string(parse_tree->GetDatabaseName()); // This holds the attribute names. // This is a fix for a bug where // The vector* items gets deleted when passed // To the Executor. - + std::vector index_attrs_holder; - + for (auto &attr : parse_tree->index_attrs) { index_attrs_holder.push_back(attr); } - + index_attrs = index_attrs_holder; - + index_type = parse_tree->index_type; - + unique = parse_tree->unique; break; } + case parser::CreateStatement::CreateType::kTrigger: { create_type = CreateType::TRIGGER; trigger_name = std::string(parse_tree->trigger_name); table_name = std::string(parse_tree->GetTableName()); + schema_name = std::string(parse_tree->GetSchemaName()); database_name = std::string(parse_tree->GetDatabaseName()); - + if (parse_tree->trigger_when) { trigger_when.reset(parse_tree->trigger_when->Copy()); } else { trigger_when.reset(); } trigger_type = parse_tree->trigger_type; - + for (auto &s : parse_tree->trigger_funcname) { trigger_funcname.push_back(s); } @@ -182,23 +207,22 @@ CreatePlan::CreatePlan(parser::CreateStatement *parse_tree) } default: LOG_ERROR("UNKNOWN CREATE TYPE"); - //TODO Should we handle this here? + // TODO Should we handle this here? break; } - + // TODO check type CreateType::kDatabase } -void CreatePlan::ProcessForeignKeyConstraint(const std::string &table_name, - const parser::ColumnDefinition *col) { - +void CreatePlan::ProcessForeignKeyConstraint( + const std::string &table_name, const parser::ColumnDefinition *col) { ForeignKeyInfo fkey_info; // Extract source and sink column names - for (auto& key : col->foreign_key_source) { + for (auto &key : col->foreign_key_source) { fkey_info.foreign_key_sources.push_back(key); } - for (auto& key : col->foreign_key_sink) { + for (auto &key : col->foreign_key_sink) { fkey_info.foreign_key_sinks.push_back(key); } diff --git a/src/planner/drop_plan.cpp b/src/planner/drop_plan.cpp index e4993e6cadb..34240f85cad 100644 --- a/src/planner/drop_plan.cpp +++ b/src/planner/drop_plan.cpp @@ -32,8 +32,16 @@ DropPlan::DropPlan(parser::DropStatement *parse_tree) { drop_type = DropType::DB; break; } + case parser::DropStatement::EntityType::kSchema: { + database_name = parse_tree->GetDatabaseName(); + schema_name = parse_tree->GetSchemaName(); + missing = parse_tree->GetMissing(); + drop_type = DropType::SCHEMA; + break; + } case parser::DropStatement::EntityType::kTable: { database_name = parse_tree->GetDatabaseName(); + schema_name = parse_tree->GetSchemaName(); table_name = parse_tree->GetTableName(); missing = parse_tree->GetMissing(); drop_type = DropType::TABLE; @@ -43,6 +51,7 @@ DropPlan::DropPlan(parser::DropStatement *parse_tree) { // note parse_tree->table_name is different from // parse_tree->GetTableName() database_name = parse_tree->GetDatabaseName(); + schema_name = parse_tree->GetSchemaName(); table_name = std::string(parse_tree->GetTriggerTableName()); trigger_name = std::string(parse_tree->GetTriggerName()); drop_type = DropType::TRIGGER; @@ -50,6 +59,7 @@ DropPlan::DropPlan(parser::DropStatement *parse_tree) { } case parser::DropStatement::EntityType::kIndex: { database_name = parse_tree->GetDatabaseName(); + schema_name = parse_tree->GetSchemaName(); index_name = std::string(parse_tree->GetIndexName()); drop_type = DropType::INDEX; break; diff --git a/src/planner/plan_util.cpp b/src/planner/plan_util.cpp index b8d9081e8b7..7f0d828a9bd 100644 --- a/src/planner/plan_util.cpp +++ b/src/planner/plan_util.cpp @@ -37,7 +37,7 @@ const std::set PlanUtil::GetAffectedIndexes( catalog::CatalogCache &catalog_cache, const parser::SQLStatement &sql_stmt) { std::set index_oids; - std::string db_name, table_name; + std::string db_name, table_name, schema_name; switch (sql_stmt.GetType()) { // For INSERT, DELETE, all indexes are affected case StatementType::INSERT: { @@ -53,9 +53,10 @@ const std::set PlanUtil::GetAffectedIndexes( static_cast(sql_stmt); db_name = delete_stmt.GetDatabaseName(); table_name = delete_stmt.GetTableName(); + schema_name = delete_stmt.GetSchemaName(); } auto indexes_map = catalog_cache.GetDatabaseObject(db_name) - ->GetTableObject(table_name) + ->GetTableObject(table_name, schema_name) ->GetIndexObjects(); for (auto &index : indexes_map) { index_oids.insert(index.first); @@ -66,8 +67,10 @@ const std::set PlanUtil::GetAffectedIndexes( static_cast(sql_stmt); db_name = update_stmt.table->GetDatabaseName(); table_name = update_stmt.table->GetTableName(); - auto db_object = catalog_cache.GetDatabaseObject(db_name); - auto table_object = db_object->GetTableObject(table_name); + schema_name = update_stmt.table->GetSchemaName(); + auto table_object = + catalog_cache.GetDatabaseObject(db_name)->GetTableObject(table_name, + schema_name); auto &update_clauses = update_stmt.updates; std::set update_oids; diff --git a/src/statistics/stats_aggregator.cpp b/src/statistics/stats_aggregator.cpp index 3e3cde97c94..7cbf38e384a 100644 --- a/src/statistics/stats_aggregator.cpp +++ b/src/statistics/stats_aggregator.cpp @@ -132,8 +132,6 @@ void StatsAggregator::UpdateQueryMetrics(int64_t time_stamp, concurrency::TransactionContext *txn) { // Get the target query metrics table LOG_TRACE("Inserting Query Metric Tuples"); - // auto query_metrics_table = GetMetricTable(MetricType::QUERY_NAME); - std::shared_ptr query_metric; auto &completed_query_metrics = aggregated_stats_.GetCompletedQueryMetrics(); while (completed_query_metrics.Dequeue(query_metric)) { @@ -192,8 +190,9 @@ void StatsAggregator::UpdateMetrics() { auto storage_manager = storage::StorageManager::GetInstance(); auto time_since_epoch = std::chrono::system_clock::now().time_since_epoch(); - auto time_stamp = std::chrono::duration_cast( - time_since_epoch).count(); + auto time_stamp = + std::chrono::duration_cast(time_since_epoch) + .count(); auto database_count = storage_manager->GetDatabaseCount(); for (oid_t database_offset = 0; database_offset < database_count; @@ -252,9 +251,9 @@ void StatsAggregator::UpdateTableMetrics(storage::Database *database, auto table_metrics_catalog = catalog::Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetTableMetricsCatalog(); - table_metrics_catalog->InsertTableMetrics(database_oid, table_oid, reads, - updates, deletes, inserts, - time_stamp, pool_.get(), txn); + table_metrics_catalog->InsertTableMetrics(table_oid, reads, updates, + deletes, inserts, time_stamp, + pool_.get(), txn); LOG_TRACE("Table Metric Tuple inserted"); UpdateIndexMetrics(database, table, time_stamp, txn); @@ -284,9 +283,9 @@ void StatsAggregator::UpdateIndexMetrics(storage::Database *database, auto index_metrics_catalog = catalog::Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetIndexMetricsCatalog(); - index_metrics_catalog->InsertIndexMetrics( - database_oid, table_oid, index_oid, reads, deletes, inserts, time_stamp, - pool_.get(), txn); + index_metrics_catalog->InsertIndexMetrics(table_oid, index_oid, reads, + deletes, inserts, time_stamp, + pool_.get(), txn); } } @@ -347,16 +346,5 @@ void StatsAggregator::UnregisterContext(std::thread::id id) { } } -storage::DataTable *StatsAggregator::GetMetricTable(std::string table_name) { - auto storage_manager = storage::StorageManager::GetInstance(); - PELOTON_ASSERT(storage_manager->GetDatabaseCount() > 0); - storage::Database *catalog_database = - storage_manager->GetDatabaseWithOid(CATALOG_DATABASE_OID); - PELOTON_ASSERT(catalog_database != nullptr); - auto metrics_table = catalog_database->GetTableWithName(table_name); - PELOTON_ASSERT(metrics_table != nullptr); - return metrics_table; -} - } // namespace stats } // namespace peloton diff --git a/src/storage/database.cpp b/src/storage/database.cpp index 705ad42916e..8a7506805c8 100644 --- a/src/storage/database.cpp +++ b/src/storage/database.cpp @@ -67,14 +67,6 @@ storage::DataTable *Database::GetTableWithOid(const oid_t table_oid) const { return nullptr; } -storage::DataTable *Database::GetTableWithName( - const std::string &table_name) const { - for (auto table : tables) - if (table->GetName() == table_name) return table; - throw CatalogException("Table '" + table_name + "' does not exist"); - return nullptr; -} - void Database::DropTableWithOid(const oid_t table_oid) { { std::lock_guard lock(database_mutex); diff --git a/src/traffic_cop/traffic_cop.cpp b/src/traffic_cop/traffic_cop.cpp index 86279e50fa1..a87d99c0ac5 100644 --- a/src/traffic_cop/traffic_cop.cpp +++ b/src/traffic_cop/traffic_cop.cpp @@ -420,8 +420,8 @@ void TrafficCop::GetTableColumns(parser::TableRef *from_table, auto columns = static_cast( catalog::Catalog::GetInstance()->GetTableWithName( - from_table->GetDatabaseName(), from_table->GetTableName(), - GetCurrentTxnState().first)) + from_table->GetDatabaseName(), from_table->GetSchemaName(), + from_table->GetTableName(), GetCurrentTxnState().first)) ->GetSchema() ->GetColumns(); target_columns.insert(target_columns.end(), columns.begin(), diff --git a/src/tuning/index_tuner.cpp b/src/tuning/index_tuner.cpp index b59f44bc870..ca96907e605 100644 --- a/src/tuning/index_tuner.cpp +++ b/src/tuning/index_tuner.cpp @@ -14,22 +14,22 @@ #include #include "tuning/brain_util.h" -#include "concurrency/transaction_manager_factory.h" -#include "tuning/clusterer.h" #include "catalog/catalog.h" #include "catalog/schema.h" #include "common/container_tuple.h" #include "common/logger.h" #include "common/macros.h" #include "common/timer.h" +#include "concurrency/transaction_manager_factory.h" #include "index/index_factory.h" #include "storage/data_table.h" #include "storage/tile_group.h" +#include "tuning/clusterer.h" namespace peloton { namespace tuning { -IndexTuner& IndexTuner::GetInstance() { +IndexTuner &IndexTuner::GetInstance() { static IndexTuner index_tuner; return index_tuner; } @@ -52,7 +52,7 @@ void IndexTuner::Start() { } // Add an ad-hoc index -static void AddIndex(storage::DataTable* table, +static void AddIndex(storage::DataTable *table, std::set suggested_index_attrs) { // Construct index metadata std::vector key_attrs(suggested_index_attrs.size()); @@ -63,8 +63,8 @@ static void AddIndex(storage::DataTable* table, auto index_oid = index_count + 1; auto tuple_schema = table->GetSchema(); - catalog::Schema* key_schema; - index::IndexMetadata* index_metadata; + catalog::Schema *key_schema; + index::IndexMetadata *index_metadata; bool unique; key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs); @@ -91,7 +91,7 @@ static void AddIndex(storage::DataTable* table, LOG_DEBUG("Creating index : %s", index_metadata->GetInfo().c_str()); } -void IndexTuner::BuildIndex(storage::DataTable* table, +void IndexTuner::BuildIndex(storage::DataTable *table, std::shared_ptr index) { auto table_schema = table->GetSchema(); auto index_tile_group_offset = index->GetIndexedTileGroupOff(); @@ -137,7 +137,7 @@ void IndexTuner::BuildIndex(storage::DataTable* table, tile_groups_indexed_ += tile_groups_indexed; } -void IndexTuner::BuildIndices(storage::DataTable* table) { +void IndexTuner::BuildIndices(storage::DataTable *table) { oid_t index_count = table->GetIndexCount(); for (oid_t index_itr = 0; index_itr < index_count; index_itr++) { @@ -153,7 +153,7 @@ void IndexTuner::BuildIndices(storage::DataTable* table) { } double IndexTuner::ComputeWorkloadWriteRatio( - const std::vector& samples) { + const std::vector &samples) { double write_ratio = 0; double total_read_duration = 0; @@ -198,7 +198,7 @@ bool SampleFrequencyMapEntryComparator(sample_frequency_map_entry a, } std::vector GetFrequentSamples( - const std::vector& samples) { + const std::vector &samples) { std::unordered_map sample_frequency_map; double total_weight = 0; @@ -253,7 +253,7 @@ std::vector GetFrequentSamples( } std::vector> GetSuggestedIndices( - const std::vector& list) { + const std::vector &list) { // Find frequent samples size_t frequency_rank_threshold = 10; @@ -264,8 +264,8 @@ std::vector> GetSuggestedIndices( for (size_t entry_itr = 0; (entry_itr < frequency_rank_threshold) && (entry_itr < list_size); entry_itr++) { - auto& entry = list[entry_itr]; - auto& sample = entry.first; + auto &entry = list[entry_itr]; + auto &sample = entry.first; LOG_TRACE("%s Utility : %.2lf", sample.GetInfo().c_str(), entry.second); suggested_indices.push_back(sample.GetColumnsAccessed()); } @@ -275,14 +275,14 @@ std::vector> GetSuggestedIndices( double GetCurrentIndexUtility( std::set suggested_index_set, - const std::vector& list) { + const std::vector &list) { double current_index_utility = 0; auto list_size = list.size(); for (size_t entry_itr = 0; entry_itr < list_size; entry_itr++) { - auto& entry = list[entry_itr]; - auto& sample = entry.first; - auto& columns = sample.GetColumnsAccessed(); + auto &entry = list[entry_itr]; + auto &sample = entry.first; + auto &columns = sample.GetColumnsAccessed(); std::set columns_set(columns.begin(), columns.end()); @@ -296,7 +296,7 @@ double GetCurrentIndexUtility( return current_index_utility; } -void IndexTuner::DropIndexes(storage::DataTable* table) { +void IndexTuner::DropIndexes(storage::DataTable *table) { oid_t index_count = table->GetIndexCount(); // Go over indices @@ -326,8 +326,8 @@ void IndexTuner::DropIndexes(storage::DataTable* table) { } void IndexTuner::AddIndexes( - storage::DataTable* table, - const std::vector>& suggested_indices) { + storage::DataTable *table, + const std::vector> &suggested_indices) { oid_t valid_index_count = table->GetValidIndexCount(); size_t constructed_index_itr = 0; @@ -384,8 +384,8 @@ void IndexTuner::AddIndexes( } } -void UpdateIndexUtility(storage::DataTable* table, - const std::vector& list) { +void UpdateIndexUtility(storage::DataTable *table, + const std::vector &list) { oid_t index_count = table->GetIndexCount(); for (oid_t index_itr = 0; index_itr < index_count; index_itr++) { @@ -422,7 +422,7 @@ void UpdateIndexUtility(storage::DataTable* table, } } -void PrintIndexInformation(storage::DataTable* table) { +void PrintIndexInformation(storage::DataTable *table) { oid_t index_count = table->GetIndexCount(); auto table_tilegroup_count = table->GetTileGroupCount(); LOG_INFO("Index count : %u", table->GetValidIndexCount()); @@ -448,7 +448,7 @@ void PrintIndexInformation(storage::DataTable* table) { } } -void IndexTuner::Analyze(storage::DataTable* table) { +void IndexTuner::Analyze(storage::DataTable *table) { // Process all samples in table auto samples = table->GetIndexSamples(); @@ -492,7 +492,7 @@ void IndexTuner::Analyze(storage::DataTable* table) { PrintIndexInformation(table); } -void IndexTuner::IndexTuneHelper(storage::DataTable* table) { +void IndexTuner::IndexTuneHelper(storage::DataTable *table) { // Process all samples in table auto samples = table->GetIndexSamples(); auto sample_count = samples.size(); @@ -563,7 +563,7 @@ void IndexTuner::Stop() { LOG_INFO("Stopped index tuner"); } -void IndexTuner::AddTable(storage::DataTable* table) { +void IndexTuner::AddTable(storage::DataTable *table) { { std::lock_guard lock(index_tuner_mutex); tables.push_back(table); @@ -577,7 +577,7 @@ void IndexTuner::ClearTables() { } } -void IndexTuner::BootstrapTPCC(const std::string& path) { +void IndexTuner::BootstrapTPCC(const std::string &path) { // Enable visibility mode SetVisibilityMode(); @@ -595,12 +595,13 @@ void IndexTuner::BootstrapTPCC(const std::string& path) { auto samples = table_samples.second; // Locate table in catalog - auto& txn_manager = concurrency::TransactionManagerFactory::GetInstance(); + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - auto table = catalog->GetTableWithName(database_name, table_name, txn); + auto table = catalog->GetTableWithName( + database_name, std::string(DEFUALT_SCHEMA_NAME), table_name, txn); txn_manager.CommitTransaction(txn); PELOTON_ASSERT(table != nullptr); - for (auto& sample : samples) { + for (auto &sample : samples) { table->RecordIndexSample(sample); } LOG_INFO("Added table to index tuner : %s", table_name.c_str()); @@ -611,11 +612,11 @@ void IndexTuner::BootstrapTPCC(const std::string& path) { } // Load statistics for Index Tuner from a file -void LoadStatsFromFile(const std::string& path) { +void LoadStatsFromFile(const std::string &path) { LOG_INFO("LoadStatsFromFile Invoked"); // Get index tuner - auto& index_tuner = tuning::IndexTuner::GetInstance(); + auto &index_tuner = tuning::IndexTuner::GetInstance(); // Set duration between pauses auto duration = 30000; // in ms @@ -627,5 +628,5 @@ void LoadStatsFromFile(const std::string& path) { return; } -} // namespace indextuner +} // namespace tuning } // namespace peloton diff --git a/test/parser/postgresparser_test.cpp b/test/parser/postgresparser_test.cpp index 97e86adc8da..36910bdc9a9 100644 --- a/test/parser/postgresparser_test.cpp +++ b/test/parser/postgresparser_test.cpp @@ -765,7 +765,7 @@ TEST_F(PostgresParserTests, CreateSchemaTest) { auto create_stmt = (parser::CreateStatement *)stmt_list->GetStatement(0); LOG_INFO("%s", stmt_list->GetInfo().c_str()); // Check attributes - EXPECT_EQ("tt", create_stmt->schema_name); + EXPECT_EQ("tt", create_stmt->GetSchemaName()); // Test default schema name query = "CREATE SCHEMA AUTHORIZATION joe"; @@ -775,7 +775,7 @@ TEST_F(PostgresParserTests, CreateSchemaTest) { create_stmt = (parser::CreateStatement *)stmt_list->GetStatement(0); LOG_INFO("%s", stmt_list->GetInfo().c_str()); // Check attributes - EXPECT_EQ("joe", create_stmt->schema_name); + EXPECT_EQ("joe", create_stmt->GetSchemaName()); } TEST_F(PostgresParserTests, CreateViewTest) { @@ -1048,7 +1048,7 @@ TEST_F(PostgresParserTests, CreateTriggerTest) { TEST_F(PostgresParserTests, DropTriggerTest) { auto parser = parser::PostgresParser::GetInstance(); - std::string query = "DROP TRIGGER if_dist_exists ON films;"; + std::string query = "DROP TRIGGER if_dist_exists ON peloton.films;"; std::unique_ptr stmt_list( parser.BuildParseTree(query).release()); EXPECT_TRUE(stmt_list->is_valid); From 0fa160a6fdcb5023f5ff0d214d5f0c6b984f47f0 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Sat, 14 Apr 2018 00:00:11 -0400 Subject: [PATCH 40/48] rebase to latest master branch --- src/catalog/abstract_catalog.cpp | 6 +++--- src/catalog/column_catalog.cpp | 2 +- src/catalog/database_catalog.cpp | 2 +- src/catalog/index_catalog.cpp | 6 +++--- src/catalog/table_catalog.cpp | 4 ++-- 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 43c2ea2d2c1..f7ae9851ca6 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -82,7 +82,7 @@ AbstractCatalog::AbstractCatalog(const std::string &catalog_table_ddl, auto catalog_table_name = create_plan->GetTableName(); auto catalog_schema_name = create_plan->GetSchemaName(); auto catalog_database_name = create_plan->GetDatabaseName(); - PL_ASSERT(catalog_schema_name == std::string(CATALOG_SCHEMA_NAME)); + 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, @@ -330,7 +330,7 @@ bool AbstractCatalog::UpdateWithIndexScan( auto index = catalog_table_->GetIndex(index_offset); std::vector key_column_offsets = index->GetMetadata()->GetKeySchema()->GetIndexedColumns(); - PL_ASSERT(scan_values.size() == key_column_offsets.size()); + PELOTON_ASSERT(scan_values.size() == key_column_offsets.size()); std::vector expr_types(scan_values.size(), ExpressionType::COMPARE_EQUAL); std::vector runtime_keys; @@ -356,7 +356,7 @@ bool AbstractCatalog::UpdateWithIndexScan( } } - PL_ASSERT(update_columns.size() == update_values.size()); + PELOTON_ASSERT(update_columns.size() == update_values.size()); for (size_t i = 0; i < update_values.size(); i++) { planner::DerivedAttribute update_attribute{ new expression::ConstantValueExpression(update_values[i])}; diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index f513096fbf2..2084577ef4c 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -228,7 +228,7 @@ ColumnCatalog::GetColumnObjects(oid_t table_oid, ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); - PL_ASSERT(table_object && table_object->GetTableOid() == table_oid); + PELOTON_ASSERT(table_object && table_object->GetTableOid() == table_oid); auto column_objects = table_object->GetColumnObjects(true); if (column_objects.size() != 0) return column_objects; diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index b09316c6b55..fc0b81c64d0 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -181,7 +181,7 @@ DatabaseCatalogObject::GetTableObjects(const std::string &schema_name) { pg_table->GetTableObjects(txn); } // make sure to check IsValidTableObjects() before getting table objects - PL_ASSERT(valid_table_objects); + PELOTON_ASSERT(valid_table_objects); std::vector> result; for (auto it : table_objects_cache) { if (it.second->GetSchemaName() == schema_name) { diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index 162c617e554..da666f36f60 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -212,7 +212,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(index_object->GetTableOid(), txn); - PL_ASSERT(table_object && + PELOTON_ASSERT(table_object && table_object->GetTableOid() == index_object->GetTableOid()); return table_object->GetIndexObject(index_oid); } else { @@ -258,7 +258,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(index_object->GetTableOid(), txn); - PL_ASSERT(table_object && + PELOTON_ASSERT(table_object && table_object->GetTableOid() == index_object->GetTableOid()); return table_object->GetIndexObject(index_name); } else { @@ -287,7 +287,7 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); - PL_ASSERT(table_object && table_object->GetTableOid() == table_oid); + PELOTON_ASSERT(table_object && table_object->GetTableOid() == table_oid); auto index_objects = table_object->GetIndexObjects(true); if (index_objects.empty() == false) return index_objects; diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 096a1cf41f4..33a9d8bd91b 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -458,7 +458,7 @@ std::shared_ptr TableCatalog::GetTableObject( // insert into cache auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); - PL_ASSERT(database_object); + PELOTON_ASSERT(database_object); bool success = database_object->InsertTableObject(table_object); PELOTON_ASSERT(success == true); (void)success; @@ -511,7 +511,7 @@ std::shared_ptr TableCatalog::GetTableObject( // insert into cache auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); - PL_ASSERT(database_object); + PELOTON_ASSERT(database_object); bool success = database_object->InsertTableObject(table_object); PELOTON_ASSERT(success == true); (void)success; From 094e4481a3014a4523ffaa08dd360f4f760cf016 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Sun, 15 Apr 2018 22:53:35 -0400 Subject: [PATCH 41/48] add more comments --- src/catalog/catalog.cpp | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 1fdbbe9e258..0774b857186 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -57,16 +57,16 @@ Catalog::Catalog() : pool_(new type::EphemeralPool()) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); auto storage_manager = storage::StorageManager::GetInstance(); - // Create pg_catalog database - auto pg_catalog = new storage::Database(CATALOG_DATABASE_OID); - pg_catalog->setDBName(CATALOG_DATABASE_NAME); - storage_manager->AddDatabaseToStorageManager(pg_catalog); + // Create peloton database + auto peloton = new storage::Database(CATALOG_DATABASE_OID); + peloton->setDBName(CATALOG_DATABASE_NAME); + storage_manager->AddDatabaseToStorageManager(peloton); // Create catalog tables - DatabaseCatalog::GetInstance(pg_catalog, pool_.get(), txn); - BootstrapSystemCatalogs(pg_catalog, txn); + DatabaseCatalog::GetInstance(peloton, pool_.get(), txn); + BootstrapSystemCatalogs(peloton, txn); - // Insert pg_catalog database into pg_database + // Insert peloton database into pg_database DatabaseCatalog::GetInstance()->InsertDatabase( CATALOG_DATABASE_OID, CATALOG_DATABASE_NAME, pool_.get(), txn); @@ -162,7 +162,7 @@ void Catalog::BootstrapSystemCatalogs(storage::Database *database, DEFUALT_SCHEMA_OID, DEFUALT_SCHEMA_NAME, pool_.get(), txn); // Insert catalog tables into pg_table - // pg_database is shared across different databases + // pg_database record is shared across different databases system_catalogs->GetTableCatalog()->InsertTable( DATABASE_CATALOG_OID, DATABASE_CATALOG_NAME, CATALOG_SCHEMA_NAME, CATALOG_DATABASE_OID, pool_.get(), txn); @@ -227,7 +227,6 @@ ResultType Catalog::CreateDatabase(const std::string &database_name, // TODO: This should be deprecated, dbname should only exists in pg_db database->setDBName(database_name); - { std::lock_guard lock(catalog_mutex); storage_manager->AddDatabaseToStorageManager(database); From fccc88bdcd972f66fdfe80343e277fc5c2d4b94b Mon Sep 17 00:00:00 2001 From: mengranwo Date: Wed, 25 Apr 2018 00:29:07 -0400 Subject: [PATCH 42/48] fix test case errors, able to compile, one failing test --- src/catalog/query_metrics_catalog.cpp | 9 +- src/include/catalog/query_metrics_catalog.h | 55 ++-- src/include/parser/drop_statement.h | 9 + src/planner/plan_util.cpp | 3 +- src/statistics/stats_aggregator.cpp | 7 +- test/binder/binder_test.cpp | 22 +- test/brain/query_logger_test.cpp | 5 +- test/catalog/catalog_test.cpp | 67 +++-- test/catalog/constraints_test.cpp | 93 ++++--- test/codegen/bloom_filter_test.cpp | 12 +- test/codegen/table_scan_translator_test.cpp | 47 ++-- test/codegen/testing_codegen_util.cpp | 29 ++- test/executor/copy_test.cpp | 3 +- test/executor/create_index_test.cpp | 2 +- test/executor/create_test.cpp | 31 +-- test/executor/delete_test.cpp | 7 +- test/executor/drop_test.cpp | 51 ++-- test/executor/insert_test.cpp | 30 ++- test/executor/update_test.cpp | 9 +- .../catalog/testing_constraints_util.h | 244 +++++++++--------- test/optimizer/old_optimizer_test.cpp | 2 +- test/optimizer/optimizer_test.cpp | 13 + test/optimizer/selectivity_test.cpp | 6 +- test/optimizer/table_stats_collector_test.cpp | 24 +- test/optimizer/tuple_samples_storage_test.cpp | 10 +- test/parser/parser_test.cpp | 6 +- test/planner/plan_util_test.cpp | 23 +- test/planner/planner_test.cpp | 88 ++++--- test/sql/analyze_sql_test.cpp | 11 +- test/sql/drop_sql_test.cpp | 12 +- test/sql/optimizer_sql_test.cpp | 37 ++- test/statistics/stats_test.cpp | 11 +- test/statistics/testing_stats_util.cpp | 8 +- test/storage/database_test.cpp | 6 +- test/trigger/trigger_test.cpp | 20 +- 35 files changed, 550 insertions(+), 462 deletions(-) diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 9f2e8b0f737..c49fd95f379 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -26,6 +26,7 @@ QueryMetricsCatalog::QueryMetricsCatalog(const std::string &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, " @@ -44,7 +45,7 @@ QueryMetricsCatalog::QueryMetricsCatalog(const std::string &database_name, QueryMetricsCatalog::~QueryMetricsCatalog() {} bool QueryMetricsCatalog::InsertQueryMetrics( - const std::string &name, int64_t num_params, + 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, @@ -55,6 +56,7 @@ bool QueryMetricsCatalog::InsertQueryMetrics( new storage::Tuple(catalog_table_->GetSchema(), true)); auto val0 = type::ValueFactory::GetVarcharValue(name, pool); + auto val1 = type::ValueFactory::GetIntegerValue(database_oid); auto val2 = type::ValueFactory::GetIntegerValue(num_params); auto val3 = type::ValueFactory::GetNullValueByType(type::TypeId::VARBINARY); @@ -79,6 +81,7 @@ bool QueryMetricsCatalog::InsertQueryMetrics( auto val12 = type::ValueFactory::GetIntegerValue(time_stamp); tuple->SetValue(ColumnId::NAME, val0, pool); + tuple->SetValue(ColumnId::DATABASE_OID, val1, pool); tuple->SetValue(ColumnId::NUM_PARAMS, val2, pool); tuple->SetValue(ColumnId::PARAM_TYPES, val3, pool); tuple->SetValue(ColumnId::PARAM_FORMATS, val4, pool); @@ -96,11 +99,13 @@ bool QueryMetricsCatalog::InsertQueryMetrics( } bool QueryMetricsCatalog::DeleteQueryMetrics( - const std::string &name, concurrency::TransactionContext *txn) { + const std::string &name, oid_t database_oid, + concurrency::TransactionContext *txn) { 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()); return DeleteWithIndexScan(index_offset, values, txn); } diff --git a/src/include/catalog/query_metrics_catalog.h b/src/include/catalog/query_metrics_catalog.h index 63986324350..ed6ea2c9d37 100644 --- a/src/include/catalog/query_metrics_catalog.h +++ b/src/include/catalog/query_metrics_catalog.h @@ -15,17 +15,18 @@ // // Schema: (column offset: column_name) // 0: name (pkey) -// 1: num_params -// 2: param_types -// 3: param_formats -// 4: param_values -// 5: reads -// 6: updates -// 7: deletes -// 8: inserts -// 9: latency -// 10: cpu_time -// 11: time_stamp +// 1: database_id(pkey) +// 2: num_params +// 3: param_types +// 4: param_formats +// 5: param_values +// 6: reads +// 7: updates +// 8: deletes +// 9: inserts +// 10: latency +// 11: cpu_time +// 12: time_stamp // // //===----------------------------------------------------------------------===// @@ -49,7 +50,8 @@ class QueryMetricsCatalog : public AbstractCatalog { //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// - bool InsertQueryMetrics(const std::string &name, int64_t num_params, + bool 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, @@ -57,7 +59,7 @@ class QueryMetricsCatalog : public AbstractCatalog { 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, + bool DeleteQueryMetrics(const std::string &name, oid_t database_oid, concurrency::TransactionContext *txn); //===--------------------------------------------------------------------===// @@ -67,21 +69,22 @@ class QueryMetricsCatalog : public AbstractCatalog { const std::string &name, concurrency::TransactionContext *txn); int64_t GetNumParams(const std::string &name, concurrency::TransactionContext *txn); - // TODO: add more if needed - + // TODO: In theory, we don't need database_oid + // but now we store all the query metrics under default database "pelton" enum ColumnId { NAME = 0, - NUM_PARAMS = 1, - PARAM_TYPES = 2, - PARAM_FORMATS = 3, - PARAM_VALUES = 4, - READS = 5, - UPDATES = 6, - DELETES = 7, - INSERTS = 8, - LATENCY = 9, - CPU_TIME = 10, - TIME_STAMP = 11, + DATABASE_OID = 1, + NUM_PARAMS = 2, + PARAM_TYPES = 3, + PARAM_FORMATS = 4, + PARAM_VALUES = 5, + READS = 6, + UPDATES = 7, + DELETES = 8, + INSERTS = 9, + LATENCY = 10, + CPU_TIME = 11, + TIME_STAMP = 12, // Add new columns here in creation order }; diff --git a/src/include/parser/drop_statement.h b/src/include/parser/drop_statement.h index d4205528cef..9612ed5fe7e 100644 --- a/src/include/parser/drop_statement.h +++ b/src/include/parser/drop_statement.h @@ -39,6 +39,15 @@ class DropStatement : public TableRefStatement { type_(type), missing_(false), cascade_(false) {} + // only used in drop_test + DropStatement(EntityType type, std::string table_name_of_trigger, + std::string trigger_name) + : TableRefStatement(StatementType::DROP), + type_(type), + trigger_name_(trigger_name) { + if (!table_info_) table_info_.reset(new parser::TableInfo()); + table_info_->table_name = table_name_of_trigger; + } EntityType GetDropType() { return type_; } diff --git a/src/planner/plan_util.cpp b/src/planner/plan_util.cpp index 7f0d828a9bd..d9c7edd9986 100644 --- a/src/planner/plan_util.cpp +++ b/src/planner/plan_util.cpp @@ -45,10 +45,11 @@ const std::set PlanUtil::GetAffectedIndexes( static_cast(sql_stmt); db_name = insert_stmt.GetDatabaseName(); table_name = insert_stmt.GetTableName(); + schema_name = insert_stmt.GetSchemaName(); } PELOTON_FALLTHROUGH; case StatementType::DELETE: { - if (table_name.empty() || db_name.empty()) { + if (table_name.empty() || db_name.empty() || schema_name.empty()) { auto &delete_stmt = static_cast(sql_stmt); db_name = delete_stmt.GetDatabaseName(); diff --git a/src/statistics/stats_aggregator.cpp b/src/statistics/stats_aggregator.cpp index 7cbf38e384a..2d4c68c8794 100644 --- a/src/statistics/stats_aggregator.cpp +++ b/src/statistics/stats_aggregator.cpp @@ -172,9 +172,10 @@ void StatsAggregator::UpdateQueryMetrics(int64_t time_stamp, ->GetSystemCatalogs(query_metric->GetDatabaseId()) ->GetQueryMetricsCatalog() ->InsertQueryMetrics( - query_metric->GetName(), 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); + 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); LOG_TRACE("Query Metric Tuple inserted"); } diff --git a/test/binder/binder_test.cpp b/test/binder/binder_test.cpp index 40ed8b5e70b..4f1467285f1 100644 --- a/test/binder/binder_test.cpp +++ b/test/binder/binder_test.cpp @@ -28,11 +28,11 @@ #include "sql/testing_sql_util.h" #include "type/value_factory.h" +using std::make_shared; +using std::make_tuple; using std::string; using std::unique_ptr; using std::vector; -using std::make_tuple; -using std::make_shared; namespace peloton { namespace test { @@ -128,10 +128,14 @@ TEST_F(BinderCorrectnessTest, SelectStatementTest) { oid_t db_oid = catalog_ptr->GetDatabaseWithName(default_database_name, txn)->GetOid(); - oid_t tableA_oid = - catalog_ptr->GetTableWithName(default_database_name, "a", txn)->GetOid(); - oid_t tableB_oid = - catalog_ptr->GetTableWithName(default_database_name, "b", txn)->GetOid(); + oid_t tableA_oid = catalog_ptr + ->GetTableWithName(default_database_name, + DEFUALT_SCHEMA_NAME, "a", txn) + ->GetOid(); + oid_t tableB_oid = catalog_ptr + ->GetTableWithName(default_database_name, + DEFUALT_SCHEMA_NAME, "b", txn) + ->GetOid(); txn_manager.CommitTransaction(txn); // Check select_list @@ -257,8 +261,10 @@ TEST_F(BinderCorrectnessTest, DeleteStatementTest) { auto txn = txn_manager.BeginTransaction(); oid_t db_oid = catalog_ptr->GetDatabaseWithName(default_database_name, txn)->GetOid(); - oid_t tableB_oid = - catalog_ptr->GetTableWithName(default_database_name, "b", txn)->GetOid(); + oid_t tableB_oid = catalog_ptr + ->GetTableWithName(default_database_name, + DEFUALT_SCHEMA_NAME, "b", txn) + ->GetOid(); string deleteSQL = "DELETE FROM b WHERE 1 = b1 AND b2 = 'str'"; unique_ptr binder( diff --git a/test/brain/query_logger_test.cpp b/test/brain/query_logger_test.cpp index b2a65eff085..c3affa7fd40 100644 --- a/test/brain/query_logger_test.cpp +++ b/test/brain/query_logger_test.cpp @@ -13,8 +13,8 @@ #include "common/harness.h" #include "brain/query_logger.h" -#include "sql/testing_sql_util.h" #include "settings/settings_manager.h" +#include "sql/testing_sql_util.h" namespace peloton { namespace test { @@ -27,7 +27,8 @@ class QueryLoggerTests : public PelotonTest { // query to check that logging is done select_query_ = - "SELECT query_string, fingerprint FROM pg_catalog.pg_query_history;"; + "SELECT query_string, fingerprint FROM " + "peloton.pg_catalog.pg_query_history;"; brain::QueryLogger::Fingerprint fingerprint{select_query_}; select_query_fingerprint_ = fingerprint.GetFingerprint(); diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index 001d772535b..02e76b638bf 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -41,11 +41,12 @@ TEST_F(CatalogTests, BootstrappingCatalog) { auto txn = txn_manager.BeginTransaction(); storage::Database *database = catalog->GetDatabaseWithName(CATALOG_DATABASE_NAME, txn); + // Check database metric table + storage::DataTable *db_metric_table = + catalog->GetTableWithName(CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, + DATABASE_METRICS_CATALOG_NAME, txn); txn_manager.CommitTransaction(txn); EXPECT_NE(nullptr, database); - // Check database metric table - auto db_metric_table = - database->GetTableWithName(DATABASE_METRICS_CATALOG_NAME); EXPECT_NE(nullptr, db_metric_table); } // @@ -53,17 +54,10 @@ TEST_F(CatalogTests, CreatingDatabase) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); catalog::Catalog::GetInstance()->CreateDatabase("emp_db", txn); - auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - CATALOG_DATABASE_NAME, INDEX_CATALOG_NAME, txn); - auto index_object = table_object->GetIndexObject(INDEX_CATALOG_PKEY_OID); - std::vector key_attrs = index_object->GetKeyAttrs(); - EXPECT_EQ("emp_db", catalog::Catalog::GetInstance() ->GetDatabaseWithName("emp_db", txn) ->GetDBName()); txn_manager.CommitTransaction(txn); - EXPECT_EQ(1, key_attrs.size()); - EXPECT_EQ(0, key_attrs[0]); } TEST_F(CatalogTests, CreatingTable) { @@ -83,11 +77,13 @@ TEST_F(CatalogTests, CreatingTable) { std::unique_ptr table_schema_3( new catalog::Schema({id_column, name_column})); - catalog::Catalog::GetInstance()->CreateTable("emp_db", "emp_table", - std::move(table_schema), txn); - catalog::Catalog::GetInstance()->CreateTable("emp_db", "department_table", + catalog::Catalog::GetInstance()->CreateTable( + "emp_db", DEFUALT_SCHEMA_NAME, "emp_table", std::move(table_schema), txn); + catalog::Catalog::GetInstance()->CreateTable("emp_db", DEFUALT_SCHEMA_NAME, + "department_table", std::move(table_schema_2), txn); - catalog::Catalog::GetInstance()->CreateTable("emp_db", "salary_table", + catalog::Catalog::GetInstance()->CreateTable("emp_db", DEFUALT_SCHEMA_NAME, + "salary_table", std::move(table_schema_3), txn); // insert random tuple into DATABASE_METRICS_CATALOG and check std::unique_ptr pool(new type::EphemeralPool()); @@ -112,13 +108,12 @@ TEST_F(CatalogTests, CreatingTable) { ->GetParamTypes("a query", txn); EXPECT_EQ(1, param1.len); EXPECT_EQ('a', *param1.buf); - + // check colum object EXPECT_EQ("name", catalog::Catalog::GetInstance() - ->GetDatabaseWithName("emp_db", txn) - ->GetTableWithName("department_table") - ->GetSchema() - ->GetColumn(1) - .GetName()); + ->GetTableObject("emp_db", DEFUALT_SCHEMA_NAME, + "department_table", txn) + ->GetColumnObject(1) + ->GetColumnName()); txn_manager.CommitTransaction(txn); // EXPECT_EQ(5, time_stamp); @@ -161,7 +156,7 @@ TEST_F(CatalogTests, TableObject) { auto txn = txn_manager.BeginTransaction(); auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - "emp_db", "department_table", txn); + "emp_db", DEFUALT_SCHEMA_NAME, "department_table", txn); auto index_objects = table_object->GetIndexObjects(); auto column_objects = table_object->GetColumnObjects(); @@ -195,7 +190,7 @@ TEST_F(CatalogTests, TableObject) { bool update_result = pg_table->UpdateVersionId(1, department_table_oid, txn); // get version id after update, invalidate old cache table_object = catalog::Catalog::GetInstance()->GetTableObject( - "emp_db", "department_table", txn); + "emp_db", DEFUALT_SCHEMA_NAME, "department_table", txn); uint32_t version_oid = table_object->GetVersionId(); EXPECT_NE(department_table_oid, INVALID_OID); EXPECT_EQ(update_result, true); @@ -208,22 +203,23 @@ TEST_F(CatalogTests, DroppingTable) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); - // NOTE: everytime we create a database, there will be 7 catalog tables inside + // NOTE: everytime we create a database, there will be 8 catalog tables inside EXPECT_EQ( - 10, + 11, (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); auto database_object = catalog::Catalog::GetInstance()->GetDatabaseObject("emp_db", txn); EXPECT_NE(nullptr, database_object); - catalog::Catalog::GetInstance()->DropTable("emp_db", "department_table", txn); + catalog::Catalog::GetInstance()->DropTable("emp_db", DEFUALT_SCHEMA_NAME, + "department_table", txn); database_object = catalog::Catalog::GetInstance()->GetDatabaseObject("emp_db", txn); EXPECT_NE(nullptr, database_object); auto department_table_object = - database_object->GetTableObject("department_table"); + database_object->GetTableObject("department_table", DEFUALT_SCHEMA_NAME); EXPECT_EQ( - 9, + 10, (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); @@ -232,29 +228,30 @@ TEST_F(CatalogTests, DroppingTable) { // Try to drop again txn = txn_manager.BeginTransaction(); EXPECT_THROW(catalog::Catalog::GetInstance()->DropTable( - "emp_db", "department_table", txn), + "emp_db", DEFUALT_SCHEMA_NAME, "department_table", txn), CatalogException); // EXPECT_EQ( - 9, + 10, (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); // Drop a table that does not exist txn = txn_manager.BeginTransaction(); - EXPECT_THROW( - catalog::Catalog::GetInstance()->DropTable("emp_db", "void_table", txn), - CatalogException); + EXPECT_THROW(catalog::Catalog::GetInstance()->DropTable( + "emp_db", DEFUALT_SCHEMA_NAME, "void_table", txn), + CatalogException); EXPECT_EQ( - 9, + 10, (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); // Drop the other table txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->DropTable("emp_db", "emp_table", txn); + catalog::Catalog::GetInstance()->DropTable("emp_db", DEFUALT_SCHEMA_NAME, + "emp_table", txn); EXPECT_EQ( - 8, + 9, (int)catalog->GetDatabaseObject("emp_db", txn)->GetTableObjects().size()); txn_manager.CommitTransaction(txn); } diff --git a/test/catalog/constraints_test.cpp b/test/catalog/constraints_test.cpp index 02dfa6a9fb1..d37f4f7081e 100644 --- a/test/catalog/constraints_test.cpp +++ b/test/catalog/constraints_test.cpp @@ -10,20 +10,20 @@ // //===----------------------------------------------------------------------===// -#include "sql/testing_sql_util.h" #include "gtest/gtest.h" +#include "sql/testing_sql_util.h" #include "catalog/testing_constraints_util.h" -#include "common/internal_types.h" #include "catalog/catalog.h" +#include "catalog/foreign_key.h" +#include "common/internal_types.h" #include "concurrency/testing_transaction_util.h" -#include "planner/plan_util.h" -#include "planner/create_plan.h" #include "executor/executors.h" -#include "catalog/foreign_key.h" -#include "parser/postgresparser.h" #include "optimizer/optimizer.h" +#include "parser/postgresparser.h" +#include "planner/create_plan.h" +#include "planner/plan_util.h" #define DEFAULT_VALUE 11111 @@ -54,12 +54,13 @@ TEST_F(ConstraintsTests, NOTNULLTest) { // Set all of the columns to be NOT NULL std::vector> constraints; for (int i = 0; i < CONSTRAINTS_NUM_COLS; i++) { - constraints.push_back({ catalog::Constraint(ConstraintType::NOTNULL, - "notnull_constraint") }); + constraints.push_back( + {catalog::Constraint(ConstraintType::NOTNULL, "notnull_constraint")}); } std::vector multi_constraints; storage::DataTable *data_table = - TestingConstraintsUtil::CreateAndPopulateTable(constraints, multi_constraints); + TestingConstraintsUtil::CreateAndPopulateTable(constraints, + multi_constraints); // Bootstrap auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); @@ -68,14 +69,12 @@ TEST_F(ConstraintsTests, NOTNULLTest) { type::ValueFactory::GetIntegerValue(1), type::ValueFactory::GetIntegerValue(22), type::ValueFactory::GetDecimalValue(3.33), - type::ValueFactory::GetVarcharValue("4444") - }; + type::ValueFactory::GetVarcharValue("4444")}; std::vector null_values = { type::ValueFactory::GetNullValueByType(type::TypeId::INTEGER), type::ValueFactory::GetNullValueByType(type::TypeId::INTEGER), type::ValueFactory::GetNullValueByType(type::TypeId::DECIMAL), - type::ValueFactory::GetNullValueByType(type::TypeId::VARCHAR) - }; + type::ValueFactory::GetNullValueByType(type::TypeId::VARCHAR)}; // Test1: Insert a tuple with column that satisfies the requirement auto txn = txn_manager.BeginTransaction(); @@ -103,8 +102,8 @@ TEST_F(ConstraintsTests, NOTNULLTest) { } EXPECT_TRUE(hasException); txn_manager.CommitTransaction(txn); - } // FOR - + } // FOR + // free the database just created txn = txn_manager.BeginTransaction(); catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); @@ -120,22 +119,23 @@ TEST_F(ConstraintsTests, DEFAULTTEST) { // COL_A if (i == 0) { constraints.push_back( - { catalog::Constraint(ConstraintType::PRIMARY, "pkey") }); + {catalog::Constraint(ConstraintType::PRIMARY, "pkey")}); } // COL_B else if (i == 1) { catalog::Constraint default_const(ConstraintType::DEFAULT, "default"); default_const.addDefaultValue( type::ValueFactory::GetIntegerValue(DEFAULT_VALUE)); - constraints.push_back({ }); + constraints.push_back({}); } // COL_C + COL_D else { - constraints.push_back({ }); + constraints.push_back({}); } } std::vector multi_constraints; - TestingConstraintsUtil::CreateAndPopulateTable(constraints, multi_constraints); + TestingConstraintsUtil::CreateAndPopulateTable(constraints, + multi_constraints); // Bootstrap std::vector result; @@ -146,17 +146,17 @@ TEST_F(ConstraintsTests, DEFAULTTEST) { // Test1: Insert a tuple without the second column defined // It should get set with the default value std::string sql = StringUtil::Format( - "INSERT INTO %s (col_a, col_c, col_d) " - "VALUES (9999, 2.2, 'xxx');", CONSTRAINTS_TEST_TABLE); - auto status = TestingSQLUtil::ExecuteSQLQuery( - sql, result, tuple_descriptor, rows_affected, error_message - ); + "INSERT INTO %s (col_a, col_c, col_d) " + "VALUES (9999, 2.2, 'xxx');", + CONSTRAINTS_TEST_TABLE); + auto status = TestingSQLUtil::ExecuteSQLQuery(sql, result, tuple_descriptor, + rows_affected, error_message); EXPECT_EQ(ResultType::SUCCESS, status); sql = StringUtil::Format("SELECT col_d FROM %s WHERE col_a = 9999", CONSTRAINTS_TEST_TABLE); - status = TestingSQLUtil::ExecuteSQLQuery( - sql, result, tuple_descriptor, rows_affected, error_message); + status = TestingSQLUtil::ExecuteSQLQuery(sql, result, tuple_descriptor, + rows_affected, error_message); EXPECT_EQ(ResultType::SUCCESS, status); std::string resultStr = TestingSQLUtil::GetResultValueAsString(result, 0); LOG_INFO("OUTPUT:\n%s", resultStr.c_str()); @@ -179,7 +179,8 @@ TEST_F(ConstraintsTests, CHECKTest) { type::Value tmp_value = type::ValueFactory::GetIntegerValue(0); constraints.AddCheck(ExpressionType::COMPARE_GREATERTHAN, tmp_value); column1.AddConstraint(constraints); - LOG_DEBUG("%s %s", peloton::DOUBLE_STAR.c_str(), constraints.GetInfo().c_str()); + LOG_DEBUG("%s %s", peloton::DOUBLE_STAR.c_str(), + constraints.GetInfo().c_str()); catalog::Schema *table_schema = new catalog::Schema({column1}); std::string table_name("TEST_TABLE"); bool own_schema = true; @@ -230,15 +231,17 @@ TEST_F(ConstraintsTests, UNIQUETest) { auto constraints = catalog::Constraint(ConstraintType::UNIQUE, "unique1"); column1.AddConstraint(constraints); - LOG_DEBUG("%s %s", peloton::DOUBLE_STAR.c_str(), constraints.GetInfo().c_str()); + LOG_DEBUG("%s %s", peloton::DOUBLE_STAR.c_str(), + constraints.GetInfo().c_str()); std::unique_ptr table_schema( new catalog::Schema({column1, column2})); std::string table_name("TEST_TABLE"); - catalog::Catalog::GetInstance()->CreateTable(DEFAULT_DB_NAME, table_name, + catalog::Catalog::GetInstance()->CreateTable(DEFAULT_DB_NAME, + DEFUALT_SCHEMA_NAME, table_name, std::move(table_schema), txn); + storage::DataTable *table = catalog::Catalog::GetInstance()->GetTableWithName( + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, table_name, txn); txn_manager.CommitTransaction(txn); - storage::Database *database = catalog->GetDatabaseWithName(DEFAULT_DB_NAME); - storage::DataTable *table = database->GetTableWithName(table_name); // table->AddUNIQUEIndex(); @@ -288,7 +291,7 @@ TEST_F(ConstraintsTests, UNIQUETest) { } #endif -//TEST_F(ConstraintsTests, MULTIUNIQUETest) { +// TEST_F(ConstraintsTests, MULTIUNIQUETest) { // auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); // auto catalog = catalog::Catalog::GetInstance(); // auto txn = txn_manager.BeginTransaction(); @@ -368,7 +371,7 @@ TEST_F(ConstraintsTests, UNIQUETest) { // txn_manager.CommitTransaction(txn); //} -//TEST_F(ConstraintsTests, ForeignKeySingleInsertTest) { +// TEST_F(ConstraintsTests, ForeignKeySingleInsertTest) { // // First, initial 2 tables like following // // TABLE A -- src table TABLE B -- sink table // // a int(primary, ref B) b int b int(primary) c int @@ -393,8 +396,9 @@ TEST_F(ConstraintsTests, UNIQUETest) { // // auto constraints = catalog::Constraint(ConstraintType::PRIMARY, "primary1"); // column1.AddConstraint(constraints); -// LOG_DEBUG("%s %s", peloton::DOUBLE_STAR.c_str(), constraints.GetInfo().c_str()); -// std::unique_ptr tableA_schema( +// LOG_DEBUG("%s %s", peloton::DOUBLE_STAR.c_str(), +// constraints.GetInfo().c_str()); std::unique_ptr +// tableA_schema( // new catalog::Schema({column1, column2})); // // catalog->CreateTable(db_name, table_a_name, std::move(tableA_schema), txn); @@ -413,9 +417,10 @@ TEST_F(ConstraintsTests, UNIQUETest) { // auto table_b = catalog->GetTableWithName(db_name, table_b_name); // // oid_t sink_table_id = table_b->GetOid(); -// std::vector sink_col_ids = { table_b->GetSchema()->GetColumnID("b") }; -// std::vector source_col_ids = { table_a->GetSchema()->GetColumnID("a") }; -// catalog::ForeignKey *foreign_key = new catalog::ForeignKey( +// std::vector sink_col_ids = { table_b->GetSchema()->GetColumnID("b") +// }; std::vector source_col_ids = { +// table_a->GetSchema()->GetColumnID("a") }; catalog::ForeignKey *foreign_key = +// new catalog::ForeignKey( // sink_table_id, sink_col_ids, source_col_ids, // FKConstrActionType::NOACTION, // FKConstrActionType::NOACTION, @@ -463,7 +468,7 @@ TEST_F(ConstraintsTests, UNIQUETest) { // delete foreign_key; //} -//TEST_F(ConstraintsTests, ForeignKeyMultiInsertTest) { +// TEST_F(ConstraintsTests, ForeignKeyMultiInsertTest) { // // First, initial 2 tables like following // // TABLE A -- src table TABLE B -- sink table // // a int(primary, ref B) b int b int(primary) c int @@ -498,7 +503,8 @@ TEST_F(ConstraintsTests, UNIQUETest) { // cols.push_back(0); // cols.push_back(1); // auto mc = -// catalog::MultiConstraint(ConstraintType::PRIMARY, "multiprimary1", cols); +// catalog::MultiConstraint(ConstraintType::PRIMARY, "multiprimary1", +// cols); // LOG_DEBUG("%s MULTI CONSTRAINTS %s %s", peloton::DOUBLE_STAR.c_str(), // peloton::DOUBLE_STAR.c_str(), mc.GetInfo().c_str()); // @@ -514,9 +520,10 @@ TEST_F(ConstraintsTests, UNIQUETest) { // // // Create foreign key tableA.B -> tableB.B // oid_t sink_table_id = table_b->GetOid(); -// std::vector sink_col_ids = { table_b->GetSchema()->GetColumnID("b") }; -// std::vector source_col_ids = { table_a->GetSchema()->GetColumnID("b") }; -// catalog::ForeignKey *foreign_key = new catalog::ForeignKey( +// std::vector sink_col_ids = { table_b->GetSchema()->GetColumnID("b") +// }; std::vector source_col_ids = { +// table_a->GetSchema()->GetColumnID("b") }; catalog::ForeignKey *foreign_key = +// new catalog::ForeignKey( // sink_table_id, sink_col_ids, source_col_ids, // FKConstrActionType::RESTRICT, // FKConstrActionType::CASCADE, diff --git a/test/codegen/bloom_filter_test.cpp b/test/codegen/bloom_filter_test.cpp index 5be9bf35500..bf9962ca834 100644 --- a/test/codegen/bloom_filter_test.cpp +++ b/test/codegen/bloom_filter_test.cpp @@ -18,10 +18,10 @@ #include "codegen/codegen.h" #include "codegen/counting_consumer.h" #include "codegen/function_builder.h" -#include "codegen/query_parameters.h" #include "codegen/lang/if.h" #include "codegen/lang/loop.h" #include "codegen/proxy/bloom_filter_proxy.h" +#include "codegen/query_parameters.h" #include "codegen/testing_codegen_util.h" #include "codegen/util/bloom_filter.h" #include "common/timer.h" @@ -167,7 +167,7 @@ TEST_F(BloomFilterCodegenTest, FalsePositiveRateTest) { ASSERT_TRUE(code_context.Compile()); - typedef void (*ftype)(codegen::util::BloomFilter *bloom_filter, int *, int, + typedef void (*ftype)(codegen::util::BloomFilter * bloom_filter, int *, int, int *); ftype f = (ftype)code_context.GetRawFunctionPointer(func.GetFunction()); @@ -213,7 +213,8 @@ TEST_F(BloomFilterCodegenTest, PerformanceTest) { int curr_size = 0; std::vector numbers; std::unordered_set number_set; - auto *table1 = catalog->GetTableWithName(DEFAULT_DB_NAME, table1_name, txn); + auto *table1 = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, + table1_name, txn); while (curr_size < table1_target_size) { // Find a unique random number int random; @@ -233,7 +234,8 @@ 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, table2_name, txn); + auto *table2 = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, + table2_name, txn); unsigned outer_table_cardinality = numbers.size() * outer_to_inner_ratio; for (unsigned i = 0; i < outer_table_cardinality; i++) { int number; @@ -332,7 +334,7 @@ void BloomFilterCodegenTest::CreateTable(std::string table_name, int tuple_size, } auto *catalog = catalog::Catalog::GetInstance(); catalog->CreateTable( - DEFAULT_DB_NAME, table_name, + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, table_name, std::unique_ptr(new catalog::Schema(cols)), txn); } diff --git a/test/codegen/table_scan_translator_test.cpp b/test/codegen/table_scan_translator_test.cpp index 3b107a6ab17..881e24a6996 100644 --- a/test/codegen/table_scan_translator_test.cpp +++ b/test/codegen/table_scan_translator_test.cpp @@ -10,7 +10,6 @@ // //===----------------------------------------------------------------------===// -#include "storage/storage_manager.h" #include "catalog/catalog.h" #include "codegen/query_compiler.h" #include "common/harness.h" @@ -18,6 +17,7 @@ #include "expression/conjunction_expression.h" #include "expression/operator_expression.h" #include "planner/seq_scan_plan.h" +#include "storage/storage_manager.h" #include "codegen/testing_codegen_util.h" @@ -67,11 +67,12 @@ class TableScanTranslatorTest : public PelotonCodeGenTest { std::unique_ptr schema{new catalog::Schema(cols)}; // Insert table in catalog - catalog->CreateTable(test_db_name, all_cols_table_name, std::move(schema), - txn); + catalog->CreateTable(test_db_name, DEFUALT_SCHEMA_NAME, all_cols_table_name, + std::move(schema), txn); - auto &table = GetAllColsTable(); - auto *table_schema = table.GetSchema(); + all_cols_table = catalog->GetTableWithName( + test_db_name, DEFUALT_SCHEMA_NAME, all_cols_table_name, txn); + auto *table_schema = all_cols_table->GetSchema(); // Insert one row where all columns are NULL storage::Tuple tuple{table_schema, true}; @@ -82,7 +83,7 @@ class TableScanTranslatorTest : public PelotonCodeGenTest { ItemPointer *index_entry_ptr = nullptr; ItemPointer tuple_slot_id = - table.InsertTuple(&tuple, txn, &index_entry_ptr); + all_cols_table->InsertTuple(&tuple, txn, &index_entry_ptr); PELOTON_ASSERT(tuple_slot_id.block != INVALID_OID); PELOTON_ASSERT(tuple_slot_id.offset != INVALID_OID); @@ -90,12 +91,11 @@ class TableScanTranslatorTest : public PelotonCodeGenTest { txn_manager.CommitTransaction(txn); } - storage::DataTable &GetAllColsTable() const { - return *GetDatabase().GetTableWithName(all_cols_table_name); - } + storage::DataTable *GetAllColsTable() { return all_cols_table; } private: uint32_t num_rows_to_insert = 64; + storage::DataTable *all_cols_table = nullptr; }; TEST_F(TableScanTranslatorTest, AllColumnsScan) { @@ -125,13 +125,12 @@ TEST_F(TableScanTranslatorTest, AllColumnsScanWithNulls) { // // SELECT * FROM crazy_table; // - - auto &tbl = GetAllColsTable(); - std::vector all_col_ids(tbl.GetSchema()->GetColumnCount()); + auto *tbl = GetAllColsTable(); + std::vector all_col_ids(tbl->GetSchema()->GetColumnCount()); std::iota(all_col_ids.begin(), all_col_ids.end(), 0); // Setup the scan plan node - planner::SeqScanPlan scan{&tbl, nullptr, all_col_ids}; + planner::SeqScanPlan scan{tbl, nullptr, all_col_ids}; // Do binding planner::BindingContext context; @@ -151,8 +150,8 @@ TEST_F(TableScanTranslatorTest, AllColumnsScanWithNulls) { auto &tuple = buffer.GetOutputTuples()[0]; for (uint32_t i = 0; i < all_col_ids.size(); i++) { auto col_val = tuple.GetValue(i); - EXPECT_TRUE(col_val.IsNull()) << "Result value: " << col_val.ToString() - << ", expected NULL"; + EXPECT_TRUE(col_val.IsNull()) + << "Result value: " << col_val.ToString() << ", expected NULL"; } } @@ -217,15 +216,15 @@ TEST_F(TableScanTranslatorTest, SimplePredicateWithNull) { // First tuple should be (0, 1) EXPECT_EQ(CmpBool::CmpTrue, results[0].GetValue(0).CompareEquals( - type::ValueFactory::GetIntegerValue(0))); + type::ValueFactory::GetIntegerValue(0))); EXPECT_EQ(CmpBool::CmpTrue, results[0].GetValue(1).CompareEquals( - type::ValueFactory::GetIntegerValue(1))); + type::ValueFactory::GetIntegerValue(1))); // Second tuple should be (10, 11) EXPECT_EQ(CmpBool::CmpTrue, results[1].GetValue(0).CompareEquals( - type::ValueFactory::GetIntegerValue(10))); + type::ValueFactory::GetIntegerValue(10))); EXPECT_EQ(CmpBool::CmpTrue, results[1].GetValue(1).CompareEquals( - type::ValueFactory::GetIntegerValue(11))); + type::ValueFactory::GetIntegerValue(11))); } TEST_F(TableScanTranslatorTest, PredicateOnNonOutputColumn) { @@ -292,9 +291,9 @@ TEST_F(TableScanTranslatorTest, ScanWithConjunctionPredicate) { const auto &results = buffer.GetOutputTuples(); ASSERT_EQ(1, results.size()); EXPECT_EQ(CmpBool::CmpTrue, results[0].GetValue(0).CompareEquals( - type::ValueFactory::GetIntegerValue(20))); + type::ValueFactory::GetIntegerValue(20))); EXPECT_EQ(CmpBool::CmpTrue, results[0].GetValue(1).CompareEquals( - type::ValueFactory::GetIntegerValue(21))); + type::ValueFactory::GetIntegerValue(21))); } TEST_F(TableScanTranslatorTest, ScanWithAddPredicate) { @@ -580,10 +579,10 @@ TEST_F(TableScanTranslatorTest, ScanWithModuloPredicate) { const auto &results = buffer.GetOutputTuples(); ASSERT_EQ(1, results.size()); EXPECT_EQ(CmpBool::CmpTrue, results[0].GetValue(0).CompareEquals( - type::ValueFactory::GetIntegerValue(0))); + type::ValueFactory::GetIntegerValue(0))); EXPECT_EQ(CmpBool::CmpTrue, results[0].GetValue(1).CompareEquals( - type::ValueFactory::GetIntegerValue(1))); + type::ValueFactory::GetIntegerValue(1))); } } // namespace test -} // namespace peloton \ No newline at end of file +} // namespace peloton diff --git a/test/codegen/testing_codegen_util.cpp b/test/codegen/testing_codegen_util.cpp index 91cc858927b..fe8f6c26440 100644 --- a/test/codegen/testing_codegen_util.cpp +++ b/test/codegen/testing_codegen_util.cpp @@ -16,14 +16,14 @@ #include "codegen/proxy/runtime_functions_proxy.h" #include "codegen/proxy/value_proxy.h" #include "codegen/proxy/values_runtime_proxy.h" +#include "codegen/query_cache.h" #include "concurrency/transaction_manager_factory.h" -#include "executor/plan_executor.h" #include "executor/executor_context.h" +#include "executor/plan_executor.h" #include "expression/comparison_expression.h" #include "expression/operator_expression.h" #include "expression/tuple_value_expression.h" #include "storage/table_factory.h" -#include "codegen/query_cache.h" namespace peloton { namespace test { @@ -107,21 +107,25 @@ 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, test_table_names[i], + catalog->CreateTable(test_db_name, DEFUALT_SCHEMA_NAME, test_table_names[i], std::move(table_schema), txn, false, tuples_per_tilegroup); - test_table_oids.push_back(catalog->GetTableObject(test_db_name, - test_table_names[i], - txn)->GetTableOid()); + test_table_oids.push_back(catalog + ->GetTableObject(test_db_name, + DEFUALT_SCHEMA_NAME, + test_table_names[i], txn) + ->GetTableOid()); } for (int i = 4; i < 5; i++) { auto table_schema = CreateTestSchema(true); - catalog->CreateTable(test_db_name, test_table_names[i], + catalog->CreateTable(test_db_name, DEFUALT_SCHEMA_NAME, test_table_names[i], std::move(table_schema), txn, false, tuples_per_tilegroup); - test_table_oids.push_back(catalog->GetTableObject(test_db_name, - test_table_names[i], - txn)->GetTableOid()); + test_table_oids.push_back(catalog + ->GetTableObject(test_db_name, + DEFUALT_SCHEMA_NAME, + test_table_names[i], txn) + ->GetTableOid()); } } @@ -134,8 +138,9 @@ void PelotonCodeGenTest::LoadTestTable(oid_t table_id, uint32_t num_rows, auto *table_schema = test_table.GetSchema(); size_t curr_size = test_table.GetTupleCount(); - auto col_val = - [](uint32_t tuple_id, uint32_t col_id) { return 10 * tuple_id + col_id; }; + auto col_val = [](uint32_t tuple_id, uint32_t col_id) { + return 10 * tuple_id + col_id; + }; const bool allocate = true; auto testing_pool = TestingHarness::GetInstance().GetTestingPool(); diff --git a/test/executor/copy_test.cpp b/test/executor/copy_test.cpp index be0c3fa943d..77c1c9eecc9 100644 --- a/test/executor/copy_test.cpp +++ b/test/executor/copy_test.cpp @@ -112,7 +112,8 @@ TEST_F(CopyTests, Copying) { // Now Copying end-to-end LOG_TRACE("Copying a table..."); std::string copy_sql = - "COPY emp_db.department_table TO './copy_output.csv' DELIMITER ',';"; + "COPY emp_db.public.department_table TO './copy_output.csv' DELIMITER " + "',';"; txn = txn_manager.BeginTransaction(); LOG_TRACE("Query: %s", copy_sql.c_str()); std::unique_ptr statement(new Statement("COPY", copy_sql)); diff --git a/test/executor/create_index_test.cpp b/test/executor/create_index_test.cpp index d0d208d492c..034eca553fa 100644 --- a/test/executor/create_index_test.cpp +++ b/test/executor/create_index_test.cpp @@ -205,7 +205,7 @@ TEST_F(CreateIndexTests, CreatingIndex) { txn = txn_manager.BeginTransaction(); auto target_table_ = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, "department_table", txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", txn); // Expected 2 , Primary key index + created index EXPECT_EQ(target_table_->GetIndexCount(), 2); diff --git a/test/executor/create_test.cpp b/test/executor/create_test.cpp index c147c159724..0faede0508d 100644 --- a/test/executor/create_test.cpp +++ b/test/executor/create_test.cpp @@ -99,8 +99,9 @@ TEST_F(CreateTests, CreatingTable) { new executor::ExecutorContext(txn)); // Create plans - planner::CreatePlan node("department_table", DEFAULT_DB_NAME, - std::move(table_schema), CreateType::TABLE); + planner::CreatePlan node("department_table", DEFUALT_SCHEMA_NAME, + DEFAULT_DB_NAME, std::move(table_schema), + CreateType::TABLE); // Create executer executor::CreateExecutor executor(&node, context.get()); @@ -140,8 +141,8 @@ TEST_F(CreateTests, CreatingUDFs) { new executor::ExecutorContext(txn)); // Create plans - planner::CreatePlan node("accounts", DEFAULT_DB_NAME, std::move(table_schema), - CreateType::TABLE); + planner::CreatePlan node("accounts", DEFUALT_SCHEMA_NAME, DEFAULT_DB_NAME, + std::move(table_schema), CreateType::TABLE); // Create executer executor::CreateExecutor executor(&node, context.get()); @@ -242,8 +243,8 @@ TEST_F(CreateTests, CreatingTrigger) { new executor::ExecutorContext(txn)); // Create plans - planner::CreatePlan node("accounts", DEFAULT_DB_NAME, std::move(table_schema), - CreateType::TABLE); + planner::CreatePlan node("accounts", DEFUALT_SCHEMA_NAME, DEFAULT_DB_NAME, + std::move(table_schema), CreateType::TABLE); // Create executer executor::CreateExecutor executor(&node, context.get()); @@ -331,8 +332,8 @@ TEST_F(CreateTests, CreatingTrigger) { // Check the effect of creation storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName(DEFAULT_DB_NAME, - "accounts", txn); + catalog::Catalog::GetInstance()->GetTableWithName( + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "accounts", txn); txn_manager.CommitTransaction(txn); EXPECT_EQ(1, target_table->GetTriggerNumber()); trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); @@ -372,8 +373,8 @@ TEST_F(CreateTests, CreatingTriggerWithoutWhen) { new executor::ExecutorContext(txn)); // Create plans - planner::CreatePlan node("accounts", DEFAULT_DB_NAME, std::move(table_schema), - CreateType::TABLE); + planner::CreatePlan node("accounts", DEFUALT_SCHEMA_NAME, DEFAULT_DB_NAME, + std::move(table_schema), CreateType::TABLE); // Create executer executor::CreateExecutor executor(&node, context.get()); @@ -419,8 +420,8 @@ TEST_F(CreateTests, CreatingTriggerWithoutWhen) { // Check the effect of creation storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName(DEFAULT_DB_NAME, - "accounts", txn); + catalog::Catalog::GetInstance()->GetTableWithName( + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "accounts", txn); txn_manager.CommitTransaction(txn); EXPECT_EQ(1, target_table->GetTriggerNumber()); trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); @@ -461,8 +462,8 @@ TEST_F(CreateTests, CreatingTriggerInCatalog) { new executor::ExecutorContext(txn)); // Create plans - planner::CreatePlan node("accounts", DEFAULT_DB_NAME, std::move(table_schema), - CreateType::TABLE); + planner::CreatePlan node("accounts", DEFUALT_SCHEMA_NAME, DEFAULT_DB_NAME, + std::move(table_schema), CreateType::TABLE); // Create executer executor::CreateExecutor executor(&node, context.get()); @@ -501,7 +502,7 @@ TEST_F(CreateTests, CreatingTriggerInCatalog) { // check whether the trigger catalog table contains this new trigger auto table_object = catalog::Catalog::GetInstance()->GetTableObject( - DEFAULT_DB_NAME, "accounts", txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "accounts", txn); auto trigger_list = catalog::Catalog::GetInstance() ->GetSystemCatalogs(table_object->GetDatabaseOid()) diff --git a/test/executor/delete_test.cpp b/test/executor/delete_test.cpp index 98928ee7e4e..f081b766720 100644 --- a/test/executor/delete_test.cpp +++ b/test/executor/delete_test.cpp @@ -116,15 +116,16 @@ TEST_F(DeleteTests, VariousOperations) { new catalog::Schema({id_column, name_column})); std::unique_ptr context( new executor::ExecutorContext(txn)); - planner::CreatePlan node("department_table", DEFAULT_DB_NAME, - std::move(table_schema), CreateType::TABLE); + planner::CreatePlan node("department_table", DEFUALT_SCHEMA_NAME, + DEFAULT_DB_NAME, std::move(table_schema), + CreateType::TABLE); executor::CreateExecutor create_executor(&node, context.get()); create_executor.Init(); create_executor.Execute(); LOG_INFO("Table created!"); storage::DataTable *table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, "department_table", txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", txn); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); diff --git a/test/executor/drop_test.cpp b/test/executor/drop_test.cpp index 28005a05a5b..271c590e500 100644 --- a/test/executor/drop_test.cpp +++ b/test/executor/drop_test.cpp @@ -97,28 +97,29 @@ TEST_F(DropTests, DroppingTable) { txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_NAME, "department_table", + catalog->CreateTable(TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", std::move(table_schema), txn); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_NAME, "department_table_2", + catalog->CreateTable(TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table_2", std::move(table_schema2), txn); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - // NOTE: everytime we create a database, there will be 7 catalog tables inside + // NOTE: everytime we create a database, there will be 8 catalog tables inside EXPECT_EQ((int)catalog->GetDatabaseObject(TEST_DB_NAME, txn) ->GetTableObjects() .size(), - 9); + 10); // Now dropping the table using the executor - catalog->DropTable(TEST_DB_NAME, "department_table", txn); + catalog->DropTable(TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", + txn); EXPECT_EQ((int)catalog->GetDatabaseObject(TEST_DB_NAME, txn) ->GetTableObjects() .size(), - 8); + 9); // free the database just created catalog->DropDatabaseWithName(TEST_DB_NAME, txn); @@ -148,7 +149,7 @@ TEST_F(DropTests, DroppingTrigger) { txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_NAME, "department_table", + catalog->CreateTable(TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", std::move(table_schema), txn); txn_manager.CommitTransaction(txn); @@ -180,7 +181,7 @@ TEST_F(DropTests, DroppingTrigger) { // Check the effect of creation storage::DataTable *target_table = catalog::Catalog::GetInstance()->GetTableWithName( - TEST_DB_NAME, "department_table", txn); + TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", txn); txn_manager.CommitTransaction(txn); EXPECT_EQ(1, target_table->GetTriggerNumber()); trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); @@ -212,8 +213,9 @@ TEST_F(DropTests, DroppingTrigger) { // Now dropping the table using the executer txn = txn_manager.BeginTransaction(); - catalog->DropTable(TEST_DB_NAME, "department_table", txn); - EXPECT_EQ(7, (int)catalog::Catalog::GetInstance() + catalog->DropTable(TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", + txn); + EXPECT_EQ(8, (int)catalog::Catalog::GetInstance() ->GetDatabaseObject(TEST_DB_NAME, txn) ->GetTableObjects() .size()); @@ -233,9 +235,8 @@ TEST_F(DropTests, DroppingIndexByName) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - + // create database catalog->CreateDatabase(TEST_DB_NAME, txn); - auto db = catalog->GetDatabaseWithName(TEST_DB_NAME, txn); // Insert a table first auto id_column = catalog::Column( type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER), @@ -250,18 +251,20 @@ TEST_F(DropTests, DroppingIndexByName) { txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_NAME, "department_table_01", + catalog->CreateTable(TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table_01", std::move(table_schema), txn); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - auto source_table = db->GetTableWithName("department_table_01"); + auto source_table = catalog->GetTableWithName( + TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table_01", txn); 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, "department_table_01", source_col_ids, - index_name1, false, IndexType::BWTREE, txn); + catalog->CreateIndex(TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table_01", + source_col_ids, index_name1, false, IndexType::BWTREE, + txn); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); @@ -273,21 +276,27 @@ TEST_F(DropTests, DroppingIndexByName) { auto pg_index = catalog::Catalog::GetInstance() ->GetSystemCatalogs(database_object->GetDatabaseOid()) ->GetIndexCatalog(); - EXPECT_NE(nullptr, pg_index); + auto index_object = + pg_index->GetIndexObject(index_name1, DEFUALT_SCHEMA_NAME, txn); + 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(TEST_DB_NAME, index_name1, txn); - EXPECT_EQ(pg_index->GetIndexObject(index_name1, txn), nullptr); + catalog->DropIndex(database_object->GetDatabaseOid(), + index_object->GetIndexOid(), txn); + EXPECT_EQ(pg_index->GetIndexObject(index_name1, DEFUALT_SCHEMA_NAME, txn), + 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(index_name1, txn), nullptr); + EXPECT_EQ(pg_index->GetIndexObject(index_name1, DEFUALT_SCHEMA_NAME, txn), + nullptr); // Now dropping the table - catalog->DropTable(TEST_DB_NAME, "department_table_01", txn); + catalog->DropTable(TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table_01", + txn); txn_manager.CommitTransaction(txn); // free the database just created diff --git a/test/executor/insert_test.cpp b/test/executor/insert_test.cpp index 5c322458e6b..4499eb6f53e 100644 --- a/test/executor/insert_test.cpp +++ b/test/executor/insert_test.cpp @@ -17,8 +17,8 @@ #include "catalog/catalog.h" #include "common/harness.h" #include "concurrency/transaction_manager_factory.h" -#include "executor/insert_executor.h" #include "executor/executor_context.h" +#include "executor/insert_executor.h" #include "expression/constant_value_expression.h" #include "parser/insert_statement.h" #include "planner/insert_plan.h" @@ -52,11 +52,12 @@ TEST_F(InsertTests, InsertRecord) { txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog::Catalog::GetInstance()->CreateTable(DEFAULT_DB_NAME, "TEST_TABLE", - std::move(table_schema), txn); + catalog::Catalog::GetInstance()->CreateTable( + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "TEST_TABLE", + std::move(table_schema), txn); auto table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, "TEST_TABLE", txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "TEST_TABLE", txn); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); @@ -83,13 +84,15 @@ TEST_F(InsertTests, InsertRecord) { insert_node->insert_values.push_back( std::vector>()); - auto& values_ptr = insert_node->insert_values[0]; + auto &values_ptr = insert_node->insert_values[0]; values_ptr.push_back(std::unique_ptr( - new expression::ConstantValueExpression(type::ValueFactory::GetIntegerValue(70)))); + new expression::ConstantValueExpression( + type::ValueFactory::GetIntegerValue(70)))); values_ptr.push_back(std::unique_ptr( - new expression::ConstantValueExpression(type::ValueFactory::GetVarcharValue("Hello")))); + new expression::ConstantValueExpression( + type::ValueFactory::GetVarcharValue("Hello")))); insert_node->select.reset(new parser::SelectStatement()); @@ -113,16 +116,19 @@ TEST_F(InsertTests, InsertRecord) { insert_node->insert_values.push_back( std::vector>()); - auto& values_ptr2 = insert_node->insert_values[1]; + auto &values_ptr2 = insert_node->insert_values[1]; values_ptr2.push_back(std::unique_ptr( - new expression::ConstantValueExpression(type::ValueFactory::GetIntegerValue(100)))); + new expression::ConstantValueExpression( + type::ValueFactory::GetIntegerValue(100)))); values_ptr2.push_back(std::unique_ptr( - new expression::ConstantValueExpression(type::ValueFactory::GetVarcharValue("Hello")))); + new expression::ConstantValueExpression( + type::ValueFactory::GetVarcharValue("Hello")))); - insert_node->insert_values[0].at(0).reset(new expression::ConstantValueExpression( - type::ValueFactory::GetIntegerValue(90))); + insert_node->insert_values[0].at(0).reset( + new expression::ConstantValueExpression( + type::ValueFactory::GetIntegerValue(90))); planner::InsertPlan node3(table, &insert_node->columns, &insert_node->insert_values); executor::InsertExecutor executor3(&node3, context.get()); diff --git a/test/executor/update_test.cpp b/test/executor/update_test.cpp index 8d3b1305cbd..f8f3c12d0a2 100644 --- a/test/executor/update_test.cpp +++ b/test/executor/update_test.cpp @@ -176,16 +176,17 @@ TEST_F(UpdateTests, UpdatingOld) { new catalog::Schema({id_column, manager_id_column, name_column})); std::unique_ptr context( new executor::ExecutorContext(txn)); - planner::CreatePlan node("department_table", DEFAULT_DB_NAME, - std::move(table_schema), CreateType::TABLE); + planner::CreatePlan node("department_table", DEFUALT_SCHEMA_NAME, + DEFAULT_DB_NAME, std::move(table_schema), + CreateType::TABLE); executor::CreateExecutor create_executor(&node, context.get()); create_executor.Init(); create_executor.Execute(); LOG_INFO("Table created!"); - storage::DataTable *table = - catalog->GetTableWithName(DEFAULT_DB_NAME, "department_table", txn); + storage::DataTable *table = catalog->GetTableWithName( + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", txn); txn_manager.CommitTransaction(txn); // Inserting a tuple end-to-end diff --git a/test/include/catalog/testing_constraints_util.h b/test/include/catalog/testing_constraints_util.h index d3e0669a8d5..30a9b658223 100644 --- a/test/include/catalog/testing_constraints_util.h +++ b/test/include/catalog/testing_constraints_util.h @@ -10,43 +10,42 @@ // //===----------------------------------------------------------------------===// - #pragma once -#include -#include #include #include +#include +#include #include "common/harness.h" #include "executor/mock_executor.h" -#include "common/internal_types.h" #include "catalog/catalog.h" #include "catalog/database_catalog.h" #include "catalog/schema.h" -#include "type/value.h" -#include "type/value_factory.h" #include "common/exception.h" +#include "common/internal_types.h" #include "concurrency/transaction_context.h" #include "concurrency/transaction_manager_factory.h" #include "executor/abstract_executor.h" -#include "executor/logical_tile.h" -#include "storage/tile_group.h" -#include "storage/tile_group_factory.h" -#include "storage/tuple.h" -#include "storage/data_table.h" -#include "storage/table_factory.h" -#include "index/index_factory.h" -#include "planner/delete_plan.h" -#include "planner/insert_plan.h" -#include "planner/project_info.h" -#include "executor/executor_context.h" #include "executor/delete_executor.h" +#include "executor/executor_context.h" #include "executor/insert_executor.h" +#include "executor/logical_tile.h" #include "executor/seq_scan_executor.h" #include "executor/update_executor.h" #include "expression/expression_util.h" +#include "index/index_factory.h" +#include "planner/delete_plan.h" +#include "planner/insert_plan.h" +#include "planner/project_info.h" +#include "storage/data_table.h" +#include "storage/table_factory.h" +#include "storage/tile_group.h" +#include "storage/tile_group_factory.h" +#include "storage/tuple.h" +#include "type/value.h" +#include "type/value_factory.h" using ::testing::IsNull; using ::testing::NotNull; @@ -61,7 +60,7 @@ namespace peloton { namespace catalog { class Column; class Manager; -} +} // namespace catalog namespace concurrency { class Transaction; @@ -70,14 +69,14 @@ class Transaction; namespace executor { class AbstractExecutor; class LogicalTile; -} +} // namespace executor namespace storage { class Backend; class TileGroup; class DataTable; class Tuple; -} +} // namespace storage namespace planner { class ProjectInfo; @@ -92,18 +91,17 @@ namespace test { class TestingConstraintsUtil { public: - /** @brief Creates a basic table with allocated and populated tuples */ static storage::DataTable *CreateAndPopulateTable( std::vector> constraints, std::vector multi_constraints) { const int tuple_count = TESTS_TUPLES_PER_TILEGROUP; - storage::DataTable *table = TestingConstraintsUtil::CreateTable( - constraints, multi_constraints); + storage::DataTable *table = + TestingConstraintsUtil::CreateTable(constraints, multi_constraints); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); - TestingConstraintsUtil::PopulateTable(txn, table, - tuple_count * DEFAULT_TILEGROUP_COUNT); + TestingConstraintsUtil::PopulateTable( + txn, table, tuple_count * DEFAULT_TILEGROUP_COUNT); txn_manager.CommitTransaction(txn); return table; @@ -114,7 +112,6 @@ class TestingConstraintsUtil { std::vector> constraints, UNUSED_ATTRIBUTE std::vector multi_constraints, UNUSED_ATTRIBUTE bool indexes = true) { - // Create the database auto catalog = catalog::Catalog::GetInstance(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); @@ -126,83 +123,84 @@ class TestingConstraintsUtil { // are going to need for this test std::vector columns; for (int i = 0; i < CONSTRAINTS_NUM_COLS; i++) { - columns.push_back(TestingConstraintsUtil::GetColumnInfo(i, constraints[i])); + columns.push_back( + TestingConstraintsUtil::GetColumnInfo(i, constraints[i])); } std::unique_ptr table_schema(new catalog::Schema(columns)); std::string table_name(CONSTRAINTS_TEST_TABLE); // Create table. txn = txn_manager.BeginTransaction(); - auto result = catalog->CreateTable(DEFAULT_DB_NAME, - table_name, - std::move(table_schema), - txn, - false); + auto result = + catalog->CreateTable(DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, table_name, + std::move(table_schema), txn, false); txn_manager.CommitTransaction(txn); EXPECT_EQ(ResultType::SUCCESS, result); txn = txn_manager.BeginTransaction(); - auto db = catalog->GetDatabaseWithName(DEFAULT_DB_NAME, txn); - storage::DataTable *table = db->GetTableWithName(table_name); + auto table = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, + table_name, txn); txn_manager.CommitTransaction(txn); EXPECT_NE(nullptr, table); -// if (indexes == true) { -// // PRIMARY INDEX -// std::vector key_attrs; -// -// auto tuple_schema = table->GetSchema(); -// catalog::Schema *key_schema; -// index::IndexMetadata *index_metadata; -// bool unique; -// -// key_attrs = {0}; -// key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs); -// key_schema->SetIndexedColumns(key_attrs); -// -// unique = true; -// -// index_metadata = new index::IndexMetadata( -// "primary_btree_index", 123, table->GetOid(), table->GetDatabaseOid(), -// IndexType::BWTREE, IndexConstraintType::PRIMARY_KEY, tuple_schema, -// key_schema, key_attrs, unique); -// -// std::shared_ptr pkey_index( -// index::IndexFactory::GetIndex(index_metadata)); -// -// table->AddIndex(pkey_index); -// -// // SECONDARY INDEX -// key_attrs = {0, 1}; -// key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs); -// key_schema->SetIndexedColumns(key_attrs); -// -// unique = false; -// index_metadata = new index::IndexMetadata( -// "secondary_btree_index", 124, table->GetOid(), -// table->GetDatabaseOid(), IndexType::BWTREE, -// IndexConstraintType::DEFAULT, tuple_schema, key_schema, key_attrs, -// unique); -// std::shared_ptr sec_index( -// index::IndexFactory::GetIndex(index_metadata)); -// -// table->AddIndex(sec_index); -// -// // SECONDARY INDEX - UNIQUE INDEX -// key_attrs = {3}; -// key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs); -// key_schema->SetIndexedColumns(key_attrs); -// -// unique = false; -// index_metadata = new index::IndexMetadata( -// "unique_btree_index", 125, table->GetOid(), table->GetDatabaseOid(), -// IndexType::BWTREE, IndexConstraintType::UNIQUE, tuple_schema, -// key_schema, key_attrs, unique); -// std::shared_ptr unique_index( -// index::IndexFactory::GetIndex(index_metadata)); -// -// table->AddIndex(unique_index); -// } + // if (indexes == true) { + // // PRIMARY INDEX + // std::vector key_attrs; + // + // auto tuple_schema = table->GetSchema(); + // catalog::Schema *key_schema; + // index::IndexMetadata *index_metadata; + // bool unique; + // + // key_attrs = {0}; + // key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs); + // key_schema->SetIndexedColumns(key_attrs); + // + // unique = true; + // + // index_metadata = new index::IndexMetadata( + // "primary_btree_index", 123, table->GetOid(), + // table->GetDatabaseOid(), IndexType::BWTREE, + // IndexConstraintType::PRIMARY_KEY, tuple_schema, key_schema, + // key_attrs, unique); + // + // std::shared_ptr pkey_index( + // index::IndexFactory::GetIndex(index_metadata)); + // + // table->AddIndex(pkey_index); + // + // // SECONDARY INDEX + // key_attrs = {0, 1}; + // key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs); + // key_schema->SetIndexedColumns(key_attrs); + // + // unique = false; + // index_metadata = new index::IndexMetadata( + // "secondary_btree_index", 124, table->GetOid(), + // table->GetDatabaseOid(), IndexType::BWTREE, + // IndexConstraintType::DEFAULT, tuple_schema, key_schema, + // key_attrs, unique); + // std::shared_ptr sec_index( + // index::IndexFactory::GetIndex(index_metadata)); + // + // table->AddIndex(sec_index); + // + // // SECONDARY INDEX - UNIQUE INDEX + // key_attrs = {3}; + // key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs); + // key_schema->SetIndexedColumns(key_attrs); + // + // unique = false; + // index_metadata = new index::IndexMetadata( + // "unique_btree_index", 125, table->GetOid(), + // table->GetDatabaseOid(), IndexType::BWTREE, + // IndexConstraintType::UNIQUE, tuple_schema, key_schema, + // key_attrs, unique); + // std::shared_ptr unique_index( + // index::IndexFactory::GetIndex(index_metadata)); + // + // table->AddIndex(unique_index); + // } return table; }; @@ -247,15 +245,15 @@ class TestingConstraintsUtil { }; /** @brief Delete all tuples from a table */ -// static bool ExecuteTruncate(concurrency::TransactionContext *transaction, -// storage::DataTable *table) { -// std::unique_ptr context( -// new executor::ExecutorContext(transaction)); -// planner::DeletePlan node(table, true); -// executor::DeleteExecutor executor(&node, context.get()); -// executor.Init(); -// return executor.Execute(); -// }; + // static bool ExecuteTruncate(concurrency::TransactionContext *transaction, + // storage::DataTable *table) { + // std::unique_ptr context( + // new executor::ExecutorContext(transaction)); + // planner::DeletePlan node(table, true); + // executor::DeleteExecutor executor(&node, context.get()); + // executor.Init(); + // return executor.Execute(); + // }; /** @brief Insert a tuple with 1 columns' value specified */ static bool ExecuteMultiInsert(concurrency::TransactionContext *transaction, @@ -311,11 +309,11 @@ class TestingConstraintsUtil { storage::DataTable *table, const type::Value &col1, const type::Value &col2, const type::Value &col3) { std::unique_ptr context( - new executor::ExecutorContext(transaction)); + new executor::ExecutorContext(transaction)); // Make tuple std::unique_ptr tuple( - new storage::Tuple(table->GetSchema(), true)); + new storage::Tuple(table->GetSchema(), true)); auto testing_pool = TestingHarness::GetInstance().GetTestingPool(); tuple->SetValue(0, col1, testing_pool); @@ -330,8 +328,6 @@ class TestingConstraintsUtil { return executor.Execute(); }; - - static void PopulateTable(concurrency::TransactionContext *transaction, storage::DataTable *table, int num_rows) { // Ensure that the tile group is as expected. @@ -356,49 +352,41 @@ class TestingConstraintsUtil { auto col4 = type::ValueFactory::GetVarcharValue( std::to_string(PopulatedValue(populate_value, 3))); - TestingConstraintsUtil::ExecuteInsert(transaction, table, col1, col2, col3, - col4); + TestingConstraintsUtil::ExecuteInsert(transaction, table, col1, col2, + col3, col4); } }; - static catalog::Column GetColumnInfo(int index, - std::vector constraints) { + static catalog::Column GetColumnInfo( + int index, std::vector constraints) { catalog::Column column; switch (index) { // COL_A case 0: { - column = catalog::Column( - type::TypeId::INTEGER, - type::Type::GetTypeSize(type::TypeId::INTEGER), - "col_a", - true); + column = catalog::Column(type::TypeId::INTEGER, + type::Type::GetTypeSize(type::TypeId::INTEGER), + "col_a", true); break; } // COL_B case 1: { - column = catalog::Column( - type::TypeId::INTEGER, - type::Type::GetTypeSize(type::TypeId::INTEGER), - "col_b", - true); + column = catalog::Column(type::TypeId::INTEGER, + type::Type::GetTypeSize(type::TypeId::INTEGER), + "col_b", true); break; } // COL_C case 2: { - column = catalog::Column( - type::TypeId::DECIMAL, - type::Type::GetTypeSize(type::TypeId::DECIMAL), - "col_c", - true); + column = catalog::Column(type::TypeId::DECIMAL, + type::Type::GetTypeSize(type::TypeId::DECIMAL), + "col_c", true); break; } // COL_D case 3: { - column = catalog::Column( - type::TypeId::VARCHAR, - 25, // Column length. - "col_d", - false); + column = catalog::Column(type::TypeId::VARCHAR, + 25, // Column length. + "col_d", false); break; } default: { @@ -430,4 +418,4 @@ class TestingConstraintsUtil { }; } // namespace test -} // namespace peloton \ No newline at end of file +} // namespace peloton diff --git a/test/optimizer/old_optimizer_test.cpp b/test/optimizer/old_optimizer_test.cpp index 052fd5b6b64..1069ab87909 100644 --- a/test/optimizer/old_optimizer_test.cpp +++ b/test/optimizer/old_optimizer_test.cpp @@ -171,7 +171,7 @@ TEST_F(OldOptimizerTests, UpdateDelWithIndexScanTest) { txn = txn_manager.BeginTransaction(); auto target_table_ = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, "department_table", txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", txn); // Expected 1 , Primary key index + created index EXPECT_EQ(target_table_->GetIndexCount(), 2); txn_manager.CommitTransaction(txn); diff --git a/test/optimizer/optimizer_test.cpp b/test/optimizer/optimizer_test.cpp index 398a2ccf6a1..11971114f69 100644 --- a/test/optimizer/optimizer_test.cpp +++ b/test/optimizer/optimizer_test.cpp @@ -21,9 +21,11 @@ #include "executor/insert_executor.h" #include "executor/plan_executor.h" #include "expression/tuple_value_expression.h" +#include "optimizer/mock_task.h" #include "optimizer/operators.h" #include "optimizer/optimizer.h" #include "optimizer/rule_impls.h" +#include "parser/mock_sql_statement.h" #include "parser/postgresparser.h" #include "planner/abstract_join_plan.h" #include "planner/create_plan.h" @@ -117,7 +119,13 @@ TEST_F(OptimizerTests, HashJoinTest) { LOG_INFO("Table Created"); traffic_cop.CommitQueryHelper(); + // NOTE: everytime we create a database, there will be 8 catalog tables inside txn = txn_manager.BeginTransaction(); + EXPECT_EQ(catalog::Catalog::GetInstance() + ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) + ->GetTableCount(), + 9); + traffic_cop.SetTcopTxnState(txn); LOG_INFO("Creating table"); LOG_INFO("Query: CREATE TABLE table_b(bid INT PRIMARY KEY,value INT);"); @@ -148,6 +156,11 @@ TEST_F(OptimizerTests, HashJoinTest) { traffic_cop.CommitQueryHelper(); txn = txn_manager.BeginTransaction(); + EXPECT_EQ(catalog::Catalog::GetInstance() + ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) + ->GetTableCount(), + 10); + // Inserting a tuple to table_a traffic_cop.SetTcopTxnState(txn); LOG_INFO("Inserting a tuple..."); diff --git a/test/optimizer/selectivity_test.cpp b/test/optimizer/selectivity_test.cpp index eeaf280ec51..0f5e4a9ab8c 100644 --- a/test/optimizer/selectivity_test.cpp +++ b/test/optimizer/selectivity_test.cpp @@ -72,7 +72,8 @@ 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, TEST_TABLE_NAME, txn); + auto table = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, + TEST_TABLE_NAME, txn); txn_manager.CommitTransaction(txn); oid_t db_id = database->GetOid(); oid_t table_id = table->GetOid(); @@ -180,7 +181,8 @@ 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, TEST_TABLE_NAME, txn); + auto table = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, + TEST_TABLE_NAME, txn); txn_manager.CommitTransaction(txn); oid_t db_id = database->GetOid(); oid_t table_id = table->GetOid(); diff --git a/test/optimizer/table_stats_collector_test.cpp b/test/optimizer/table_stats_collector_test.cpp index 488e99ab9b5..7cafebe3e9e 100644 --- a/test/optimizer/table_stats_collector_test.cpp +++ b/test/optimizer/table_stats_collector_test.cpp @@ -12,15 +12,15 @@ #include +#include "catalog/catalog.h" +#include "catalog/column.h" +#include "catalog/schema.h" #include "common/harness.h" #include "common/logger.h" -#include "catalog/schema.h" -#include "catalog/column.h" -#include "catalog/catalog.h" #include "concurrency/transaction_manager_factory.h" #include "executor/testing_executor_util.h" -#include "optimizer/stats/table_stats_collector.h" #include "optimizer/stats/column_stats_collector.h" +#include "optimizer/stats/table_stats_collector.h" #include "sql/testing_sql_util.h" #include "storage/data_table.h" #include "storage/tuple.h" @@ -46,7 +46,7 @@ TEST_F(TableStatsCollectorTests, BasicTests) { TEST_F(TableStatsCollectorTests, SingleColumnTableTest) { // Boostrap database auto catalog = catalog::Catalog::GetInstance(); - auto& txn_manager = concurrency::TransactionManagerFactory::GetInstance(); + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); catalog->CreateDatabase(DEFAULT_DB_NAME, txn); txn_manager.CommitTransaction(txn); @@ -60,7 +60,8 @@ TEST_F(TableStatsCollectorTests, SingleColumnTableTest) { } txn = txn_manager.BeginTransaction(); - auto table = catalog->GetTableWithName(DEFAULT_DB_NAME, "test", txn); + auto table = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, + "test", txn); txn_manager.CommitTransaction(txn); TableStatsCollector stats{table}; stats.CollectColumnStats(); @@ -88,7 +89,7 @@ TEST_F(TableStatsCollectorTests, SingleColumnTableTest) { TEST_F(TableStatsCollectorTests, MultiColumnTableTest) { // Boostrap database auto catalog = catalog::Catalog::GetInstance(); - auto& txn_manager = concurrency::TransactionManagerFactory::GetInstance(); + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); catalog->CreateDatabase(DEFAULT_DB_NAME, txn); txn_manager.CommitTransaction(txn); @@ -110,7 +111,8 @@ TEST_F(TableStatsCollectorTests, MultiColumnTableTest) { } txn = txn_manager.BeginTransaction(); - auto table = catalog->GetTableWithName(DEFAULT_DB_NAME, "test", txn); + auto table = catalog->GetTableWithName(DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, + "test", txn); txn_manager.CommitTransaction(txn); TableStatsCollector stats{table}; stats.CollectColumnStats(); @@ -119,20 +121,20 @@ TEST_F(TableStatsCollectorTests, MultiColumnTableTest) { EXPECT_EQ(stats.GetActiveTupleCount(), nrow); // Varchar stats - ColumnStatsCollector* b_stats = stats.GetColumnStats(1); + ColumnStatsCollector *b_stats = stats.GetColumnStats(1); EXPECT_EQ(b_stats->GetFracNull(), 0); EXPECT_EQ(b_stats->GetCardinality(), 2); EXPECT_EQ((b_stats->GetHistogramBound()).size(), 0); // varchar has no histogram dist // Double stats - ColumnStatsCollector* c_stats = stats.GetColumnStats(2); + ColumnStatsCollector *c_stats = stats.GetColumnStats(2); EXPECT_EQ(c_stats->GetFracNull(), 0); EXPECT_EQ(c_stats->GetCardinality(), 1); EXPECT_EQ(c_stats->GetHistogramBound().size() + 1, 1); // Timestamp stats - ColumnStatsCollector* d_stats = stats.GetColumnStats(3); + ColumnStatsCollector *d_stats = stats.GetColumnStats(3); EXPECT_EQ(d_stats->GetFracNull(), 0); EXPECT_EQ(d_stats->GetCardinality(), 2); EXPECT_EQ(d_stats->GetHistogramBound().size() + 1, 2); diff --git a/test/optimizer/tuple_samples_storage_test.cpp b/test/optimizer/tuple_samples_storage_test.cpp index 36e6a785646..a5dd4524a4d 100644 --- a/test/optimizer/tuple_samples_storage_test.cpp +++ b/test/optimizer/tuple_samples_storage_test.cpp @@ -50,7 +50,8 @@ TEST_F(TupleSamplesStorageTests, SamplesDBTest) { txn_manager.CommitTransaction(txn); EXPECT_TRUE(samples_db != nullptr); EXPECT_EQ(samples_db->GetDBName(), SAMPLES_DB_NAME); - EXPECT_EQ(samples_db->GetTableCount(), 0); + // NOTE: everytime we create a database, there will be 8 catalog tables inside + EXPECT_EQ(samples_db->GetTableCount(), 8); } TEST_F(TupleSamplesStorageTests, AddSamplesTableTest) { @@ -83,11 +84,10 @@ TEST_F(TupleSamplesStorageTests, AddSamplesTableTest) { tuple_samples_storage->GenerateSamplesTableName( data_table->GetDatabaseOid(), data_table->GetOid()); txn = txn_manager.BeginTransaction(); - storage::Database *samples_db = - catalog->GetDatabaseWithName(SAMPLES_DB_NAME, txn); + storage::DataTable *samples_table = catalog->GetTableWithName( + SAMPLES_DB_NAME, DEFUALT_SCHEMA_NAME, samples_table_name, txn); txn_manager.CommitTransaction(txn); - storage::DataTable *samples_table = - samples_db->GetTableWithName(samples_table_name); + EXPECT_TRUE(samples_table != nullptr); EXPECT_EQ(samples_table->GetTupleCount(), sampled_count); tuple_samples_storage->DeleteSamplesTable(data_table->GetDatabaseOid(), diff --git a/test/parser/parser_test.cpp b/test/parser/parser_test.cpp index 23fd1404182..93abf1c497c 100644 --- a/test/parser/parser_test.cpp +++ b/test/parser/parser_test.cpp @@ -154,7 +154,8 @@ TEST_F(ParserTests, GrammarTest) { TEST_F(ParserTests, SelectParserTest) { std::string query = - "SELECT customer_id, SUM(order_value) FROM order_db.customers JOIN " + "SELECT customer_id, SUM(order_value) FROM order_db.public.customers " + "JOIN " "orders ON customers.id = orders.customer_id GROUP BY customer_id ORDER " "BY SUM(order_value) DESC LIMIT 5;"; @@ -192,6 +193,7 @@ TEST_F(ParserTests, SelectParserTest) { EXPECT_NOTNULL(join); EXPECT_STREQ(join->left->GetTableName().c_str(), "customers"); EXPECT_STREQ(join->right->GetTableName().c_str(), "orders"); + EXPECT_STREQ(join->left->GetSchemaName().c_str(), "public"); EXPECT_STREQ(join->left->GetDatabaseName().c_str(), "order_db"); // Group By @@ -489,4 +491,4 @@ TEST_F(ParserTests, CopyTest) { } } // namespace test -} // namespace peloton \ No newline at end of file +} // namespace peloton diff --git a/test/planner/plan_util_test.cpp b/test/planner/plan_util_test.cpp index b8afbb7c7f5..f623b293051 100644 --- a/test/planner/plan_util_test.cpp +++ b/test/planner/plan_util_test.cpp @@ -40,7 +40,6 @@ TEST_F(PlanUtilTests, GetAffectedIndexesTest) { auto txn = txn_manager.BeginTransaction(); catalog->CreateDatabase(TEST_DB_NAME, txn); - auto db = catalog->GetDatabaseWithName(TEST_DB_NAME, txn); // Insert a table first auto id_column = catalog::Column( type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER), @@ -55,26 +54,30 @@ TEST_F(PlanUtilTests, GetAffectedIndexesTest) { txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_NAME, "test_table", std::move(table_schema), - txn); + catalog->CreateTable(TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "test_table", + std::move(table_schema), txn); + auto source_table = catalog->GetTableWithName( + TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "test_table", txn); + EXPECT_NE(source_table, nullptr); txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - auto source_table = db->GetTableWithName("test_table"); oid_t col_id = source_table->GetSchema()->GetColumnID(id_column.column_name); std::vector source_col_ids; source_col_ids.push_back(col_id); // create index on 'id' - catalog->CreateIndex(TEST_DB_NAME, "test_table", source_col_ids, - "test_id_idx", false, IndexType::BWTREE, txn); + catalog->CreateIndex(TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "test_table", + source_col_ids, "test_id_idx", false, IndexType::BWTREE, + txn); // 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, "test_table", source_col_ids, - "test_fname_idx", false, IndexType::BWTREE, txn); + catalog->CreateIndex(TEST_DB_NAME, DEFUALT_SCHEMA_NAME, "test_table", + source_col_ids, "test_fname_idx", false, + IndexType::BWTREE, txn); txn_manager.CommitTransaction(txn); // dummy txn to get the catalog_cache object @@ -87,7 +90,9 @@ TEST_F(PlanUtilTests, GetAffectedIndexesTest) { // And two indexes on following columns: // 1) id // 2) id and first_name - auto table_object = db_object->GetTableObject("test_table"); + auto table_object = + db_object->GetTableObject("test_table", DEFUALT_SCHEMA_NAME); + EXPECT_NE(table_object, nullptr); oid_t id_idx_oid = table_object->GetIndexObject("test_id_idx")->GetIndexOid(); oid_t fname_idx_oid = table_object->GetIndexObject("test_fname_idx")->GetIndexOid(); diff --git a/test/planner/planner_test.cpp b/test/planner/planner_test.cpp index f556eefccc7..7b263bccd79 100644 --- a/test/planner/planner_test.cpp +++ b/test/planner/planner_test.cpp @@ -15,17 +15,17 @@ #include "concurrency/transaction_manager_factory.h" #include "executor/plan_executor.h" #include "expression/comparison_expression.h" +#include "expression/expression_util.h" #include "expression/operator_expression.h" #include "expression/parameter_value_expression.h" #include "expression/tuple_value_expression.h" -#include "expression/expression_util.h" -#include "parser/statements.h" #include "parser/postgresparser.h" +#include "parser/statements.h" +#include "planner/attribute_info.h" #include "planner/create_plan.h" #include "planner/delete_plan.h" #include "planner/drop_plan.h" -#include "planner/attribute_info.h" #include "planner/plan_util.h" #include "planner/project_info.h" #include "planner/seq_scan_plan.h" @@ -41,33 +41,33 @@ namespace test { class PlannerTest : public PelotonTest {}; TEST_F(PlannerTest, CreateDatabasePlanTest) { - auto& peloton_parser = parser::PostgresParser::GetInstance(); - auto parse_tree_list = peloton_parser.BuildParseTree("CREATE DATABASE pelotondb;"); + auto &peloton_parser = parser::PostgresParser::GetInstance(); + auto parse_tree_list = + peloton_parser.BuildParseTree("CREATE DATABASE pelotondb;"); // There should be only one statement in the statement list EXPECT_EQ(1, parse_tree_list->GetNumStatements()); auto &parse_tree = parse_tree_list->GetStatements().at(0); std::unique_ptr create_DB_plan( - new planner::CreatePlan((parser::CreateStatement *)parse_tree.get()) - ); + new planner::CreatePlan((parser::CreateStatement *)parse_tree.get())); EXPECT_STREQ("pelotondb", create_DB_plan->GetDatabaseName().c_str()); EXPECT_EQ(CreateType::DB, create_DB_plan->GetCreateType()); } TEST_F(PlannerTest, DropDatabasePlanTest) { - auto& peloton_parser = parser::PostgresParser::GetInstance(); - auto parse_tree_list = peloton_parser.BuildParseTree("DROP DATABASE pelotondb;"); + auto &peloton_parser = parser::PostgresParser::GetInstance(); + auto parse_tree_list = + peloton_parser.BuildParseTree("DROP DATABASE pelotondb;"); // There should be only one statement in the statement list EXPECT_EQ(1, parse_tree_list->GetNumStatements()); auto &parse_tree = parse_tree_list->GetStatements().at(0); std::unique_ptr drop_DB_plan( - new planner::DropPlan((parser::DropStatement *)parse_tree.get()) - ); + new planner::DropPlan((parser::DropStatement *)parse_tree.get())); EXPECT_STREQ("pelotondb", drop_DB_plan->GetDatabaseName().c_str()); EXPECT_EQ(DropType::DB, drop_DB_plan->GetDropType()); } - + TEST_F(PlannerTest, DeletePlanTestParameter) { // Bootstrapping peloton auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); @@ -85,7 +85,8 @@ TEST_F(PlannerTest, DeletePlanTestParameter) { std::unique_ptr table_schema( new catalog::Schema({id_column, name_column})); catalog::Catalog::GetInstance()->CreateTable( - DEFAULT_DB_NAME, "department_table", std::move(table_schema), txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", + std::move(table_schema), txn); txn_manager.CommitTransaction(txn); // DELETE FROM department_table WHERE id = $0 @@ -99,7 +100,7 @@ TEST_F(PlannerTest, DeletePlanTestParameter) { ExpressionType::COMPARE_EQUAL, tuple_expr, parameter_expr); auto target_table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, "department_table", txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", txn); // Create delete plan std::unique_ptr delete_plan( @@ -148,7 +149,8 @@ TEST_F(PlannerTest, UpdatePlanTestParameter) { std::unique_ptr table_schema( new catalog::Schema({id_column, name_column})); catalog::Catalog::GetInstance()->CreateTable( - DEFAULT_DB_NAME, "department_table", std::move(table_schema), txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", + std::move(table_schema), txn); txn_manager.CommitTransaction(txn); // UPDATE department_table SET name = $0 WHERE id = $1 @@ -157,7 +159,7 @@ 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, table_name, txn); + database_name, DEFUALT_SCHEMA_NAME, table_name, txn); auto schema = target_table->GetSchema(); TargetList tlist; @@ -244,7 +246,8 @@ 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, "department_table", std::move(table_schema), txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", + std::move(table_schema), txn); if (ret != ResultType::SUCCESS) LOG_TRACE("create table failed"); txn_manager.CommitTransaction(txn); @@ -255,7 +258,7 @@ TEST_F(PlannerTest, InsertPlanTestParameter) { std::string name = "department_table"; auto table_ref = new parser::TableRef(TableReferenceType::NAME); - table_ref->table_info_ .reset(new parser::TableInfo()); + table_ref->table_info_.reset(new parser::TableInfo()); table_ref->table_info_->table_name = name; insert_statement->table_ref_.reset(table_ref); @@ -264,27 +267,30 @@ TEST_F(PlannerTest, InsertPlanTestParameter) { // at this point insert_statement->insert_values.push_back( std::vector>()); - auto& parameter_exprs = insert_statement->insert_values[0]; + auto ¶meter_exprs = insert_statement->insert_values[0]; auto parameter_expr_1 = new expression::ParameterValueExpression(0); auto parameter_expr_2 = new expression::ParameterValueExpression(1); - parameter_exprs.push_back(std::unique_ptr(parameter_expr_1)); - parameter_exprs.push_back(std::unique_ptr(parameter_expr_2)); + parameter_exprs.push_back( + std::unique_ptr(parameter_expr_1)); + parameter_exprs.push_back( + std::unique_ptr(parameter_expr_2)); auto target_table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, "department_table", txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", txn); - std::unique_ptr insert_plan(new planner::InsertPlan( - target_table, &insert_statement->columns, - &insert_statement->insert_values)); + std::unique_ptr insert_plan( + new planner::InsertPlan(target_table, &insert_statement->columns, + &insert_statement->insert_values)); LOG_INFO("Plan created:\n%s", insert_plan->GetInfo().c_str()); // VALUES(1, "CS") LOG_INFO("Binding values"); std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(1).Copy()); - values.push_back(type::ValueFactory::GetVarcharValue( - (std::string) "CS", - TestingHarness::GetInstance().GetTestingPool()).Copy()); + values.push_back( + type::ValueFactory::GetVarcharValue( + (std::string) "CS", TestingHarness::GetInstance().GetTestingPool()) + .Copy()); LOG_INFO("Value 1: %s", values.at(0).GetInfo().c_str()); LOG_INFO("Value 2: %s", values.at(1).GetInfo().c_str()); // bind values to parameters in plan @@ -314,7 +320,8 @@ TEST_F(PlannerTest, InsertPlanTestParameterColumns) { std::unique_ptr table_schema( new catalog::Schema({id_column, name_column})); catalog::Catalog::GetInstance()->CreateTable( - DEFAULT_DB_NAME, "department_table", std::move(table_schema), txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", + std::move(table_schema), txn); txn_manager.CommitTransaction(txn); // INSERT INTO department_table VALUES (1, $1) @@ -340,24 +347,27 @@ TEST_F(PlannerTest, InsertPlanTestParameterColumns) { auto parameter_expr_2 = new expression::ParameterValueExpression(1); insert_statement->insert_values.push_back( std::vector>()); - auto& exprs = insert_statement->insert_values[0]; - exprs.push_back(std::unique_ptr(constant_expr_1)); - exprs.push_back(std::unique_ptr(parameter_expr_2)); + auto &exprs = insert_statement->insert_values[0]; + exprs.push_back( + std::unique_ptr(constant_expr_1)); + exprs.push_back( + std::unique_ptr(parameter_expr_2)); auto target_table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, "department_table", txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", txn); - std::unique_ptr insert_plan(new planner::InsertPlan( - target_table, &insert_statement->columns, - &insert_statement->insert_values)); + std::unique_ptr insert_plan( + new planner::InsertPlan(target_table, &insert_statement->columns, + &insert_statement->insert_values)); LOG_INFO("Plan created:\n%s", insert_plan->GetInfo().c_str()); // VALUES(1, "CS") LOG_INFO("Binding values"); std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue( - (std::string) "CS", - TestingHarness::GetInstance().GetTestingPool()).Copy()); + values.push_back( + type::ValueFactory::GetVarcharValue( + (std::string) "CS", TestingHarness::GetInstance().GetTestingPool()) + .Copy()); LOG_INFO("Value 1: %s", values.at(0).GetInfo().c_str()); // bind values to parameters in plan insert_plan->SetParameterValues(&values); diff --git a/test/sql/analyze_sql_test.cpp b/test/sql/analyze_sql_test.cpp index ee8767e14c1..16191ec000d 100644 --- a/test/sql/analyze_sql_test.cpp +++ b/test/sql/analyze_sql_test.cpp @@ -12,15 +12,15 @@ #include -#include "sql/testing_sql_util.h" #include "catalog/catalog.h" #include "catalog/column_stats_catalog.h" -#include "concurrency/transaction_manager_factory.h" #include "common/harness.h" +#include "common/internal_types.h" +#include "concurrency/transaction_manager_factory.h" #include "executor/create_executor.h" #include "optimizer/stats/stats_storage.h" #include "planner/create_plan.h" -#include "common/internal_types.h" +#include "sql/testing_sql_util.h" namespace peloton { namespace test { @@ -73,10 +73,9 @@ TEST_F(AnalyzeSQLTests, AnalyzeSingleTableTest) { // Check stats information in catalog txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); - storage::Database *catalog_database = - catalog->GetDatabaseWithName(std::string(CATALOG_DATABASE_NAME), txn); storage::DataTable *db_column_stats_collector_table = - catalog_database->GetTableWithName(COLUMN_STATS_CATALOG_NAME); + catalog->GetTableWithName(CATALOG_DATABASE_NAME, CATALOG_SCHEMA_NAME, + COLUMN_STATS_CATALOG_NAME, txn); EXPECT_NE(db_column_stats_collector_table, nullptr); EXPECT_EQ(db_column_stats_collector_table->GetTupleCount(), 4); diff --git a/test/sql/drop_sql_test.cpp b/test/sql/drop_sql_test.cpp index 418634f8f73..64f6af5f001 100644 --- a/test/sql/drop_sql_test.cpp +++ b/test/sql/drop_sql_test.cpp @@ -40,8 +40,8 @@ TEST_F(DropSQLTests, DropTableTest) { storage::DataTable *table; txn = txn_manager.BeginTransaction(); try { - table = catalog::Catalog::GetInstance()->GetTableWithName(DEFAULT_DB_NAME, - "test", txn); + table = catalog::Catalog::GetInstance()->GetTableWithName( + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "test", txn); } catch (CatalogException &e) { table = nullptr; } @@ -76,8 +76,8 @@ TEST_F(DropSQLTests, DropTableTest) { // Check the table does not exist txn = txn_manager.BeginTransaction(); try { - table = catalog::Catalog::GetInstance()->GetTableWithName(DEFAULT_DB_NAME, - "test", txn); + table = catalog::Catalog::GetInstance()->GetTableWithName( + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "test", txn); } catch (CatalogException &e) { txn_manager.CommitTransaction(txn); table = nullptr; @@ -114,7 +114,7 @@ TEST_F(DropSQLTests, DropIndexTest) { std::shared_ptr index; txn = txn_manager.BeginTransaction(); try { - index = pg_index->GetIndexObject("idx", txn); + index = pg_index->GetIndexObject("idx", DEFUALT_SCHEMA_NAME, txn); } catch (CatalogException &e) { index = nullptr; @@ -128,7 +128,7 @@ TEST_F(DropSQLTests, DropIndexTest) { // Check if index is not in catalog txn = txn_manager.BeginTransaction(); - index = pg_index->GetIndexObject("idx", txn); + index = pg_index->GetIndexObject("idx", DEFUALT_SCHEMA_NAME, txn); EXPECT_EQ(index, nullptr); // Free the database just created diff --git a/test/sql/optimizer_sql_test.cpp b/test/sql/optimizer_sql_test.cpp index 5f8a2ceee70..a81734c529d 100644 --- a/test/sql/optimizer_sql_test.cpp +++ b/test/sql/optimizer_sql_test.cpp @@ -21,11 +21,11 @@ #include "planner/order_by_plan.h" #include "sql/testing_sql_util.h" -using std::vector; -using std::unordered_set; +using std::shared_ptr; using std::string; using std::unique_ptr; -using std::shared_ptr; +using std::unordered_set; +using std::vector; namespace peloton { namespace test { @@ -132,9 +132,10 @@ class OptimizerSQLTests : public PelotonTest { TEST_F(OptimizerSQLTests, SimpleSelectTest) { // Testing select star expression - TestUtil("SELECT * from test", {"333", "22", "1", "2", "11", "0", "3", "33", - "444", "4", "0", "555"}, - false); + TestUtil( + "SELECT * from test", + {"333", "22", "1", "2", "11", "0", "3", "33", "444", "4", "0", "555"}, + false); // Something wrong with column property. string query = "SELECT b from test order by c"; @@ -229,9 +230,10 @@ TEST_F(OptimizerSQLTests, SelectOrderByTest) { true); // Testing order by * expression - TestUtil("SELECT * from test order by a", {"1", "22", "333", "2", "11", "0", - "3", "33", "444", "4", "0", "555"}, - true); + TestUtil( + "SELECT * from test order by a", + {"1", "22", "333", "2", "11", "0", "3", "33", "444", "4", "0", "555"}, + true); } TEST_F(OptimizerSQLTests, SelectLimitTest) { @@ -330,7 +332,7 @@ TEST_F(OptimizerSQLTests, DDLSqlTest) { auto txn = txn_manager.BeginTransaction(); // using transaction to get table from catalog auto table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, "test2", txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "test2", txn); EXPECT_NE(nullptr, table); auto cols = table->GetSchema()->GetColumns(); EXPECT_EQ(3, cols.size()); @@ -352,7 +354,7 @@ TEST_F(OptimizerSQLTests, DDLSqlTest) { txn = txn_manager.BeginTransaction(); EXPECT_THROW(catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, "test2", txn), + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "test2", txn), peloton::Exception); txn_manager.CommitTransaction(txn); } @@ -611,7 +613,14 @@ TEST_F(OptimizerSQLTests, JoinTest) { "SELECT A.b, B.b FROM test1 as A, test1 as B " "WHERE A.a = B.a", { - "22", "22", "22", "22", "11", "11", "0", "0", + "22", + "22", + "22", + "22", + "11", + "11", + "0", + "0", }, false); @@ -653,8 +662,8 @@ TEST_F(OptimizerSQLTests, JoinTest) { TestUtil( "SELECT test.a, test1.a, test2.a, test3.c FROM test, test1, test2, test3 " "WHERE test.a = test2.a AND test2.a = test1.a and test.b = test3.b", - {"1", "1", "1", "0", "1", "1", "1", "555", "2", "2", "2", "333", "4", - "4", "4", "0"}, + {"1", "1", "1", "0", "1", "1", "1", "555", "2", "2", "2", "333", "4", "4", + "4", "0"}, false); } diff --git a/test/statistics/stats_test.cpp b/test/statistics/stats_test.cpp index 89ea279d2f5..a53775e67a6 100644 --- a/test/statistics/stats_test.cpp +++ b/test/statistics/stats_test.cpp @@ -136,13 +136,16 @@ 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", "department_table", - std::move(table_schema), txn); + catalog::Catalog::GetInstance()->CreateTable( + "emp_db", DEFUALT_SCHEMA_NAME, "department_table", + std::move(table_schema), txn); // Create multiple stat worker threads int num_threads = 8; - storage::Database *database = catalog->GetDatabaseWithName("emp_db", txn); - storage::DataTable *table = database->GetTableWithName("department_table"); + storage::Database *database = + catalog->GetDatabaseWithName("emp_db", txn); + storage::DataTable *table = catalog->GetTableWithName( + "emp_db", DEFUALT_SCHEMA_NAME, "department_table", txn); txn_manager.CommitTransaction(txn); LaunchParallelTest(num_threads, TransactionTest, database, table); // Wait for aggregation to finish diff --git a/test/statistics/testing_stats_util.cpp b/test/statistics/testing_stats_util.cpp index 6fbdb23c866..3811e84b5c9 100644 --- a/test/statistics/testing_stats_util.cpp +++ b/test/statistics/testing_stats_util.cpp @@ -125,7 +125,7 @@ void TestingStatsUtil::CreateTable(bool has_primary_key) { auto txn = txn_manager.BeginTransaction(); std::unique_ptr context( new executor::ExecutorContext(txn)); - planner::CreatePlan node("department_table", "emp_db", + planner::CreatePlan node("department_table", DEFUALT_SCHEMA_NAME, "emp_db", std::move(table_schema), CreateType::TABLE); executor::CreateExecutor create_executor(&node, context.get()); create_executor.Init(); @@ -137,7 +137,7 @@ std::shared_ptr TestingStatsUtil::GetInsertStmt(int id, std::string val) { std::shared_ptr statement; std::string sql = - "INSERT INTO emp_db.department_table(dept_id,dept_name) VALUES " + "INSERT INTO department_table(dept_id,dept_name) VALUES " "(" + std::to_string(id) + ",'" + val + "');"; LOG_TRACE("Query: %s", sql.c_str()); @@ -148,7 +148,7 @@ std::shared_ptr TestingStatsUtil::GetInsertStmt(int id, std::shared_ptr TestingStatsUtil::GetDeleteStmt() { std::shared_ptr statement; - std::string sql = "DELETE FROM emp_db.department_table"; + std::string sql = "DELETE FROM department_table"; LOG_INFO("Query: %s", sql.c_str()); statement.reset(new Statement("DELETE", sql)); ParseAndPlan(statement.get(), sql); @@ -158,7 +158,7 @@ std::shared_ptr TestingStatsUtil::GetDeleteStmt() { std::shared_ptr TestingStatsUtil::GetUpdateStmt() { std::shared_ptr statement; std::string sql = - "UPDATE emp_db.department_table SET dept_name = 'CS' WHERE dept_id = 1"; + "UPDATE department_table SET dept_name = 'CS' WHERE dept_id = 1"; LOG_INFO("Query: %s", sql.c_str()); statement.reset(new Statement("UPDATE", sql)); ParseAndPlan(statement.get(), sql); diff --git a/test/storage/database_test.cpp b/test/storage/database_test.cpp index e12e93c2fcd..289d0cb1ba9 100644 --- a/test/storage/database_test.cpp +++ b/test/storage/database_test.cpp @@ -62,12 +62,12 @@ TEST_F(DatabaseTests, AddDropTableTest) { int table_oid = data_table->GetOid(); database->AddTable(data_table.get()); - // NOTE: everytime we create a database, there will be 7 catalog tables inside - EXPECT_TRUE(database->GetTableCount() == 8); + // NOTE: everytime we create a database, there will be 8 catalog tables inside + EXPECT_TRUE(database->GetTableCount() == 9); database->DropTableWithOid(table_oid); - EXPECT_TRUE(database->GetTableCount() == 7); + EXPECT_TRUE(database->GetTableCount() == 8); data_table.release(); diff --git a/test/trigger/trigger_test.cpp b/test/trigger/trigger_test.cpp index 4cb13d7c556..8c3044a134d 100644 --- a/test/trigger/trigger_test.cpp +++ b/test/trigger/trigger_test.cpp @@ -56,7 +56,7 @@ class TriggerTests : public PelotonTest { new executor::ExecutorContext(txn)); // Create plans - planner::CreatePlan node(table_name, DEFAULT_DB_NAME, + planner::CreatePlan node(table_name, DEFUALT_SCHEMA_NAME, DEFAULT_DB_NAME, std::move(table_schema), CreateType::TABLE); // Create executer @@ -73,7 +73,7 @@ class TriggerTests : public PelotonTest { auto txn = txn_manager.BeginTransaction(); auto table = catalog::Catalog::GetInstance()->GetTableWithName( - DEFAULT_DB_NAME, std::string(table_name), txn); + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, std::string(table_name), txn); std::unique_ptr context( new executor::ExecutorContext(txn)); @@ -148,8 +148,8 @@ class TriggerTests : public PelotonTest { // Check the effect of creation storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName(DEFAULT_DB_NAME, - table_name, txn); + catalog::Catalog::GetInstance()->GetTableWithName( + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, table_name, txn); txn_manager.CommitTransaction(txn); EXPECT_EQ(trigger_number, target_table->GetTriggerNumber()); trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); @@ -277,8 +277,8 @@ TEST_F(TriggerTests, BeforeAndAfterRowInsertTriggers) { // Check the effect of creation storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName(DEFAULT_DB_NAME, - "accounts", txn); + catalog::Catalog::GetInstance()->GetTableWithName( + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "accounts", txn); txn_manager.CommitTransaction(txn); EXPECT_EQ(1, target_table->GetTriggerNumber()); trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); @@ -365,8 +365,8 @@ TEST_F(TriggerTests, AfterStatmentInsertTriggers) { // Check the effect of creation storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName(DEFAULT_DB_NAME, - "accounts", txn); + catalog::Catalog::GetInstance()->GetTableWithName( + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "accounts", txn); txn_manager.CommitTransaction(txn); EXPECT_EQ(1, target_table->GetTriggerNumber()); trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); @@ -470,8 +470,8 @@ TEST_F(TriggerTests, OtherTypesTriggers) { auto txn = txn_manager.BeginTransaction(); storage::DataTable *target_table = - catalog::Catalog::GetInstance()->GetTableWithName(DEFAULT_DB_NAME, - table_name, txn); + catalog::Catalog::GetInstance()->GetTableWithName( + DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, table_name, txn); txn_manager.CommitTransaction(txn); trigger::TriggerList *new_trigger_list = target_table->GetTriggerList(); From 392872484d7c6eb0ab46a4e51eccd83094f5d110 Mon Sep 17 00:00:00 2001 From: mengranwo Date: Wed, 25 Apr 2018 13:01:18 -0400 Subject: [PATCH 43/48] resolve conflicts --- src/catalog/abstract_catalog.cpp | 32 ++++++------------- src/catalog/query_metrics_catalog.cpp | 4 +-- .../operator/table_scan_translator.cpp | 15 ++++++--- src/include/catalog/query_metrics_catalog.h | 2 +- src/include/planner/seq_scan_plan.h | 2 +- test/catalog/catalog_test.cpp | 5 +-- test/statistics/testing_stats_util.cpp | 7 ++-- 7 files changed, 31 insertions(+), 36 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index f7ae9851ca6..741baaa59c8 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -12,10 +12,9 @@ #include "catalog/abstract_catalog.h" -#include "binder/bind_node_visitor.h" - #include "common/statement.h" +#include "catalog/catalog.h" #include "catalog/database_catalog.h" #include "catalog/table_catalog.h" @@ -59,25 +58,11 @@ AbstractCatalog::AbstractCatalog(oid_t catalog_table_oid, AbstractCatalog::AbstractCatalog(const std::string &catalog_table_ddl, concurrency::TransactionContext *txn) { - // Get catalog table schema + // get catalog table schema auto &peloton_parser = parser::PostgresParser::GetInstance(); - - // Build the parse tree - const auto parse_tree_list = peloton_parser.BuildParseTree(catalog_table_ddl); - if (parse_tree_list->GetStatements().empty()) { - throw CatalogException( - "Parse tree list has no parse trees. Cannot build plan"); - } - // TODO: support multi-statement queries - auto parse_tree = parse_tree_list->GetStatement(0); - - // Run binder - auto bind_node_visitor = binder::BindNodeVisitor(txn, DATABASE_CATALOG_NAME); - bind_node_visitor.BindNameToNode(parse_tree); - - // Create the plan tree auto create_plan = std::dynamic_pointer_cast( - optimizer::Optimizer().BuildPelotonPlanTree(parse_tree_list, txn)); + optimizer::Optimizer().BuildPelotonPlanTree( + peloton_parser.BuildParseTree(catalog_table_ddl), txn)); auto catalog_table_schema = create_plan->GetSchema(); auto catalog_table_name = create_plan->GetTableName(); auto catalog_schema_name = create_plan->GetSchemaName(); @@ -88,15 +73,17 @@ AbstractCatalog::AbstractCatalog(const std::string &catalog_table_ddl, catalog_database_name, catalog_schema_name, catalog_table_name, std::unique_ptr(catalog_table_schema), txn, true); - // Get catalog table oid + // get catalog table oid auto catalog_table_object = Catalog::GetInstance()->GetTableObject( catalog_database_name, catalog_schema_name, catalog_table_name, txn); - // Set catalog_table_ + // set catalog_table_ try { catalog_table_ = storage::StorageManager::GetInstance()->GetTableWithOid( catalog_table_object->GetDatabaseOid(), catalog_table_object->GetTableOid()); + // set database_oid + database_oid = catalog_table_object->GetDatabaseOid(); } catch (CatalogException &e) { LOG_TRACE("Can't find table %d! Return false", catalog_table_object->GetTableOid()); @@ -336,7 +323,8 @@ bool AbstractCatalog::UpdateWithIndexScan( std::vector runtime_keys; planner::IndexScanPlan::IndexScanDesc index_scan_desc( - index, key_column_offsets, expr_types, scan_values, runtime_keys); + index->GetOid(), key_column_offsets, expr_types, scan_values, + runtime_keys); planner::IndexScanPlan index_scan_node(catalog_table_, nullptr, update_columns, index_scan_desc); diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index c49fd95f379..0fd6b7c44d7 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -99,8 +99,7 @@ bool QueryMetricsCatalog::InsertQueryMetrics( } bool QueryMetricsCatalog::DeleteQueryMetrics( - const std::string &name, oid_t database_oid, - concurrency::TransactionContext *txn) { + const std::string &name, concurrency::TransactionContext *txn) { oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index std::vector values; @@ -116,6 +115,7 @@ stats::QueryMetric::QueryParamBuf QueryMetricsCatalog::GetParamTypes( 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()); auto result_tiles = GetResultWithIndexScan(column_ids, index_offset, values, txn); diff --git a/src/codegen/operator/table_scan_translator.cpp b/src/codegen/operator/table_scan_translator.cpp index 5cebc93a75c..f9a793c2be7 100644 --- a/src/codegen/operator/table_scan_translator.cpp +++ b/src/codegen/operator/table_scan_translator.cpp @@ -14,9 +14,9 @@ #include "codegen/lang/if.h" #include "codegen/proxy/executor_context_proxy.h" +#include "codegen/proxy/runtime_functions_proxy.h" #include "codegen/proxy/storage_manager_proxy.h" #include "codegen/proxy/transaction_runtime_proxy.h" -#include "codegen/proxy/runtime_functions_proxy.h" #include "codegen/proxy/zone_map_proxy.h" #include "codegen/type/boolean_type.h" #include "planner/seq_scan_plan.h" @@ -50,7 +50,7 @@ TableScanTranslator::TableScanTranslator(const planner::SeqScanPlan &scan, pipeline.InstallBoundaryAtOutput(this); } } - LOG_DEBUG("Finished constructing TableScanTranslator ..."); + LOG_TRACE("Finished constructing TableScanTranslator ..."); } // Produce! @@ -135,8 +135,12 @@ void TableScanTranslator::ScanConsumer::ProcessTuples( } // 3. Setup the (filtered) row batch and setup attribute accessors - RowBatch batch{translator_.GetCompilationContext(), tile_group_id_, tid_start, - tid_end, selection_vector_, true}; + RowBatch batch{translator_.GetCompilationContext(), + tile_group_id_, + tid_start, + tid_end, + selection_vector_, + true}; std::vector attribute_accesses; SetupRowBatch(batch, tile_group_access, attribute_accesses); @@ -227,7 +231,8 @@ void TableScanTranslator::ScanConsumer::FilterRowsByPredicate( codegen::Value valid_row = row.DeriveValue(codegen, *predicate); // Reify the boolean value since it may be NULL - PELOTON_ASSERT(valid_row.GetType().GetSqlType() == type::Boolean::Instance()); + PELOTON_ASSERT(valid_row.GetType().GetSqlType() == + type::Boolean::Instance()); llvm::Value *bool_val = type::Boolean::Instance().Reify(codegen, valid_row); // Set the validity of the row diff --git a/src/include/catalog/query_metrics_catalog.h b/src/include/catalog/query_metrics_catalog.h index ed6ea2c9d37..643893d375c 100644 --- a/src/include/catalog/query_metrics_catalog.h +++ b/src/include/catalog/query_metrics_catalog.h @@ -59,7 +59,7 @@ class QueryMetricsCatalog : public AbstractCatalog { 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, oid_t database_oid, + bool DeleteQueryMetrics(const std::string &name, concurrency::TransactionContext *txn); //===--------------------------------------------------------------------===// diff --git a/src/include/planner/seq_scan_plan.h b/src/include/planner/seq_scan_plan.h index 690e74d9c7d..3e1f68f7cae 100644 --- a/src/include/planner/seq_scan_plan.h +++ b/src/include/planner/seq_scan_plan.h @@ -17,10 +17,10 @@ #include #include "abstract_scan_plan.h" +#include "common/internal_types.h" #include "common/logger.h" #include "expression/abstract_expression.h" #include "type/serializer.h" -#include "common/internal_types.h" namespace peloton { diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index 02e76b638bf..8da57e19cd3 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -100,8 +100,9 @@ TEST_F(CatalogTests, CreatingTable) { catalog::Catalog::GetInstance() ->GetSystemCatalogs(database_object->GetDatabaseOid()) ->GetQueryMetricsCatalog() - ->InsertQueryMetrics("a query", 1, param, param, param, 1, 1, 1, 1, 1, 1, - 1, pool.get(), txn); + ->InsertQueryMetrics("a query", database_object->GetDatabaseOid(), 1, + param, param, param, 1, 1, 1, 1, 1, 1, 1, pool.get(), + txn); auto param1 = catalog::Catalog::GetInstance() ->GetSystemCatalogs(database_object->GetDatabaseOid()) ->GetQueryMetricsCatalog() diff --git a/test/statistics/testing_stats_util.cpp b/test/statistics/testing_stats_util.cpp index 3811e84b5c9..7b0f87852fe 100644 --- a/test/statistics/testing_stats_util.cpp +++ b/test/statistics/testing_stats_util.cpp @@ -137,7 +137,7 @@ std::shared_ptr TestingStatsUtil::GetInsertStmt(int id, std::string val) { std::shared_ptr statement; std::string sql = - "INSERT INTO department_table(dept_id,dept_name) VALUES " + "INSERT INTO emp_db.public.department_table(dept_id,dept_name) VALUES " "(" + std::to_string(id) + ",'" + val + "');"; LOG_TRACE("Query: %s", sql.c_str()); @@ -148,7 +148,7 @@ std::shared_ptr TestingStatsUtil::GetInsertStmt(int id, std::shared_ptr TestingStatsUtil::GetDeleteStmt() { std::shared_ptr statement; - std::string sql = "DELETE FROM department_table"; + std::string sql = "DELETE FROM emp_db.public.department_table"; LOG_INFO("Query: %s", sql.c_str()); statement.reset(new Statement("DELETE", sql)); ParseAndPlan(statement.get(), sql); @@ -158,7 +158,8 @@ std::shared_ptr TestingStatsUtil::GetDeleteStmt() { std::shared_ptr TestingStatsUtil::GetUpdateStmt() { std::shared_ptr statement; std::string sql = - "UPDATE department_table SET dept_name = 'CS' WHERE dept_id = 1"; + "UPDATE emp_db.public.department_table SET dept_name = 'CS' WHERE " + "dept_id = 1"; LOG_INFO("Query: %s", sql.c_str()); statement.reset(new Statement("UPDATE", sql)); ParseAndPlan(statement.get(), sql); From 48c91e50741f9120180b8a395cfe5cdce958847c Mon Sep 17 00:00:00 2001 From: mengranwo Date: Wed, 25 Apr 2018 15:51:02 -0400 Subject: [PATCH 44/48] fix iso compile bug --- src/catalog/catalog.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 0774b857186..b09ceb2380d 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -923,7 +923,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 = " + - database_oid); + std::to_string(database_oid)); } return catalog_map_[database_oid]; } From 9ced76134682387b82694b8f06ca90d31c215ffd Mon Sep 17 00:00:00 2001 From: mengranwo Date: Fri, 27 Apr 2018 22:29:47 -0400 Subject: [PATCH 45/48] make changes according to pooja's reviews --- src/catalog/abstract_catalog.cpp | 4 ++ src/catalog/catalog.cpp | 10 +-- src/catalog/column_catalog.cpp | 2 +- src/catalog/system_catalogs.cpp | 66 ++++++++++--------- src/catalog/table_catalog.cpp | 8 ++- src/include/catalog/catalog_defaults.h | 1 + src/include/catalog/column_catalog.h | 2 +- src/include/catalog/query_metrics_catalog.h | 2 +- src/include/catalog/system_catalogs.h | 52 ++++++++------- src/include/planner/plan_util.h | 1 + src/include/planner/seq_scan_plan.h | 2 +- src/parser/postgresparser.cpp | 10 ++- src/statistics/stats_aggregator.cpp | 7 -- test/binder/binder_test.cpp | 1 - test/executor/drop_test.cpp | 1 - test/function/functions_test.cpp | 8 +-- test/optimizer/optimizer_test.cpp | 4 +- test/optimizer/tuple_samples_storage_test.cpp | 2 +- test/settings/settings_manager_test.cpp | 2 - test/sql/timestamp_functions_sql_test.cpp | 1 - test/sql/type_sql_test.cpp | 1 - test/storage/database_test.cpp | 4 +- test/trigger/trigger_test.cpp | 4 -- test/udf/udf_test.cpp | 2 - 24 files changed, 102 insertions(+), 95 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 741baaa59c8..645e9c9d93f 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -317,6 +317,10 @@ bool AbstractCatalog::UpdateWithIndexScan( auto index = catalog_table_->GetIndex(index_offset); std::vector key_column_offsets = index->GetMetadata()->GetKeySchema()->GetIndexedColumns(); + + // NOTE: For indexed scan on catalog tables, we expect it not to be "partial + // indexed scan"(efficiency purpose).That being said, indexed column number + // must be equal to passed in "scan_values" size PELOTON_ASSERT(scan_values.size() == key_column_offsets.size()); std::vector expr_types(scan_values.size(), ExpressionType::COMPARE_EQUAL); diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index b09ceb2380d..90b9d13a62a 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -74,10 +74,12 @@ Catalog::Catalog() : pool_(new type::EphemeralPool()) { txn_manager.CommitTransaction(txn); } -/* This function *MUST* be called after a new database is created to bootstrap - * all system catalog tables for that database. - * The system catalog tables must be created in certain order to make sure - * all tuples are indexed (actually this might be fine now after Paulo's fix) +/*@brief This function *MUST* be called after a new database is created to + * bootstrap all system catalog tables for that database. The system catalog + * tables must be created in certain order to make sure all tuples are indexed + * + * @param database database which this system catalogs belong to + * @param txn transaction context */ void Catalog::BootstrapSystemCatalogs(storage::Database *database, concurrency::TransactionContext *txn) { diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index 2084577ef4c..8262ffe479c 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -137,7 +137,7 @@ std::unique_ptr ColumnCatalog::InitializeSchema() { bool ColumnCatalog::InsertColumn(oid_t table_oid, const std::string &column_name, - uint32_t column_id, uint32_t column_offset, + oid_t column_id, oid_t column_offset, type::TypeId column_type, bool is_inlined, const std::vector &constraints, type::AbstractPool *pool, diff --git a/src/catalog/system_catalogs.cpp b/src/catalog/system_catalogs.cpp index 17966290fa5..b1371ddd379 100644 --- a/src/catalog/system_catalogs.cpp +++ b/src/catalog/system_catalogs.cpp @@ -21,18 +21,23 @@ namespace peloton { namespace catalog { +/*@brief system catalog constructor, create core catalog tables and manually + * insert records into pg_attribute + * @param database the database which the catalog tables belongs to + * @param txn TransactionContext + */ SystemCatalogs::SystemCatalogs(storage::Database *database, type::AbstractPool *pool, concurrency::TransactionContext *txn) - : pg_trigger(nullptr), - pg_table_metrics(nullptr), - pg_index_metrics(nullptr), - pg_query_metrics(nullptr) { + : 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_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); // TODO: can we move this to BootstrapSystemCatalogs()? // insert column information into pg_attribute @@ -49,52 +54,53 @@ 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.IsInlined(), - column.GetConstraints(), pool, txn); + pg_attribute_->InsertColumn(shared_tables[i].second, column.GetName(), + column_id, column.GetOffset(), + column.GetType(), column.IsInlined(), + column.GetConstraints(), pool, txn); column_id++; } } } SystemCatalogs::~SystemCatalogs() { - delete pg_index; - delete pg_table; - delete pg_attribute; - delete pg_namespace; - if (pg_trigger) delete pg_trigger; + delete pg_index_; + delete pg_table_; + delete pg_attribute_; + delete pg_namespace_; + if (pg_trigger_) delete pg_trigger_; // if (pg_proc) delete pg_proc; - if (pg_table_metrics) delete pg_table_metrics; - if (pg_index_metrics) delete pg_index_metrics; - if (pg_query_metrics) delete pg_query_metrics; + if (pg_table_metrics_) delete pg_table_metrics_; + if (pg_index_metrics_) delete pg_index_metrics_; + if (pg_query_metrics_) delete pg_query_metrics_; } -/* - * @brief using sql create statement to create secondary catalog tables +/*@brief using sql create statement to create secondary catalog tables + * @param database_name the database which the namespace belongs to + * @param txn TransactionContext */ void SystemCatalogs::Bootstrap(const std::string &database_name, concurrency::TransactionContext *txn) { LOG_DEBUG("Bootstrapping database: %s", database_name.c_str()); - if (!pg_trigger) { - pg_trigger = new TriggerCatalog(database_name, txn); + if (!pg_trigger_) { + pg_trigger_ = new TriggerCatalog(database_name, txn); } // if (!pg_proc) { // pg_proc = new ProcCatalog(database_name, txn); // } - if (!pg_table_metrics) { - pg_table_metrics = new TableMetricsCatalog(database_name, txn); + if (!pg_table_metrics_) { + pg_table_metrics_ = new TableMetricsCatalog(database_name, txn); } - if (!pg_index_metrics) { - pg_index_metrics = new IndexMetricsCatalog(database_name, txn); + if (!pg_index_metrics_) { + pg_index_metrics_ = new IndexMetricsCatalog(database_name, txn); } - if (!pg_query_metrics) { - pg_query_metrics = new QueryMetricsCatalog(database_name, txn); + if (!pg_query_metrics_) { + pg_query_metrics_ = new QueryMetricsCatalog(database_name, txn); } } diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 33a9d8bd91b..34ef723e366 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -410,7 +410,7 @@ bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, /*@brief delete a tuple about table info from pg_table(using index scan) * @param table_oid * @param txn TransactionContext - * @return Whether deletion is Successful + * @return Whether deletion is successful */ bool TableCatalog::DeleteTable(oid_t table_oid, concurrency::TransactionContext *txn) { @@ -561,6 +561,12 @@ TableCatalog::GetTableObjects(concurrency::TransactionContext *txn) { return database_object->GetTableObjects(); } +/*@brief update version id column within pg_table + * @param update_val the new(updated) version id + * @param table_oid which table to be updated + * @param txn TransactionContext + * @return Whether update is successful + */ bool TableCatalog::UpdateVersionId(oid_t update_val, oid_t table_oid, concurrency::TransactionContext *txn) { std::vector update_columns({ColumnId::VERSION_ID}); // version_id diff --git a/src/include/catalog/catalog_defaults.h b/src/include/catalog/catalog_defaults.h index 1b7df9fd3ad..2cfcacbda70 100644 --- a/src/include/catalog/catalog_defaults.h +++ b/src/include/catalog/catalog_defaults.h @@ -35,6 +35,7 @@ namespace catalog { // Local oids from START_OID = 0 to START_OID + OID_OFFSET are reserved #define OID_OFFSET 100 +#define CATALOG_TABLES_COUNT 8 // Oid mask for each type #define DATABASE_OID_MASK (static_cast(catalog::CatalogType::DATABASE)) diff --git a/src/include/catalog/column_catalog.h b/src/include/catalog/column_catalog.h index 3df0d551967..7dcdf96e4a5 100644 --- a/src/include/catalog/column_catalog.h +++ b/src/include/catalog/column_catalog.h @@ -81,7 +81,7 @@ class ColumnCatalog : public AbstractCatalog { // write Related API //===--------------------------------------------------------------------===// bool InsertColumn(oid_t table_oid, const std::string &column_name, - uint32_t column_id, uint32_t column_offset, + oid_t column_id, oid_t column_offset, type::TypeId column_type, bool is_inlined, const std::vector &constraints, type::AbstractPool *pool, diff --git a/src/include/catalog/query_metrics_catalog.h b/src/include/catalog/query_metrics_catalog.h index 643893d375c..a8045fd94e1 100644 --- a/src/include/catalog/query_metrics_catalog.h +++ b/src/include/catalog/query_metrics_catalog.h @@ -70,7 +70,7 @@ class QueryMetricsCatalog : public AbstractCatalog { int64_t GetNumParams(const std::string &name, concurrency::TransactionContext *txn); // TODO: In theory, we don't need database_oid - // but now we store all the query metrics under default database "pelton" + // but now we store all the query metrics under default database "peloton" enum ColumnId { NAME = 0, DATABASE_OID = 1, diff --git a/src/include/catalog/system_catalogs.h b/src/include/catalog/system_catalogs.h index 7c9345867e3..7791c019097 100644 --- a/src/include/catalog/system_catalogs.h +++ b/src/include/catalog/system_catalogs.h @@ -47,73 +47,77 @@ class SystemCatalogs { void Bootstrap(const std::string &database_name, concurrency::TransactionContext *txn); + //===--------------------------------------------------------------------===// + // GET FUNCTIONS + // get catalog tables with name + //===--------------------------------------------------------------------===// ColumnCatalog *GetColumnCatalog() { - if (!pg_attribute) { + if (!pg_attribute_) { throw CatalogException("Column catalog has not been initialized"); } - return pg_attribute; + return pg_attribute_; } SchemaCatalog *GetSchemaCatalog() { - if (!pg_namespace) { + if (!pg_namespace_) { throw CatalogException("schema catalog has not been initialized"); } - return pg_namespace; + return pg_namespace_; } TableCatalog *GetTableCatalog() { - if (!pg_table) { + if (!pg_table_) { throw CatalogException("Table catalog has not been initialized"); } - return pg_table; + return pg_table_; } IndexCatalog *GetIndexCatalog() { - if (!pg_index) { + if (!pg_index_) { throw CatalogException("Index catalog has not been initialized"); } - return pg_index; + return pg_index_; } TriggerCatalog *GetTriggerCatalog() { - if (!pg_trigger) { + if (!pg_trigger_) { throw CatalogException("Trigger catalog has not been initialized"); } - return pg_trigger; + return pg_trigger_; } TableMetricsCatalog *GetTableMetricsCatalog() { - if (!pg_table_metrics) { + if (!pg_table_metrics_) { throw CatalogException("Table metrics catalog has not been initialized"); } - return pg_table_metrics; + return pg_table_metrics_; } IndexMetricsCatalog *GetIndexMetricsCatalog() { - if (!pg_index_metrics) { + if (!pg_index_metrics_) { throw CatalogException("Index metrics catalog has not been initialized"); } - return pg_index_metrics; + return pg_index_metrics_; } QueryMetricsCatalog *GetQueryMetricsCatalog() { - if (!pg_query_metrics) { + if (!pg_query_metrics_) { throw CatalogException("Query metrics catalog has not been initialized"); } - return pg_query_metrics; + return pg_query_metrics_; } private: - ColumnCatalog *pg_attribute; - SchemaCatalog *pg_namespace; - TableCatalog *pg_table; - IndexCatalog *pg_index; + ColumnCatalog *pg_attribute_; + SchemaCatalog *pg_namespace_; + TableCatalog *pg_table_; + IndexCatalog *pg_index_; - TriggerCatalog *pg_trigger; + TriggerCatalog *pg_trigger_; // ProcCatalog *pg_proc; - TableMetricsCatalog *pg_table_metrics; - IndexMetricsCatalog *pg_index_metrics; - QueryMetricsCatalog *pg_query_metrics; + TableMetricsCatalog *pg_table_metrics_; + IndexMetricsCatalog *pg_index_metrics_; + QueryMetricsCatalog *pg_query_metrics_; }; } // namespace catalog diff --git a/src/include/planner/plan_util.h b/src/include/planner/plan_util.h index 2979fd5ea6b..ca73beb46ea 100644 --- a/src/include/planner/plan_util.h +++ b/src/include/planner/plan_util.h @@ -57,6 +57,7 @@ class PlanUtil { /** * @brief Get the indexes affected by a given query + * @param CatalogCache * @param SQLStatement * @return set of affected index object ids */ diff --git a/src/include/planner/seq_scan_plan.h b/src/include/planner/seq_scan_plan.h index 3e1f68f7cae..690e74d9c7d 100644 --- a/src/include/planner/seq_scan_plan.h +++ b/src/include/planner/seq_scan_plan.h @@ -17,10 +17,10 @@ #include #include "abstract_scan_plan.h" -#include "common/internal_types.h" #include "common/logger.h" #include "expression/abstract_expression.h" #include "type/serializer.h" +#include "common/internal_types.h" namespace peloton { diff --git a/src/parser/postgresparser.cpp b/src/parser/postgresparser.cpp index e68f3f15ed3..797b77406b5 100644 --- a/src/parser/postgresparser.cpp +++ b/src/parser/postgresparser.cpp @@ -1388,7 +1388,8 @@ parser::DropStatement *PostgresParser::DropTableTransform(DropStmt *root) { auto table_info = new TableInfo{}; auto table_list = reinterpret_cast(cell->data.ptr_value); LOG_TRACE("%d", ((Node *)(table_list->head->data.ptr_value))->type); - // if schema name is specified + // if schema name is specified, which means you are using the syntax like + // DROP INDEX/TABLE A.B where A is schema name and B is table/index name if (table_list->length == 2) { table_info->schema_name = reinterpret_cast(table_list->head->data.ptr_value)->val.str; @@ -1412,8 +1413,10 @@ parser::DropStatement *PostgresParser::DropTriggerTransform(DropStmt *root) { // first, set trigger name result->SetTriggerName( reinterpret_cast(list->tail->data.ptr_value)->val.str); - // if schema name is specified TableInfo *table_info = new TableInfo{}; + // if schema name is specified, which means you are using the syntax like + // DROP TRIGGER A.B.C where A is schema name, B is table name and C is trigger + // name if (list->length == 3) { table_info->schema_name = reinterpret_cast(list->head->data.ptr_value)->val.str; @@ -1448,7 +1451,8 @@ parser::DropStatement *PostgresParser::DropIndexTransform(DropStmt *root) { auto result = new DropStatement(DropStatement::EntityType::kIndex); auto cell = root->objects->head; auto list = reinterpret_cast(cell->data.ptr_value); - // if schema name is specified + // if schema name is specified, which means you are using the syntax like + // DROP INDEX/TABLE A.B where A is schema name and B is table/index name if (list->length == 2) { TableInfo *table_info = new TableInfo{}; table_info->schema_name = diff --git a/src/statistics/stats_aggregator.cpp b/src/statistics/stats_aggregator.cpp index 2d4c68c8794..6d4a39847a3 100644 --- a/src/statistics/stats_aggregator.cpp +++ b/src/statistics/stats_aggregator.cpp @@ -161,13 +161,6 @@ void StatsAggregator::UpdateQueryMetrics(int64_t time_stamp, } // Generate and insert the tuple - // auto query_tuple = catalog::GetQueryMetricsCatalogTuple( - // query_metrics_table->GetSchema(), 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()); - // catalog::InsertTuple(query_metrics_table, std::move(query_tuple), txn); - catalog::Catalog::GetInstance() ->GetSystemCatalogs(query_metric->GetDatabaseId()) ->GetQueryMetricsCatalog() diff --git a/test/binder/binder_test.cpp b/test/binder/binder_test.cpp index 4f1467285f1..b82df1ec72a 100644 --- a/test/binder/binder_test.cpp +++ b/test/binder/binder_test.cpp @@ -42,7 +42,6 @@ class BinderCorrectnessTest : public PelotonTest { PelotonTest::SetUp(); catalog::Catalog::GetInstance(); // NOTE: Catalog::GetInstance()->Bootstrap(), you can only call it once! - // catalog->Bootstrap(); TestingExecutorUtil::InitializeDatabase(DEFAULT_DB_NAME); } diff --git a/test/executor/drop_test.cpp b/test/executor/drop_test.cpp index 271c590e500..19e6c1293da 100644 --- a/test/executor/drop_test.cpp +++ b/test/executor/drop_test.cpp @@ -77,7 +77,6 @@ TEST_F(DropTests, DroppingTable) { auto catalog = catalog::Catalog::GetInstance(); // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests // you can only call it once! - // catalog->Bootstrap(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); diff --git a/test/function/functions_test.cpp b/test/function/functions_test.cpp index 2153fbb44eb..25b56ab5823 100644 --- a/test/function/functions_test.cpp +++ b/test/function/functions_test.cpp @@ -31,16 +31,14 @@ class FunctionsTests : public PelotonTest { virtual void SetUp() { PelotonTest::SetUp(); - // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous - // unit tests you can only call it once! - // auto catalog = - // catalog::Catalog::GetInstance(); catalog->Bootstrap(); + // Bootstrap catalog + auto catalog = catalog::Catalog::GetInstance(); + catalog->Bootstrap(); } }; TEST_F(FunctionsTests, CatalogTest) { auto catalog = catalog::Catalog::GetInstance(); - catalog->Bootstrap(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto &pg_language = catalog::LanguageCatalog::GetInstance(); diff --git a/test/optimizer/optimizer_test.cpp b/test/optimizer/optimizer_test.cpp index 11971114f69..dae410999d6 100644 --- a/test/optimizer/optimizer_test.cpp +++ b/test/optimizer/optimizer_test.cpp @@ -124,7 +124,7 @@ TEST_F(OptimizerTests, HashJoinTest) { EXPECT_EQ(catalog::Catalog::GetInstance() ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) ->GetTableCount(), - 9); + 1 + CATALOG_TABLES_COUNT); traffic_cop.SetTcopTxnState(txn); LOG_INFO("Creating table"); @@ -159,7 +159,7 @@ TEST_F(OptimizerTests, HashJoinTest) { EXPECT_EQ(catalog::Catalog::GetInstance() ->GetDatabaseWithName(DEFAULT_DB_NAME, txn) ->GetTableCount(), - 10); + 2 + CATALOG_TABLES_COUNT); // Inserting a tuple to table_a traffic_cop.SetTcopTxnState(txn); diff --git a/test/optimizer/tuple_samples_storage_test.cpp b/test/optimizer/tuple_samples_storage_test.cpp index a5dd4524a4d..2103d63549c 100644 --- a/test/optimizer/tuple_samples_storage_test.cpp +++ b/test/optimizer/tuple_samples_storage_test.cpp @@ -51,7 +51,7 @@ TEST_F(TupleSamplesStorageTests, SamplesDBTest) { EXPECT_TRUE(samples_db != nullptr); EXPECT_EQ(samples_db->GetDBName(), SAMPLES_DB_NAME); // NOTE: everytime we create a database, there will be 8 catalog tables inside - EXPECT_EQ(samples_db->GetTableCount(), 8); + EXPECT_EQ(samples_db->GetTableCount(), CATALOG_TABLES_COUNT); } TEST_F(TupleSamplesStorageTests, AddSamplesTableTest) { diff --git a/test/settings/settings_manager_test.cpp b/test/settings/settings_manager_test.cpp index 3e5658d6b26..e9e00162259 100644 --- a/test/settings/settings_manager_test.cpp +++ b/test/settings/settings_manager_test.cpp @@ -61,8 +61,6 @@ TEST_F(SettingsManagerTests, InitializationTest) { TEST_F(SettingsManagerTests, ModificationTest) { // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests // you can only call it once! - // auto catalog = catalog::Catalog::GetInstance(); - // catalog->Bootstrap(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto &config_manager = settings::SettingsManager::GetInstance(); diff --git a/test/sql/timestamp_functions_sql_test.cpp b/test/sql/timestamp_functions_sql_test.cpp index 61724b2c53b..c368f84ad1c 100644 --- a/test/sql/timestamp_functions_sql_test.cpp +++ b/test/sql/timestamp_functions_sql_test.cpp @@ -82,7 +82,6 @@ TEST_F(TimestampFunctionsSQLTest, DatePartTest) { catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn); // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests // you can only call it once! - // catalog::Catalog::GetInstance()->Bootstrap(); txn_manager.CommitTransaction(txn); // create tale and insert one tuple TestingSQLUtil::ExecuteSQLQuery( diff --git a/test/sql/type_sql_test.cpp b/test/sql/type_sql_test.cpp index cffd14012b9..1da4f602646 100644 --- a/test/sql/type_sql_test.cpp +++ b/test/sql/type_sql_test.cpp @@ -28,7 +28,6 @@ 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()->Bootstrap(); txn_manager.CommitTransaction(txn); } diff --git a/test/storage/database_test.cpp b/test/storage/database_test.cpp index 289d0cb1ba9..b60919a79d3 100644 --- a/test/storage/database_test.cpp +++ b/test/storage/database_test.cpp @@ -63,11 +63,11 @@ TEST_F(DatabaseTests, AddDropTableTest) { database->AddTable(data_table.get()); // NOTE: everytime we create a database, there will be 8 catalog tables inside - EXPECT_TRUE(database->GetTableCount() == 9); + EXPECT_TRUE(database->GetTableCount() == 1 + CATALOG_TABLES_COUNT); database->DropTableWithOid(table_oid); - EXPECT_TRUE(database->GetTableCount() == 8); + EXPECT_TRUE(database->GetTableCount() == CATALOG_TABLES_COUNT); data_table.release(); diff --git a/test/trigger/trigger_test.cpp b/test/trigger/trigger_test.cpp index 8c3044a134d..ea22d4deca5 100644 --- a/test/trigger/trigger_test.cpp +++ b/test/trigger/trigger_test.cpp @@ -122,7 +122,6 @@ class TriggerTests : public PelotonTest { auto parser = parser::PostgresParser::GetInstance(); // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous // tests you can only call it once! - // catalog::Catalog::GetInstance()->Bootstrap(); std::unique_ptr stmt_list( parser.BuildParseTree(query).release()); @@ -229,7 +228,6 @@ TEST_F(TriggerTests, BeforeAndAfterRowInsertTriggers) { auto parser = parser::PostgresParser::GetInstance(); // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests // you can only call it once! - // catalog::Catalog::GetInstance()->Bootstrap(); // Create table CreateTableHelper(); @@ -315,7 +313,6 @@ TEST_F(TriggerTests, AfterStatmentInsertTriggers) { auto parser = parser::PostgresParser::GetInstance(); // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests // you can only call it once! - // catalog::Catalog::GetInstance()->Bootstrap(); // Create table CreateTableHelper(); @@ -397,7 +394,6 @@ TEST_F(TriggerTests, OtherTypesTriggers) { auto parser = parser::PostgresParser::GetInstance(); // NOTE: Catalog::GetInstance()->Bootstrap() has been called in previous tests // you can only call it once! - // catalog::Catalog::GetInstance()->Bootstrap(); // Create table CreateTableHelper(); diff --git a/test/udf/udf_test.cpp b/test/udf/udf_test.cpp index f4eee947f76..b45b29510b3 100644 --- a/test/udf/udf_test.cpp +++ b/test/udf/udf_test.cpp @@ -136,7 +136,6 @@ 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()->Bootstrap(); txn_manager.CommitTransaction(txn); // Create a txn txn = txn_manager.BeginTransaction(); @@ -195,7 +194,6 @@ 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()->Bootstrap(); txn_manager.CommitTransaction(txn); // Create a txn txn = txn_manager.BeginTransaction(); From 7f7fc4409db6f25eef704c1ae1b7e5f4d0fb9589 Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sat, 28 Apr 2018 19:21:49 -0400 Subject: [PATCH 46/48] added namespace sql test --- src/common/internal_types.cpp | 31 +++++------ test/catalog/catalog_test.cpp | 98 +++++++++++++++++++++++------------ test/sql/testing_sql_util.cpp | 5 +- 3 files changed, 84 insertions(+), 50 deletions(-) diff --git a/src/common/internal_types.cpp b/src/common/internal_types.cpp index 7efd503a2eb..6d95bf1a35c 100644 --- a/src/common/internal_types.cpp +++ b/src/common/internal_types.cpp @@ -585,7 +585,7 @@ std::string QueryTypeToString(QueryType query_type) { return "EXECUTE"; case QueryType::QUERY_SELECT: return "SELECT"; - case QueryType::QUERY_EXPLAIN: + case QueryType::QUERY_EXPLAIN: return "EXPLAIN"; case QueryType::QUERY_OTHER: default: @@ -633,20 +633,18 @@ QueryType StatementTypeToQueryType(StatementType stmt_type, const parser::SQLStatement *sql_stmt) { LOG_TRACE("%s", StatementTypeToString(stmt_type).c_str()); static std::unordered_map> - type_map{ - {StatementType::EXECUTE, QueryType::QUERY_EXECUTE}, - {StatementType::PREPARE, QueryType::QUERY_PREPARE}, - {StatementType::INSERT, QueryType::QUERY_INSERT}, - {StatementType::UPDATE, QueryType::QUERY_UPDATE}, - {StatementType::DELETE, QueryType::QUERY_DELETE}, - {StatementType::COPY, QueryType::QUERY_COPY}, - {StatementType::ANALYZE, QueryType::QUERY_ANALYZE}, - {StatementType::ALTER, QueryType::QUERY_ALTER}, - {StatementType::DROP, QueryType::QUERY_DROP}, - {StatementType::SELECT, QueryType::QUERY_SELECT}, - {StatementType::VARIABLE_SET, QueryType::QUERY_SET}, - {StatementType::EXPLAIN, QueryType::QUERY_EXPLAIN} - }; + type_map{{StatementType::EXECUTE, QueryType::QUERY_EXECUTE}, + {StatementType::PREPARE, QueryType::QUERY_PREPARE}, + {StatementType::INSERT, QueryType::QUERY_INSERT}, + {StatementType::UPDATE, QueryType::QUERY_UPDATE}, + {StatementType::DELETE, QueryType::QUERY_DELETE}, + {StatementType::COPY, QueryType::QUERY_COPY}, + {StatementType::ANALYZE, QueryType::QUERY_ANALYZE}, + {StatementType::ALTER, QueryType::QUERY_ALTER}, + {StatementType::DROP, QueryType::QUERY_DROP}, + {StatementType::SELECT, QueryType::QUERY_SELECT}, + {StatementType::VARIABLE_SET, QueryType::QUERY_SET}, + {StatementType::EXPLAIN, QueryType::QUERY_EXPLAIN}}; QueryType query_type = QueryType::QUERY_OTHER; std::unordered_map>::iterator it = @@ -2004,6 +2002,9 @@ std::string ResultTypeToString(ResultType type) { case ResultType::QUEUING: { return ("QUEUING"); } + case ResultType::TO_ABORT: { + return ("TO_ABORT"); + } default: { throw ConversionException( StringUtil::Format("No string conversion for ResultType value '%d'", diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index 8da57e19cd3..3e6b5e15872 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -23,6 +23,7 @@ #include "concurrency/transaction_manager_factory.h" #include "storage/storage_manager.h" #include "type/ephemeral_pool.h" +#include "sql/testing_sql_util.h" namespace peloton { namespace test { @@ -116,40 +117,6 @@ TEST_F(CatalogTests, CreatingTable) { ->GetColumnObject(1) ->GetColumnName()); txn_manager.CommitTransaction(txn); - // EXPECT_EQ(5, time_stamp); - - // We remove these tests so people can add new catalogs without breaking this - // test... - // 3 + 4 - // EXPECT_EQ(catalog::Catalog::GetInstance() - // ->GetDatabaseWithName("pg_catalog") - // ->GetTableWithName("pg_table") - // ->GetTupleCount(), - // 11); - // // 6 + pg_database(2) + pg_table(3) + pg_attribute(7) + pg_index(6) - // EXPECT_EQ(catalog::Catalog::GetInstance() - // ->GetDatabaseWithName("pg_catalog") - // ->GetTableWithName("pg_attribute") - // ->GetTupleCount(), - // 57); - // // pg_catalog + emp_db - // EXPECT_EQ(catalog::Catalog::GetInstance() - // ->GetDatabaseWithName("pg_catalog") - // ->GetTableWithName("pg_database") - // ->GetTupleCount(), - // 2); - // // 3 + pg_index(3) + pg_attribute(3) + pg_table(3) + pg_database(2) - // EXPECT_EQ(catalog::Catalog::GetInstance() - // ->GetDatabaseWithName("pg_catalog") - // ->GetTableWithName("pg_index") - // ->GetTupleCount(), - // 18); - // EXPECT_EQ(catalog::Catalog::GetInstance() - // ->GetDatabaseWithName("pg_catalog") - // ->GetTableWithName("pg_table") - // ->GetSchema() - // ->GetLength(), - // 72); } TEST_F(CatalogTests, TableObject) { @@ -200,6 +167,69 @@ TEST_F(CatalogTests, TableObject) { txn_manager.CommitTransaction(txn); } +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;")); + EXPECT_EQ(ResultType::SUCCESS, + TestingSQLUtil::ExecuteSQLQuery("create schema emp_ns0;")); + EXPECT_EQ(ResultType::SUCCESS, + TestingSQLUtil::ExecuteSQLQuery("create schema emp_ns1;")); + + // create emp_table0 and emp_table1 in namespaces + EXPECT_EQ(ResultType::SUCCESS, + TestingSQLUtil::ExecuteSQLQuery( + "create table emp_ns0.emp_table0 (a int, b varchar);")); + EXPECT_EQ(ResultType::SUCCESS, + TestingSQLUtil::ExecuteSQLQuery( + "create table emp_ns0.emp_table1 (a int, b varchar);")); + EXPECT_EQ(ResultType::SUCCESS, + TestingSQLUtil::ExecuteSQLQuery( + "create table emp_ns1.emp_table0 (a int, b varchar);")); + EXPECT_EQ(ResultType::FAILURE, + TestingSQLUtil::ExecuteSQLQuery( + "create table emp_ns1.emp_table0 (a int, b varchar);")); + + // insert values into emp_table0 + EXPECT_EQ(ResultType::SUCCESS, + TestingSQLUtil::ExecuteSQLQuery( + "insert into emp_ns0.emp_table0 values (1, 'abc');")); + EXPECT_EQ(ResultType::SUCCESS, + TestingSQLUtil::ExecuteSQLQuery( + "insert into emp_ns0.emp_table0 values (2, 'abc');")); + EXPECT_EQ(ResultType::SUCCESS, + TestingSQLUtil::ExecuteSQLQuery( + "insert into emp_ns1.emp_table0 values (1, 'abc');")); + + // select values from emp_table0 and emp_table1 + TestingSQLUtil::ExecuteSQLQueryAndCheckResult( + "select * from emp_ns0.emp_table1;", {}); + TestingSQLUtil::ExecuteSQLQueryAndCheckResult( + "select * from emp_ns0.emp_table0;", {"1|abc", "2|abc"}); + TestingSQLUtil::ExecuteSQLQueryAndCheckResult( + "select * from emp_ns1.emp_table0;", {"1|abc"}); + 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;")); + EXPECT_EQ(ResultType::ABORTED, TestingSQLUtil::ExecuteSQLQuery("commit;")); + + // drop namespace emp_ns0 and emp_ns1 + EXPECT_EQ(ResultType::SUCCESS, TestingSQLUtil::ExecuteSQLQuery("begin;")); + EXPECT_EQ(ResultType::SUCCESS, + TestingSQLUtil::ExecuteSQLQuery("drop schema emp_ns0;")); + TestingSQLUtil::ExecuteSQLQueryAndCheckResult( + "select * from emp_ns1.emp_table0;", {"1|abc"}); + EXPECT_EQ(ResultType::SUCCESS, TestingSQLUtil::ExecuteSQLQuery("commit;")); + EXPECT_EQ(ResultType::SUCCESS, TestingSQLUtil::ExecuteSQLQuery("begin;")); + EXPECT_EQ(ResultType::FAILURE, + TestingSQLUtil::ExecuteSQLQuery("drop schema emp_ns0;")); + EXPECT_EQ(ResultType::FAILURE, TestingSQLUtil::ExecuteSQLQuery( + "select * from emp_ns0.emp_table1;")); + EXPECT_EQ(ResultType::ABORTED, TestingSQLUtil::ExecuteSQLQuery("commit;")); +} + TEST_F(CatalogTests, DroppingTable) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); diff --git a/test/sql/testing_sql_util.cpp b/test/sql/testing_sql_util.cpp index cfda127eacf..bef98209e19 100644 --- a/test/sql/testing_sql_util.cpp +++ b/test/sql/testing_sql_util.cpp @@ -115,6 +115,7 @@ ResultType TestingSQLUtil::ExecuteSQLQueryWithOptimizer( bind_node_visitor.BindNameToNode(parsed_stmt->GetStatement(0)); auto plan = optimizer->BuildPelotonPlanTree(parsed_stmt, txn); + txn_manager.CommitTransaction(txn); tuple_descriptor = traffic_cop_.GenerateTupleDescriptor(parsed_stmt->GetStatement(0)); auto result_format = std::vector(tuple_descriptor.size(), 0); @@ -248,7 +249,9 @@ void TestingSQLUtil::ExecuteSQLQueryAndCheckResult( // Execute query TestingSQLUtil::ExecuteSQLQuery(std::move(query), result, tuple_descriptor, rows_changed, error_message); - unsigned int rows = result.size() / tuple_descriptor.size(); + unsigned int rows = tuple_descriptor.size() == 0 + ? result.size() + : result.size() / tuple_descriptor.size(); // Build actual result as set of rows for comparison std::vector actual_result(rows); From bac11ddc7d532e16bfcb94e41795737295e0a5ca Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sun, 29 Apr 2018 14:24:35 -0400 Subject: [PATCH 47/48] addressing pooja's comments --- test/optimizer/optimizer_rule_test.cpp | 1 - test/sql/testing_sql_util.cpp | 8 +++++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/test/optimizer/optimizer_rule_test.cpp b/test/optimizer/optimizer_rule_test.cpp index e4266a7fa91..12d047ad51a 100644 --- a/test/optimizer/optimizer_rule_test.cpp +++ b/test/optimizer/optimizer_rule_test.cpp @@ -24,7 +24,6 @@ #include "expression/abstract_expression.h" #include "expression/operator_expression.h" -#define private public #include "optimizer/operator_expression.h" #include "optimizer/operators.h" #include "optimizer/optimizer.h" diff --git a/test/sql/testing_sql_util.cpp b/test/sql/testing_sql_util.cpp index bef98209e19..302dfb318f1 100644 --- a/test/sql/testing_sql_util.cpp +++ b/test/sql/testing_sql_util.cpp @@ -249,9 +249,11 @@ void TestingSQLUtil::ExecuteSQLQueryAndCheckResult( // Execute query TestingSQLUtil::ExecuteSQLQuery(std::move(query), result, tuple_descriptor, rows_changed, error_message); - unsigned int rows = tuple_descriptor.size() == 0 - ? result.size() - : result.size() / tuple_descriptor.size(); + if (tuple_descriptor.size() == 0) { + PELOTON_ASSERT(result.size() == 0); + return; + } + unsigned int rows = result.size() / tuple_descriptor.size(); // Build actual result as set of rows for comparison std::vector actual_result(rows); From 781b6d75e1c0e405e7fd397216431e432d7537ed Mon Sep 17 00:00:00 2001 From: Yixin Luo Date: Sun, 29 Apr 2018 20:12:33 -0400 Subject: [PATCH 48/48] fix plan util test --- src/planner/plan_util.cpp | 9 ++------- test/planner/plan_util_test.cpp | 29 ++++++++++++++++------------- test/sql/testing_sql_util.cpp | 1 - 3 files changed, 18 insertions(+), 21 deletions(-) diff --git a/src/planner/plan_util.cpp b/src/planner/plan_util.cpp index d9c7edd9986..cb013fb1531 100644 --- a/src/planner/plan_util.cpp +++ b/src/planner/plan_util.cpp @@ -69,9 +69,8 @@ const std::set PlanUtil::GetAffectedIndexes( db_name = update_stmt.table->GetDatabaseName(); 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); + auto table_object = catalog_cache.GetDatabaseObject(db_name) + ->GetTableObject(table_name, schema_name); auto &update_clauses = update_stmt.updates; std::set update_oids; @@ -169,10 +168,6 @@ const std::vector PlanUtil::GetIndexableColumns( for (const auto expr : expr_set) { auto tuple_value_expr = static_cast(expr); - - table_id = - db_object->GetTableObject(tuple_value_expr->GetTableName()) - ->GetTableOid(); column_oids.emplace_back(database_id, table_id, (oid_t)tuple_value_expr->GetColumnId()); } diff --git a/test/planner/plan_util_test.cpp b/test/planner/plan_util_test.cpp index f623b293051..8455e98efac 100644 --- a/test/planner/plan_util_test.cpp +++ b/test/planner/plan_util_test.cpp @@ -181,6 +181,9 @@ TEST_F(PlanUtilTests, GetIndexableColumnsTest) { catalog->CreateDatabase(TEST_DB_COLUMNS, txn); auto db = catalog->GetDatabaseWithName(TEST_DB_COLUMNS, txn); oid_t database_id = db->GetOid(); + auto db_object = catalog->GetDatabaseObject(TEST_DB_COLUMNS, txn); + int table_count = db_object->GetTableObjects().size(); + txn_manager.CommitTransaction(txn); // Insert a 'test_table' with 'id', 'first_name' and 'last_name' auto id_column = catalog::Column( @@ -193,16 +196,18 @@ TEST_F(PlanUtilTests, GetIndexableColumnsTest) { std::unique_ptr table_schema( new catalog::Schema({id_column, fname_column, lname_column})); - txn_manager.CommitTransaction(txn); txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_COLUMNS, "test_table", std::move(table_schema), - txn); + catalog->CreateTable(TEST_DB_COLUMNS, DEFUALT_SCHEMA_NAME, "test_table", + std::move(table_schema), txn); txn_manager.CommitTransaction(txn); // Obtain ids for the table and columns txn = txn_manager.BeginTransaction(); - auto source_table = db->GetTableWithName("test_table"); + auto source_table = catalog->GetTableWithName( + TEST_DB_COLUMNS, DEFUALT_SCHEMA_NAME, "test_table", txn); + txn_manager.CommitTransaction(txn); + oid_t table_id = source_table->GetOid(); oid_t id_col_oid = source_table->GetSchema()->GetColumnID(id_column.column_name); @@ -210,10 +215,9 @@ TEST_F(PlanUtilTests, GetIndexableColumnsTest) { source_table->GetSchema()->GetColumnID(fname_column.column_name); oid_t lname_col_oid = source_table->GetSchema()->GetColumnID(lname_column.column_name); - txn_manager.CommitTransaction(txn); - txn = txn_manager.BeginTransaction(); // Insert a 'test_table_job' with 'age', 'job' and 'pid' + txn = txn_manager.BeginTransaction(); auto age_column = catalog::Column( type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER), "age", true); @@ -224,16 +228,14 @@ TEST_F(PlanUtilTests, GetIndexableColumnsTest) { std::unique_ptr job_table_schema( new catalog::Schema({age_column, job_column, pid_column})); - txn_manager.CommitTransaction(txn); - - txn = txn_manager.BeginTransaction(); - catalog->CreateTable(TEST_DB_COLUMNS, "test_table_job", + catalog->CreateTable(TEST_DB_COLUMNS, DEFUALT_SCHEMA_NAME, "test_table_job", std::move(job_table_schema), txn); txn_manager.CommitTransaction(txn); // Obtain ids for the table and columns txn = txn_manager.BeginTransaction(); - auto source_table_job = db->GetTableWithName("test_table_job"); + auto source_table_job = catalog->GetTableWithName( + TEST_DB_COLUMNS, DEFUALT_SCHEMA_NAME, "test_table_job", txn); oid_t table_job_id = source_table_job->GetOid(); oid_t age_col_oid = source_table_job->GetSchema()->GetColumnID(age_column.column_name); @@ -245,8 +247,9 @@ TEST_F(PlanUtilTests, GetIndexableColumnsTest) { txn = txn_manager.BeginTransaction(); // This is required so that database objects are cached - auto db_object = catalog->GetDatabaseObject(TEST_DB_COLUMNS, txn); - EXPECT_EQ(2, static_cast(db_object->GetTableObjects().size())); + db_object = catalog->GetDatabaseObject(TEST_DB_COLUMNS, txn); + EXPECT_EQ( + 2, static_cast(db_object->GetTableObjects().size()) - table_count); // ====== UPDATE statements check === // id and first_name in test_table are affected diff --git a/test/sql/testing_sql_util.cpp b/test/sql/testing_sql_util.cpp index 302dfb318f1..220fa558686 100644 --- a/test/sql/testing_sql_util.cpp +++ b/test/sql/testing_sql_util.cpp @@ -115,7 +115,6 @@ ResultType TestingSQLUtil::ExecuteSQLQueryWithOptimizer( bind_node_visitor.BindNameToNode(parsed_stmt->GetStatement(0)); auto plan = optimizer->BuildPelotonPlanTree(parsed_stmt, txn); - txn_manager.CommitTransaction(txn); tuple_descriptor = traffic_cop_.GenerateTupleDescriptor(parsed_stmt->GetStatement(0)); auto result_format = std::vector(tuple_descriptor.size(), 0);