From 273d1ec32d4dd2bc3f5dd645269dcdfb54989a24 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 24 Mar 2018 17:21:05 -0400 Subject: [PATCH 01/85] check code path --- src/catalog/abstract_catalog.cpp | 2 +- src/catalog/table_catalog.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 7cfb316a74f..64315a29742 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -221,7 +221,7 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, planner::SeqScanPlan seq_scan_node(catalog_table_, predicate, column_offsets); executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get()); - + LOG_TRACE("Excecute seq scan"); // Execute seq_scan_executor.Init(); std::unique_ptr>> diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 14929d873ee..2a93e916b73 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -415,7 +415,7 @@ std::shared_ptr TableCatalog::GetTableObject( values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithSeqScan(column_ids, index_offset, values, txn); if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { auto table_object = From 3981f21ab43fc3eb8d45396679cd17e2831ea3e1 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sun, 25 Mar 2018 11:30:56 -0400 Subject: [PATCH 02/85] add in predicate --- src/catalog/table_catalog.cpp | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 2a93e916b73..6bf8783e74d 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -21,6 +21,10 @@ #include "storage/data_table.h" #include "type/value_factory.h" +#include "common/internal_types.h" +#include "expression/abstract_expression.h" +#include "expression/expression_util.h" + namespace peloton { namespace catalog { @@ -415,7 +419,7 @@ std::shared_ptr TableCatalog::GetTableObject( values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); auto result_tiles = - GetResultWithSeqScan(column_ids, index_offset, values, txn); + GetResultWithIndexScan(column_ids, index_offset, values, txn); if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { auto table_object = @@ -465,6 +469,32 @@ std::shared_ptr TableCatalog::GetTableObject( type::ValueFactory::GetVarcharValue(table_name, nullptr).Copy()); values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); + // need the predicate for the seq scan (conjunction) + // table_name == table_name and database_oid need to be same + // only need to get the logical tiles that wrap oid, name, db_oid + expression::AbstractExpression *table_name_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeID::VARCHAR, 0, 1); + expression::AbstractExpression *table_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarCharValue(table_name, nullptr).Copy()); + expression::AbstractExpression *table_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, table_name_expr, + table_name_const_expr); + + expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeID::INTEGER, 0, 2); + expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, + db_oid_const_expr); + + expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, table_name_equality_expr, db_oid_equality_expr); + LOG_TRACE(predicate->GetInfo()); + // change this to seq plan + // ceate predicate refering to seq_scan_test.cpp auto result_tiles = GetResultWithIndexScan(column_ids, index_offset, values, txn); From 34d05ef6ce2480acda70bbc46faa5645a2b8a840 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sun, 25 Mar 2018 14:07:26 -0400 Subject: [PATCH 03/85] fix --- src/catalog/table_catalog.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 6bf8783e74d..23e2d3f756a 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -473,16 +473,16 @@ std::shared_ptr TableCatalog::GetTableObject( // table_name == table_name and database_oid need to be same // only need to get the logical tiles that wrap oid, name, db_oid expression::AbstractExpression *table_name_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeID::VARCHAR, 0, 1); + type::TypeId::VARCHAR, 0, ColumnId::TABLE_NAME); expression::AbstractExpression *table_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetVarCharValue(table_name, nullptr).Copy()); + type::ValueFactory::GetVarcharValue(table_name, nullptr).Copy()); expression::AbstractExpression *table_name_equality_expr = expression::ExpressionUtil::ComparisonFactory( ExpressionType::COMPARE_EQUAL, table_name_expr, table_name_const_expr); expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeID::INTEGER, 0, 2); + type::TypeId::INTEGER, 0, ColumnId::DATABASE_OID); expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(database_oid).Copy()); expression::AbstractExpression *db_oid_equality_expr = From 4d0a9fbb681c69a7f1e8e7edac861728975e443b Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sun, 25 Mar 2018 14:24:11 -0400 Subject: [PATCH 04/85] enable debug --- src/catalog/table_catalog.cpp | 10 ++++++---- src/include/common/logger.h | 2 +- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 23e2d3f756a..4f3ea3a00c0 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -492,6 +492,9 @@ std::shared_ptr TableCatalog::GetTableObject( expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( ExpressionType::CONJUNCTION_AND, table_name_equality_expr, db_oid_equality_expr); + + + predicate->GetInfo(); LOG_TRACE(predicate->GetInfo()); // change this to seq plan // ceate predicate refering to seq_scan_test.cpp @@ -500,17 +503,16 @@ std::shared_ptr TableCatalog::GetTableObject( if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { auto table_object = - std::make_shared((*result_tiles)[0].get(), txn); + std::make_shared((*result_tiles)[0].get(), txn); // insert into cache auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( - table_object->GetDatabaseOid(), txn); + table_object->GetDatabaseOid(), txn); PL_ASSERT(database_object); bool success = database_object->InsertTableObject(table_object); PL_ASSERT(success == true); - (void)success; + (void) success; return table_object; } - // return empty object if not found return nullptr; } diff --git a/src/include/common/logger.h b/src/include/common/logger.h index 0e912ca21c2..5e546785109 100644 --- a/src/include/common/logger.h +++ b/src/include/common/logger.h @@ -54,7 +54,7 @@ namespace peloton { // given.") #ifndef NDEBUG //#pragma message("LOG_LEVEL_DEBUG is used instead as DEBUG option is on.") -#define LOG_LEVEL LOG_LEVEL_DEBUG +#define LOG_LEVEL LOG_LEVEL_TRACE #else //#pragma message("LOG_LEVEL_WARN is used instead as DEBUG option is off.") #define LOG_LEVEL LOG_LEVEL_INFO From c60b5baee9292516107d288adec76c1d74d0cfb8 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sun, 25 Mar 2018 15:01:39 -0400 Subject: [PATCH 05/85] enable debug logger --- src/catalog/table_catalog.cpp | 2 +- src/include/common/logger.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 4f3ea3a00c0..ba16edd81de 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -495,7 +495,7 @@ std::shared_ptr TableCatalog::GetTableObject( predicate->GetInfo(); - LOG_TRACE(predicate->GetInfo()); + LOG_DEBUG("Get table: %s", predicate->GetInfo().c_str()); // change this to seq plan // ceate predicate refering to seq_scan_test.cpp auto result_tiles = diff --git a/src/include/common/logger.h b/src/include/common/logger.h index 5e546785109..0e912ca21c2 100644 --- a/src/include/common/logger.h +++ b/src/include/common/logger.h @@ -54,7 +54,7 @@ namespace peloton { // given.") #ifndef NDEBUG //#pragma message("LOG_LEVEL_DEBUG is used instead as DEBUG option is on.") -#define LOG_LEVEL LOG_LEVEL_TRACE +#define LOG_LEVEL LOG_LEVEL_DEBUG #else //#pragma message("LOG_LEVEL_WARN is used instead as DEBUG option is off.") #define LOG_LEVEL LOG_LEVEL_INFO From f615a499d3b4de60dc4350d7b8b49fa9702f5074 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sun, 25 Mar 2018 16:07:29 -0400 Subject: [PATCH 06/85] use seq scan for get table --- src/catalog/table_catalog.cpp | 6 +++--- test/catalog/catalog_test.cpp | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index ba16edd81de..c71888e8880 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -495,11 +495,11 @@ std::shared_ptr TableCatalog::GetTableObject( predicate->GetInfo(); - LOG_DEBUG("Get table: %s", predicate->GetInfo().c_str()); - // change this to seq plan + LOG_DEBUG("Get table: %s", predicate->GetInfo().c_str()); +// change this to seq plan // ceate predicate refering to seq_scan_test.cpp auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + GetResultWithSeqScan(column_ids, predicate, txn); if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { auto table_object = diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index f9e8ec00c8c..d74708e20f3 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -185,7 +185,7 @@ TEST_F(CatalogTests, TableObject) { txn_manager.CommitTransaction(txn); } -TEST_F(CatalogTests, DroppingTable) { +/*TEST_F(CatalogTests, DroppingTable) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); @@ -254,7 +254,7 @@ TEST_F(CatalogTests, DroppingDatabase) { TEST_F(CatalogTests, DroppingCatalog) { auto catalog = catalog::Catalog::GetInstance(); EXPECT_NE(nullptr, catalog); -} +}*/ } // namespace test } // namespace peloton From 967c72a1a020c4276f78f9231a5c0946e02c1043 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Thu, 29 Mar 2018 14:40:09 -0400 Subject: [PATCH 07/85] test compile --- src/catalog/abstract_catalog.cpp | 52 +++++++++++++++++++------- src/catalog/table_catalog.cpp | 31 ++++++++------- src/include/catalog/abstract_catalog.h | 6 ++- 3 files changed, 61 insertions(+), 28 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 64315a29742..9ec9736f262 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -10,6 +10,9 @@ // //===----------------------------------------------------------------------===// +#include +#include +#include "codegen/testing_codegen_util.h" #include "catalog/abstract_catalog.h" #include "common/statement.h" @@ -209,7 +212,7 @@ AbstractCatalog::GetResultWithIndexScan( * * @return Unique pointer of vector of logical tiles */ -std::unique_ptr>> +const std::vector& AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, concurrency::TransactionContext *txn) { @@ -219,20 +222,43 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, std::unique_ptr context( new executor::ExecutorContext(txn)); - planner::SeqScanPlan seq_scan_node(catalog_table_, predicate, column_offsets); - executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get()); - LOG_TRACE("Excecute seq scan"); - // Execute - seq_scan_executor.Init(); - std::unique_ptr>> - result_tiles(new std::vector>()); + auto seq_scan_plan = std::shared_ptr(new planner::SeqScanPlan( + catalog_table_, predicate, column_offsets)); + planner::BindingContext scan_context; + seq_scan_plan->PerformBinding(scan_context); - while (seq_scan_executor.Execute()) { - result_tiles->push_back( - std::unique_ptr(seq_scan_executor.GetOutput())); - } + codegen::BufferingConsumer buffer{column_offsets, scan_context}; +// bool cached; - return result_tiles; + std::unique_ptr executor_context( + new executor::ExecutorContext(txn, codegen::QueryParameters(*seq_scan_plan, {}))); + + // compile + codegen::Query *query = nullptr; + codegen::QueryCompiler compiler; + auto compiled_query = compiler.Compile(*seq_scan_plan, executor_context->GetParams().GetQueryParametersMap(), buffer); + query = compiled_query.get(); + + //Execute the query in a synchronize fashion + peloton::test::PelotonCodeGenTest::ExecuteSync(*query, std::move(executor_context), buffer); + // what about this + //query->Execute(std::move(executor_context), buffer, func); + + +// planner::SeqScanPlan seq_scan_node(catalog_table_, predicate, column_offsets); +// executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get()); +// LOG_TRACE("Excecute seq scan"); +// // Execute +// seq_scan_executor.Init(); +// std::unique_ptr>> +// result_tiles(new std::vector>()); +// +// while (seq_scan_executor.Execute()) { +// result_tiles->push_back( +// std::unique_ptr(seq_scan_executor.GetOutput())); +// } + + return buffer.GetOutputTuples(); } /*@brief Add index on catalog table diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index c71888e8880..be94b209d4e 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -19,6 +19,7 @@ #include "catalog/column_catalog.h" #include "concurrency/transaction_context.h" #include "storage/data_table.h" +#include "codegen/buffering_consumer.h" #include "type/value_factory.h" #include "common/internal_types.h" @@ -454,11 +455,11 @@ std::shared_ptr TableCatalog::GetTableObject( 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); - if (table_object) return table_object; - } +// auto database_object = txn->catalog_cache.GetDatabaseObject(database_oid); +// if (database_object) { +// auto table_object = database_object->GetTableObject(table_name, true); +// if (table_object) return table_object; +// } // cache miss, get from pg_table std::vector column_ids(all_column_ids); @@ -498,19 +499,21 @@ std::shared_ptr TableCatalog::GetTableObject( LOG_DEBUG("Get table: %s", predicate->GetInfo().c_str()); // change this to seq plan // ceate predicate refering to seq_scan_test.cpp - auto result_tiles = + const std::vector &result_tuples = GetResultWithSeqScan(column_ids, predicate, txn); - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { + if (result_tuples.size() == 1) { auto table_object = - std::make_shared((*result_tiles)[0].get(), txn); + std::make_shared(result_tuples[0].GetValue(0), txn); + // insert into cache - auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( - table_object->GetDatabaseOid(), txn); - PL_ASSERT(database_object); - bool success = database_object->InsertTableObject(table_object); - PL_ASSERT(success == true); - (void) success; +// auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( +// table_object->GetDatabaseOid(), txn); +// PL_ASSERT(database_object); +// bool success = database_object->InsertTableObject(table_object); +// PL_ASSERT(success == true); +// (void) success; + return table_object; } // return empty object if not found diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index 9acf67773b9..7b71d00a7c9 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -31,6 +31,10 @@ namespace expression { class AbstractExpression; } +namespace codegen { +class WrappedTuple; +} + namespace storage { class Database; class DataTable; @@ -67,7 +71,7 @@ class AbstractCatalog { std::vector values, concurrency::TransactionContext *txn) const; - std::unique_ptr>> + const std::vector& GetResultWithSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, concurrency::TransactionContext *txn); From bb728967e174bb5f45d718d53633db827f853f42 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Thu, 29 Mar 2018 14:45:33 -0400 Subject: [PATCH 08/85] fix unused --- src/catalog/table_catalog.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index be94b209d4e..2f135059c92 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -463,12 +463,12 @@ 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 - std::vector values; - values.push_back( - type::ValueFactory::GetVarcharValue(table_name, nullptr).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); +// oid_t index_offset = +// IndexId::SKEY_TABLE_NAME; // Index of table_name & database_oid +// std::vector values; +// values.push_back( +// type::ValueFactory::GetVarcharValue(table_name, nullptr).Copy()); +// values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); // need the predicate for the seq scan (conjunction) // table_name == table_name and database_oid need to be same From 08916eddf09687fca8ecf3854e31d7160644df3a Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Thu, 29 Mar 2018 14:51:16 -0400 Subject: [PATCH 09/85] write table object constructor --- src/catalog/table_catalog.cpp | 16 ++++++++++++++++ src/include/catalog/table_catalog.h | 1 + 2 files changed, 17 insertions(+) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 2f135059c92..aeee5b8e6e2 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -46,6 +46,22 @@ TableCatalogObject::TableCatalogObject(executor::LogicalTile *tile, valid_column_objects(false), txn(txn) {} +TableCatalogObject::TableCatalogObject(codegen::WrappedTuple wrapped_tuple, + concurrency::TransactionContext *txn) + : table_oid(wrapped_tuple.GetValue(TableCatalog::ColumnId::TABLE_OID) + .GetAs()), + table_name(wrapped_tuple.GetValue(TableCatalog::ColumnId::TABLE_NAME) + .ToString()), + database_oid(wrapped_tuple.GetValue(TableCatalog::ColumnId::DATABASE_OID) + .GetAs()), + index_objects(), + index_names(), + valid_index_objects(false), + column_objects(), + column_names(), + valid_column_objects(false), + txn(txn) {} + /* @brief insert index catalog object into cache * @param index_object * @return false if index_name already exists in cache diff --git a/src/include/catalog/table_catalog.h b/src/include/catalog/table_catalog.h index 3ef4668d5ca..02fff38e0bf 100644 --- a/src/include/catalog/table_catalog.h +++ b/src/include/catalog/table_catalog.h @@ -47,6 +47,7 @@ class TableCatalogObject { public: TableCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn, int tupleId = 0); + TableCatalogObject(codegen::WrappedTuple wrapped_tuple, concurrency::TransactionContext *txn); public: // Get indexes From 2784ad6a694b30d4fd976d9625e43cd3ec417ed3 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Thu, 29 Mar 2018 14:52:47 -0400 Subject: [PATCH 10/85] fix bug --- src/catalog/table_catalog.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index aeee5b8e6e2..4c7d677a7cc 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -520,7 +520,7 @@ std::shared_ptr TableCatalog::GetTableObject( if (result_tuples.size() == 1) { auto table_object = - std::make_shared(result_tuples[0].GetValue(0), txn); + std::make_shared(result_tuples[0], txn); // insert into cache // auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( From 5fd930ecfad16ec7282034c54ef9d127a16caa85 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Thu, 29 Mar 2018 15:28:50 -0400 Subject: [PATCH 11/85] query execute --- src/catalog/abstract_catalog.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 9ec9736f262..bfd3c6aa9ee 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -10,8 +10,8 @@ // //===----------------------------------------------------------------------===// -#include -#include +#include "codegen/buffering_consumer.h" +#include "common/internal_types.h" #include "codegen/testing_codegen_util.h" #include "catalog/abstract_catalog.h" @@ -239,10 +239,10 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, auto compiled_query = compiler.Compile(*seq_scan_plan, executor_context->GetParams().GetQueryParametersMap(), buffer); query = compiled_query.get(); - //Execute the query in a synchronize fashion - peloton::test::PelotonCodeGenTest::ExecuteSync(*query, std::move(executor_context), buffer); + // Execute the query in a synchronize fashion + // peloton::test::PelotonCodeGenTest::ExecuteSync(*query, std::move(executor_context), buffer); // what about this - //query->Execute(std::move(executor_context), buffer, func); + query->Execute(std::move(executor_context), buffer, nullptr); // planner::SeqScanPlan seq_scan_node(catalog_table_, predicate, column_offsets); From 2352d6860f45f08b2c151a5e613a45cd96c62300 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Thu, 29 Mar 2018 16:05:09 -0400 Subject: [PATCH 12/85] fix bug --- src/catalog/abstract_catalog.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index bfd3c6aa9ee..9bd19ee153b 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -10,9 +10,9 @@ // //===----------------------------------------------------------------------===// +#include "executor/plan_executor.h" #include "codegen/buffering_consumer.h" #include "common/internal_types.h" -#include "codegen/testing_codegen_util.h" #include "catalog/abstract_catalog.h" #include "common/statement.h" @@ -242,7 +242,7 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, // Execute the query in a synchronize fashion // peloton::test::PelotonCodeGenTest::ExecuteSync(*query, std::move(executor_context), buffer); // what about this - query->Execute(std::move(executor_context), buffer, nullptr); + query->Execute(std::move(executor_context), buffer, [](executor::ExecutionResult result){return result;}); // planner::SeqScanPlan seq_scan_node(catalog_table_, predicate, column_offsets); From 22f8dc93808ce1c4b1e70fd05e64e99819a6793a Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Fri, 6 Apr 2018 20:40:50 -0400 Subject: [PATCH 13/85] fix bug --- src/catalog/abstract_catalog.cpp | 8 ++------ src/catalog/table_catalog.cpp | 19 +++++++++---------- src/include/catalog/abstract_catalog.h | 1 + test/catalog/catalog_test.cpp | 4 ++-- 4 files changed, 14 insertions(+), 18 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 9bd19ee153b..e311e30cc61 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -10,11 +10,10 @@ // //===----------------------------------------------------------------------===// +#include "catalog/abstract_catalog.h" #include "executor/plan_executor.h" #include "codegen/buffering_consumer.h" #include "common/internal_types.h" -#include "catalog/abstract_catalog.h" - #include "common/statement.h" #include "catalog/catalog.h" @@ -219,8 +218,6 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, if (txn == nullptr) throw CatalogException("Scan table requires transaction"); // Sequential scan - std::unique_ptr context( - new executor::ExecutorContext(txn)); auto seq_scan_plan = std::shared_ptr(new planner::SeqScanPlan( catalog_table_, predicate, column_offsets)); @@ -235,8 +232,7 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, // compile codegen::Query *query = nullptr; - codegen::QueryCompiler compiler; - auto compiled_query = compiler.Compile(*seq_scan_plan, executor_context->GetParams().GetQueryParametersMap(), buffer); + auto compiled_query = codegen::QueryCompiler().Compile(*seq_scan_plan, executor_context->GetParams().GetQueryParametersMap(), buffer); query = compiled_query.get(); // Execute the query in a synchronize fashion diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 4c7d677a7cc..ae475887771 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -511,24 +511,23 @@ std::shared_ptr TableCatalog::GetTableObject( ExpressionType::CONJUNCTION_AND, table_name_equality_expr, db_oid_equality_expr); - predicate->GetInfo(); - LOG_DEBUG("Get table: %s", predicate->GetInfo().c_str()); -// change this to seq plan + LOG_DEBUG("Get table: %s", predicate->GetInfo().c_str()); + // change this to seq plan // ceate predicate refering to seq_scan_test.cpp const std::vector &result_tuples = GetResultWithSeqScan(column_ids, predicate, txn); - + LOG_DEBUG("Result size: %lu", result_tuples.size()); if (result_tuples.size() == 1) { auto table_object = std::make_shared(result_tuples[0], txn); // insert into cache -// auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( -// table_object->GetDatabaseOid(), txn); -// PL_ASSERT(database_object); -// bool success = database_object->InsertTableObject(table_object); -// PL_ASSERT(success == true); -// (void) success; + auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( + table_object->GetDatabaseOid(), txn); + PL_ASSERT(database_object); + bool success = database_object->InsertTableObject(table_object); + PL_ASSERT(success == true); + (void) success; return table_object; } diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index 7b71d00a7c9..c64b8455626 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -80,6 +80,7 @@ class AbstractCatalog { const std::string &index_name, IndexConstraintType index_constraint); + //===--------------------------------------------------------------------===// // Members //===--------------------------------------------------------------------===// diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index d74708e20f3..f9e8ec00c8c 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -185,7 +185,7 @@ TEST_F(CatalogTests, TableObject) { txn_manager.CommitTransaction(txn); } -/*TEST_F(CatalogTests, DroppingTable) { +TEST_F(CatalogTests, DroppingTable) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); auto catalog = catalog::Catalog::GetInstance(); @@ -254,7 +254,7 @@ TEST_F(CatalogTests, DroppingDatabase) { TEST_F(CatalogTests, DroppingCatalog) { auto catalog = catalog::Catalog::GetInstance(); EXPECT_NE(nullptr, catalog); -}*/ +} } // namespace test } // namespace peloton From 8de72bc42c487bf3d034251f05c554640ebb9d3a Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Fri, 6 Apr 2018 20:50:17 -0400 Subject: [PATCH 14/85] fix bug --- src/catalog/abstract_catalog.cpp | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index e311e30cc61..a8ba677f97b 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -219,20 +219,19 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, // Sequential scan - auto seq_scan_plan = std::shared_ptr(new planner::SeqScanPlan( - catalog_table_, predicate, column_offsets)); + planner::SeqScanPlan seq_scan_plan{catalog_table_, predicate, column_offsets}; planner::BindingContext scan_context; - seq_scan_plan->PerformBinding(scan_context); + seq_scan_plan.PerformBinding(scan_context); codegen::BufferingConsumer buffer{column_offsets, scan_context}; // bool cached; - + codegen::QueryParameters parameters(seq_scan_plan, {}); std::unique_ptr executor_context( - new executor::ExecutorContext(txn, codegen::QueryParameters(*seq_scan_plan, {}))); + new executor::ExecutorContext(txn, std::move(parameters))); // compile codegen::Query *query = nullptr; - auto compiled_query = codegen::QueryCompiler().Compile(*seq_scan_plan, executor_context->GetParams().GetQueryParametersMap(), buffer); + auto compiled_query = codegen::QueryCompiler().Compile(seq_scan_plan, parameters.GetQueryParametersMap(), buffer); query = compiled_query.get(); // Execute the query in a synchronize fashion From 52e7fc9f0ee0efd597dcec609accf24ef353c507 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Fri, 6 Apr 2018 21:15:35 -0400 Subject: [PATCH 15/85] fix query param --- src/catalog/abstract_catalog.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index a8ba677f97b..63a6e5a83aa 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -231,7 +231,7 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, // compile codegen::Query *query = nullptr; - auto compiled_query = codegen::QueryCompiler().Compile(seq_scan_plan, parameters.GetQueryParametersMap(), buffer); + auto compiled_query = codegen::QueryCompiler().Compile(seq_scan_plan, executor_context->GetParams().GetQueryParametersMap(), buffer); query = compiled_query.get(); // Execute the query in a synchronize fashion From fa20fe13d2adc6a8c4ce8f1519b4cddbf167ccbe Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Fri, 6 Apr 2018 21:52:35 -0400 Subject: [PATCH 16/85] print wrapped tuple --- src/catalog/table_catalog.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index ae475887771..cce3baf69bb 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -518,6 +518,7 @@ std::shared_ptr TableCatalog::GetTableObject( GetResultWithSeqScan(column_ids, predicate, txn); LOG_DEBUG("Result size: %lu", result_tuples.size()); if (result_tuples.size() == 1) { + LOG_DEBUG("Result: %s", result_tuples[0].GetInfo().c_str()); auto table_object = std::make_shared(result_tuples[0], txn); From 7be27d44655d4eed9e831a1d28fc64546d4593f1 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Fri, 6 Apr 2018 22:12:32 -0400 Subject: [PATCH 17/85] fix bug --- src/catalog/table_catalog.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index cce3baf69bb..a64711c38f4 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -511,14 +511,13 @@ std::shared_ptr TableCatalog::GetTableObject( ExpressionType::CONJUNCTION_AND, table_name_equality_expr, db_oid_equality_expr); - LOG_DEBUG("Get table: %s", predicate->GetInfo().c_str()); + // LOG_DEBUG("Get table: %s", predicate->GetInfo().c_str()); // change this to seq plan // ceate predicate refering to seq_scan_test.cpp - const std::vector &result_tuples = + std::vector result_tuples = GetResultWithSeqScan(column_ids, predicate, txn); LOG_DEBUG("Result size: %lu", result_tuples.size()); if (result_tuples.size() == 1) { - LOG_DEBUG("Result: %s", result_tuples[0].GetInfo().c_str()); auto table_object = std::make_shared(result_tuples[0], txn); From b69c801895dd6f5c027f12dcd0edb720f4dcb4eb Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 15:09:53 -0400 Subject: [PATCH 18/85] cache --- src/catalog/abstract_catalog.cpp | 12 +++++++++--- src/include/catalog/abstract_catalog.h | 1 + 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 63a6e5a83aa..210a6a5f7de 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -229,10 +229,16 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, std::unique_ptr executor_context( new executor::ExecutorContext(txn, std::move(parameters))); + auto plan_ptr = std::shared_ptr(&seq_scan_plan); + // compile - codegen::Query *query = nullptr; - auto compiled_query = codegen::QueryCompiler().Compile(seq_scan_plan, executor_context->GetParams().GetQueryParametersMap(), buffer); - query = compiled_query.get(); + codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); + if (query == nullptr) { + auto compiled_query = codegen::QueryCompiler().Compile(seq_scan_plan, executor_context->GetParams().GetQueryParametersMap(), buffer); + query = compiled_query.get(); + codegen::QueryCache::Instance().Add(plan_ptr, std::move(compiled_query)); + //query = codegen::QueryCache::Instance().Find(plan_ptr); + } // Execute the query in a synchronize fashion // peloton::test::PelotonCodeGenTest::ExecuteSync(*query, std::move(executor_context), buffer); diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index c64b8455626..47c055732e5 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -16,6 +16,7 @@ #include "catalog/catalog_defaults.h" #include "catalog/schema.h" +#include "codegen/query_cache.h" namespace peloton { From fd922902524e15bf24d0db831a8b317d7a0ba7df Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 15:17:57 -0400 Subject: [PATCH 19/85] cache --- src/catalog/abstract_catalog.cpp | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 210a6a5f7de..ed8370a26c4 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -219,22 +219,24 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, // Sequential scan - planner::SeqScanPlan seq_scan_plan{catalog_table_, predicate, column_offsets}; + auto plan_ptr = std::shared_ptr( + new planner::SeqScanPlan(catalog_table_, predicate, column_offsets)); planner::BindingContext scan_context; - seq_scan_plan.PerformBinding(scan_context); + plan_ptr->PerformBinding(scan_context); codegen::BufferingConsumer buffer{column_offsets, scan_context}; // bool cached; - codegen::QueryParameters parameters(seq_scan_plan, {}); + codegen::QueryParameters parameters(*plan_ptr, {}); std::unique_ptr executor_context( new executor::ExecutorContext(txn, std::move(parameters))); - auto plan_ptr = std::shared_ptr(&seq_scan_plan); + // compile codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); if (query == nullptr) { - auto compiled_query = codegen::QueryCompiler().Compile(seq_scan_plan, executor_context->GetParams().GetQueryParametersMap(), buffer); + auto compiled_query = codegen::QueryCompiler().Compile( + *plan_ptr, executor_context->GetParams().GetQueryParametersMap(), buffer); query = compiled_query.get(); codegen::QueryCache::Instance().Add(plan_ptr, std::move(compiled_query)); //query = codegen::QueryCache::Instance().Find(plan_ptr); From 35b4c6de4f51bb2430a321021abd7f592bb1669e Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 7 Apr 2018 15:59:29 -0400 Subject: [PATCH 20/85] fix try --- src/catalog/abstract_catalog.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index ed8370a26c4..86428dbbe29 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -219,13 +219,14 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, // Sequential scan - auto plan_ptr = std::shared_ptr( - new planner::SeqScanPlan(catalog_table_, predicate, column_offsets)); + std::shared_ptr plan_ptr{new planner::SeqScanPlan{ + catalog_table_, predicate, column_offsets}}; planner::BindingContext scan_context; - plan_ptr->PerformBinding(scan_context); + plan_ptr->PerformBinding(scan_context); codegen::BufferingConsumer buffer{column_offsets, scan_context}; // bool cached; + codegen::QueryParameters parameters(*plan_ptr, {}); std::unique_ptr executor_context( new executor::ExecutorContext(txn, std::move(parameters))); From 78bfc9219302839c6a7225797f0f88d84f54c65a Mon Sep 17 00:00:00 2001 From: nickwang Date: Sun, 8 Apr 2018 06:49:29 +0800 Subject: [PATCH 21/85] fix shared pointer --- src/catalog/abstract_catalog.cpp | 26 +++++++++++++------------- src/include/catalog/abstract_catalog.h | 3 ++- 2 files changed, 15 insertions(+), 14 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 86428dbbe29..8a62ef3e735 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -211,7 +211,7 @@ AbstractCatalog::GetResultWithIndexScan( * * @return Unique pointer of vector of logical tiles */ -const std::vector& +std::vector AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, concurrency::TransactionContext *txn) { @@ -219,36 +219,36 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, // Sequential scan - std::shared_ptr plan_ptr{new planner::SeqScanPlan{ - catalog_table_, predicate, column_offsets}}; + std::shared_ptr plan_ptr(new planner::SeqScanPlan( + catalog_table_, predicate, column_offsets)); planner::BindingContext scan_context; plan_ptr->PerformBinding(scan_context); codegen::BufferingConsumer buffer{column_offsets, scan_context}; -// bool cached; + bool cached; codegen::QueryParameters parameters(*plan_ptr, {}); std::unique_ptr executor_context( new executor::ExecutorContext(txn, std::move(parameters))); - - // compile - codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); - if (query == nullptr) { - auto compiled_query = codegen::QueryCompiler().Compile( + // codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); + codegen::Query *query = nullptr; + std::unique_ptr compiled_query(nullptr); + cached = (query == nullptr); + LOG_DEBUG("cache %d", cached); + if (cached) { + compiled_query = codegen::QueryCompiler().Compile( *plan_ptr, executor_context->GetParams().GetQueryParametersMap(), buffer); query = compiled_query.get(); - codegen::QueryCache::Instance().Add(plan_ptr, std::move(compiled_query)); + // codegen::QueryCache::Instance().Add(plan_ptr, std::move(compiled_query)); //query = codegen::QueryCache::Instance().Find(plan_ptr); } - // Execute the query in a synchronize fashion // peloton::test::PelotonCodeGenTest::ExecuteSync(*query, std::move(executor_context), buffer); // what about this query->Execute(std::move(executor_context), buffer, [](executor::ExecutionResult result){return result;}); - // planner::SeqScanPlan seq_scan_node(catalog_table_, predicate, column_offsets); // executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get()); // LOG_TRACE("Excecute seq scan"); @@ -261,7 +261,7 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, // result_tiles->push_back( // std::unique_ptr(seq_scan_executor.GetOutput())); // } - + LOG_DEBUG("inside result size: %lu", buffer.GetOutputTuples().size()); return buffer.GetOutputTuples(); } diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index 47c055732e5..eaa5fe1006d 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -17,6 +17,7 @@ #include "catalog/catalog_defaults.h" #include "catalog/schema.h" #include "codegen/query_cache.h" +#include "codegen/query.h" namespace peloton { @@ -72,7 +73,7 @@ class AbstractCatalog { std::vector values, concurrency::TransactionContext *txn) const; - const std::vector& + std::vector GetResultWithSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, concurrency::TransactionContext *txn); From d6088ccd4975a40ec037f2aade785110d2607093 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 7 Apr 2018 18:59:04 -0400 Subject: [PATCH 22/85] clean up --- src/catalog/abstract_catalog.cpp | 27 +++++---------------------- 1 file changed, 5 insertions(+), 22 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 8a62ef3e735..305946c7d75 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -219,8 +219,7 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, // Sequential scan - std::shared_ptr plan_ptr(new planner::SeqScanPlan( - catalog_table_, predicate, column_offsets)); + auto plan_ptr = std::make_shared(catalog_table_, predicate, column_offsets); planner::BindingContext scan_context; plan_ptr->PerformBinding(scan_context); @@ -233,35 +232,19 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, // compile // codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); - codegen::Query *query = nullptr; + codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); std::unique_ptr compiled_query(nullptr); - cached = (query == nullptr); + cached = (query != nullptr); LOG_DEBUG("cache %d", cached); - if (cached) { + if (!cached) { compiled_query = codegen::QueryCompiler().Compile( *plan_ptr, executor_context->GetParams().GetQueryParametersMap(), buffer); query = compiled_query.get(); - // codegen::QueryCache::Instance().Add(plan_ptr, std::move(compiled_query)); + codegen::QueryCache::Instance().Add(plan_ptr, std::move(compiled_query)); //query = codegen::QueryCache::Instance().Find(plan_ptr); } - // Execute the query in a synchronize fashion - // peloton::test::PelotonCodeGenTest::ExecuteSync(*query, std::move(executor_context), buffer); - // what about this query->Execute(std::move(executor_context), buffer, [](executor::ExecutionResult result){return result;}); -// planner::SeqScanPlan seq_scan_node(catalog_table_, predicate, column_offsets); -// executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get()); -// LOG_TRACE("Excecute seq scan"); -// // Execute -// seq_scan_executor.Init(); -// std::unique_ptr>> -// result_tiles(new std::vector>()); -// -// while (seq_scan_executor.Execute()) { -// result_tiles->push_back( -// std::unique_ptr(seq_scan_executor.GetOutput())); -// } - LOG_DEBUG("inside result size: %lu", buffer.GetOutputTuples().size()); return buffer.GetOutputTuples(); } From b1d6b98b5bd32258000a1be12d7f934e367fcad4 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 19:47:48 -0400 Subject: [PATCH 23/85] GetDatabaseObject --- src/catalog/abstract_catalog.cpp | 2 +- src/catalog/table_catalog.cpp | 33 ++++++++++++++++++++++++++------ 2 files changed, 28 insertions(+), 7 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 305946c7d75..5bd8b765d24 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -240,7 +240,7 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, compiled_query = codegen::QueryCompiler().Compile( *plan_ptr, executor_context->GetParams().GetQueryParametersMap(), buffer); query = compiled_query.get(); - codegen::QueryCache::Instance().Add(plan_ptr, std::move(compiled_query)); + codegen::QueryCache::Instance().Add(plan_ptr, std::move(compiled_query)); //query = codegen::QueryCache::Instance().Find(plan_ptr); } query->Execute(std::move(executor_context), buffer, [](executor::ExecutionResult result){return result;}); diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index a64711c38f4..69fce4c1108 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -556,19 +556,40 @@ TableCatalog::GetTableObjects(oid_t database_oid, // cache miss, get from pg_table std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::SKEY_DATABASE_OID; // Index of database_oid - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); + //oid_t index_offset = IndexId::SKEY_DATABASE_OID; // Index of database_oid + //std::vector values; + //values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); + + expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, + db_oid_const_expr); - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + //auto result_tiles = + // GetResultWithIndexScan(column_ids, index_offset, values, txn); - for (auto &tile : (*result_tiles)) { + expression::AbstractExpression *predicate = db_oid_equality_expr; + std::vector result_tuples = + GetResultWithSeqScan(column_ids, predicate, txn); + + /*for (auto &tile : (*result_tiles)) { for (auto tuple_id : *tile) { auto table_object = std::make_shared(tile.get(), txn, tuple_id); database_object->InsertTableObject(table_object); } + }*/ + + for (auto tuple : result_tuples) { + + auto table_object = + std::make_shared(tuple, txn); + database_object->InsertTableObject(table_object); + } database_object->SetValidTableObjects(true); From 11ab2e6909af288bb64ed31d8c36603c6531e55b Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 7 Apr 2018 19:54:09 -0400 Subject: [PATCH 24/85] performance test --- src/catalog/abstract_catalog.cpp | 45 ++++++++++++++++--- src/catalog/table_catalog.cpp | 2 +- src/include/catalog/abstract_catalog.h | 7 ++- test/catalog/catalog_test.cpp | 61 +++++++++++++++----------- 4 files changed, 83 insertions(+), 32 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 305946c7d75..45a3f7b6b76 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -211,18 +211,53 @@ AbstractCatalog::GetResultWithIndexScan( * * @return Unique pointer of vector of logical tiles */ -std::vector +std::unique_ptr>> AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, concurrency::TransactionContext *txn) { if (txn == nullptr) throw CatalogException("Scan table requires transaction"); // Sequential scan + std::unique_ptr context( + new executor::ExecutorContext(txn)); + + planner::SeqScanPlan seq_scan_node(catalog_table_, predicate, column_offsets); + executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get()); + + // Execute + seq_scan_executor.Init(); + std::unique_ptr>> + result_tiles(new std::vector>()); + + while (seq_scan_executor.Execute()) { + result_tiles->push_back( + std::unique_ptr(seq_scan_executor.GetOutput())); + } + + return result_tiles; +} +/*@brief Complied 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 +*/ +std::vector +AbstractCatalog::GetResultWithCompiledSeqScan(std::vector column_offsets, + expression::AbstractExpression *predicate, + concurrency::TransactionContext *txn) { + if (txn == nullptr) throw CatalogException("Scan table requires transaction"); + + // Create sequential scan auto plan_ptr = std::make_shared(catalog_table_, predicate, column_offsets); planner::BindingContext scan_context; plan_ptr->PerformBinding(scan_context); + // Create consumer codegen::BufferingConsumer buffer{column_offsets, scan_context}; bool cached; @@ -230,19 +265,19 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, std::unique_ptr executor_context( new executor::ExecutorContext(txn, std::move(parameters))); - // compile - // codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); + // search for query codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); std::unique_ptr compiled_query(nullptr); cached = (query != nullptr); LOG_DEBUG("cache %d", cached); + // if not cached, compile the query and save it into cache if (!cached) { compiled_query = codegen::QueryCompiler().Compile( *plan_ptr, executor_context->GetParams().GetQueryParametersMap(), buffer); query = compiled_query.get(); - codegen::QueryCache::Instance().Add(plan_ptr, std::move(compiled_query)); - //query = codegen::QueryCache::Instance().Find(plan_ptr); + codegen::QueryCache::Instance().Add(plan_ptr, std::move(compiled_query)); } + query->Execute(std::move(executor_context), buffer, [](executor::ExecutionResult result){return result;}); return buffer.GetOutputTuples(); diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index a64711c38f4..12d0ce799b6 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -515,7 +515,7 @@ std::shared_ptr TableCatalog::GetTableObject( // change this to seq plan // ceate predicate refering to seq_scan_test.cpp std::vector result_tuples = - GetResultWithSeqScan(column_ids, predicate, txn); + GetResultWithCompiledSeqScan(column_ids, predicate, txn); LOG_DEBUG("Result size: %lu", result_tuples.size()); if (result_tuples.size() == 1) { auto table_object = diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index eaa5fe1006d..0c0dd05fdd0 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -73,8 +73,13 @@ class AbstractCatalog { std::vector values, concurrency::TransactionContext *txn) const; + std::unique_ptr>> + AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, + expression::AbstractExpression *predicate, + concurrency::TransactionContext *txn); + std::vector - GetResultWithSeqScan(std::vector column_offsets, + GetResultWithCompiledSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, concurrency::TransactionContext *txn); diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index f9e8ec00c8c..036f1ece038 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -22,6 +22,7 @@ #include "common/logger.h" #include "storage/storage_manager.h" #include "type/ephemeral_pool.h" +#include "common/timer.h" namespace peloton { namespace test { @@ -152,37 +153,47 @@ TEST_F(CatalogTests, CreatingTable) { } TEST_F(CatalogTests, TableObject) { - auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); - auto txn = txn_manager.BeginTransaction(); + double avg_time = 0.0; + int num_iterations = 1000; + Timer> timer; + for(int i=0;iGetTableObject( - "EMP_DB", "department_table", txn); + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); + auto txn = txn_manager.BeginTransaction(); - auto index_objects = table_object->GetIndexObjects(); - auto column_objects = table_object->GetColumnObjects(); + timer.Start(); + auto table_object = catalog::Catalog::GetInstance()->GetTableObject( + "EMP_DB", "department_table", txn); + timer.Stop(); + avg_time += timer.GetDuration(); - EXPECT_EQ(1, index_objects.size()); - EXPECT_EQ(2, column_objects.size()); + auto index_objects = table_object->GetIndexObjects(); + auto column_objects = table_object->GetColumnObjects(); - EXPECT_EQ(table_object->GetTableOid(), column_objects[0]->GetTableOid()); - EXPECT_EQ("id", column_objects[0]->GetColumnName()); - EXPECT_EQ(0, column_objects[0]->GetColumnId()); - EXPECT_EQ(0, column_objects[0]->GetColumnOffset()); - EXPECT_EQ(type::TypeId::INTEGER, column_objects[0]->GetColumnType()); - EXPECT_TRUE(column_objects[0]->IsInlined()); - EXPECT_TRUE(column_objects[0]->IsPrimary()); - EXPECT_FALSE(column_objects[0]->IsNotNull()); + EXPECT_EQ(1, index_objects.size()); + EXPECT_EQ(2, column_objects.size()); - EXPECT_EQ(table_object->GetTableOid(), column_objects[1]->GetTableOid()); - EXPECT_EQ("name", column_objects[1]->GetColumnName()); - EXPECT_EQ(1, column_objects[1]->GetColumnId()); - EXPECT_EQ(4, column_objects[1]->GetColumnOffset()); - EXPECT_EQ(type::TypeId::VARCHAR, column_objects[1]->GetColumnType()); - EXPECT_TRUE(column_objects[1]->IsInlined()); - EXPECT_FALSE(column_objects[1]->IsPrimary()); - EXPECT_FALSE(column_objects[1]->IsNotNull()); + EXPECT_EQ(table_object->GetTableOid(), column_objects[0]->GetTableOid()); + EXPECT_EQ("id", column_objects[0]->GetColumnName()); + EXPECT_EQ(0, column_objects[0]->GetColumnId()); + EXPECT_EQ(0, column_objects[0]->GetColumnOffset()); + EXPECT_EQ(type::TypeId::INTEGER, column_objects[0]->GetColumnType()); + EXPECT_TRUE(column_objects[0]->IsInlined()); + EXPECT_TRUE(column_objects[0]->IsPrimary()); + EXPECT_FALSE(column_objects[0]->IsNotNull()); - txn_manager.CommitTransaction(txn); + EXPECT_EQ(table_object->GetTableOid(), column_objects[1]->GetTableOid()); + EXPECT_EQ("name", column_objects[1]->GetColumnName()); + EXPECT_EQ(1, column_objects[1]->GetColumnId()); + EXPECT_EQ(4, column_objects[1]->GetColumnOffset()); + EXPECT_EQ(type::TypeId::VARCHAR, column_objects[1]->GetColumnType()); + EXPECT_TRUE(column_objects[1]->IsInlined()); + EXPECT_FALSE(column_objects[1]->IsPrimary()); + EXPECT_FALSE(column_objects[1]->IsNotNull()); + + txn_manager.CommitTransaction(txn); + } + LOG_TRACE("Avg time: %.4lf", avg_time / num_iterations); } TEST_F(CatalogTests, DroppingTable) { From 6b3b90e7a5e7b3433b81d0a729fff2ff69465c1c Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 20:00:25 -0400 Subject: [PATCH 25/85] database_catalog --- src/catalog/database_catalog.cpp | 31 +++++++++++++++++++++++++++++++ src/catalog/table_catalog.cpp | 16 ++++++++-------- 2 files changed, 39 insertions(+), 8 deletions(-) diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 43f9885bef6..a39aec4a3e1 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -11,6 +11,7 @@ //===----------------------------------------------------------------------===// #include +#include #include "catalog/database_catalog.h" @@ -287,6 +288,7 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( auto database_object = txn->catalog_cache.GetDatabaseObject(database_oid); if (database_object) return database_object; + /* // cache miss, get from pg_database std::vector column_ids(all_column_ids); oid_t index_offset = IndexId::PRIMARY_KEY; // Index of database_oid @@ -307,6 +309,35 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( } else { LOG_DEBUG("Found %lu database tiles with oid %u", result_tiles->size(), database_oid); + }*/ + + // cache miss, get from pg_database + std::vector column_ids(all_column_ids); + + expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, + db_oid_const_expr); + + expression::AbstractExpression *predicate = db_oid_equality_expr; + std::vector result_tuples = + GetResultWithSeqScan(column_ids, predicate, txn); + + if (result_tuples.size() == 1) { + auto database_object = + std::make_shared(result_tuples[0], txn); + // insert into cache + bool success = txn->catalog_cache.InsertDatabaseObject(database_object); + PL_ASSERT(success == true); + (void)success; + return database_object; + } else { + LOG_DEBUG("Found %lu database tiles with oid %u", result_tuples.size(), + database_oid); } // return empty object if not found diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 69fce4c1108..0ac9b0d8bbd 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -560,14 +560,14 @@ TableCatalog::GetTableObjects(oid_t database_oid, //std::vector values; //values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); - expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::DATABASE_OID); - expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(database_oid).Copy()); - expression::AbstractExpression *db_oid_equality_expr = - expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, db_oid_expr, - db_oid_const_expr); + expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, + db_oid_const_expr); //auto result_tiles = // GetResultWithIndexScan(column_ids, index_offset, values, txn); From f9a0355d7effa73b04cf349323c66b42d50f11b4 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 20:01:52 -0400 Subject: [PATCH 26/85] fix seqscan --- src/catalog/database_catalog.cpp | 2 +- src/catalog/table_catalog.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index a39aec4a3e1..16f3f207f06 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -325,7 +325,7 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( expression::AbstractExpression *predicate = db_oid_equality_expr; std::vector result_tuples = - GetResultWithSeqScan(column_ids, predicate, txn); + GetResultWithCompiledSeqScan(column_ids, predicate, txn); if (result_tuples.size() == 1) { auto database_object = diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 4ca3f76d032..cecbf119d00 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -574,7 +574,7 @@ TableCatalog::GetTableObjects(oid_t database_oid, expression::AbstractExpression *predicate = db_oid_equality_expr; std::vector result_tuples = - GetResultWithSeqScan(column_ids, predicate, txn); + GetResultWithCompiledSeqScan(column_ids, predicate, txn); /*for (auto &tile : (*result_tiles)) { for (auto tuple_id : *tile) { From 0a101feb6e006480b8bb65ef7998671c2c0b9e18 Mon Sep 17 00:00:00 2001 From: nickwang Date: Sun, 8 Apr 2018 08:02:34 +0800 Subject: [PATCH 27/85] fix --- src/include/catalog/abstract_catalog.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index 0c0dd05fdd0..f05290c6448 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -74,7 +74,7 @@ class AbstractCatalog { concurrency::TransactionContext *txn) const; std::unique_ptr>> - AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, + GetResultWithSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, concurrency::TransactionContext *txn); From 5f2c30a1d79d29c76fb814275245c55d9a00402f Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 20:07:17 -0400 Subject: [PATCH 28/85] db_catalog --- src/catalog/database_catalog.cpp | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 16f3f207f06..bcad081c52c 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -357,6 +357,7 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( auto database_object = txn->catalog_cache.GetDatabaseObject(database_name); if (database_object) return database_object; + /* // cache miss, get from pg_database std::vector column_ids(all_column_ids); oid_t index_offset = IndexId::SKEY_DATABASE_NAME; // Index of database_name @@ -377,9 +378,33 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( (void)success; } return database_object; + }*/ + + std::vector column_ids(all_column_ids); + + expression::AbstractExpression *db_name_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::VARCHAR, 0, ColumnId::DATABASE_NAME); + expression::AbstractExpression *db_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(database_name, nullptr).Copy()); + expression::AbstractExpression *table_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_name_expr, + db_name_const_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, table_name_equality_expr, txn); + + if (result_tuples.size() == 1) { + auto database_object = + std::make_shared(result_tuples[0], txn); + // insert into cache + bool success = txn->catalog_cache.InsertDatabaseObject(database_object); + PL_ASSERT(success == true); + (void) success; + return database_object; } - // return empty object if not found + // return empty object if not found return nullptr; } From bcdbd5ef2410b1ed021581455a92133fe5a67144 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 20:08:19 -0400 Subject: [PATCH 29/85] db_catalog --- src/catalog/database_catalog.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index bcad081c52c..f3b6f7a98de 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -386,13 +386,13 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( type::TypeId::VARCHAR, 0, ColumnId::DATABASE_NAME); expression::AbstractExpression *db_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetVarcharValue(database_name, nullptr).Copy()); - expression::AbstractExpression *table_name_equality_expr = + expression::AbstractExpression *db_name_equality_expr = expression::ExpressionUtil::ComparisonFactory( ExpressionType::COMPARE_EQUAL, db_name_expr, db_name_const_expr); std::vector result_tuples = - GetResultWithCompiledSeqScan(column_ids, table_name_equality_expr, txn); + GetResultWithCompiledSeqScan(column_ids, db_name_equality_expr, txn); if (result_tuples.size() == 1) { auto database_object = From 308c124595d37da451974515fce5f2059d58ad62 Mon Sep 17 00:00:00 2001 From: nickwang Date: Sun, 8 Apr 2018 08:10:26 +0800 Subject: [PATCH 30/85] fix bug --- src/catalog/table_catalog.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 86c459b2d1f..46f380d0dc7 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -574,7 +574,7 @@ TableCatalog::GetTableObjects(oid_t database_oid, expression::AbstractExpression *predicate = db_oid_equality_expr; std::vector result_tuples = - GetResultWithSeqScan(column_ids, predicate, txn); + GetResultWithCompiledSeqScan(column_ids, predicate, txn); /*for (auto &tile : (*result_tiles)) { for (auto tuple_id : *tile) { From a4afec2bc1b87288d6119bb5f9f4d0277dce5896 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 20:26:50 -0400 Subject: [PATCH 31/85] db_catalog --- src/catalog/abstract_catalog.cpp | 2 +- src/catalog/database_catalog.cpp | 14 +++++++++++++- src/catalog/table_catalog.cpp | 2 +- src/include/catalog/database_catalog.h | 2 ++ 4 files changed, 17 insertions(+), 3 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 45a3f7b6b76..401c845fac1 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -269,7 +269,7 @@ AbstractCatalog::GetResultWithCompiledSeqScan(std::vector column_offsets, codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); std::unique_ptr compiled_query(nullptr); cached = (query != nullptr); - LOG_DEBUG("cache %d", cached); + //LOG_DEBUG("cache %d", cached); // if not cached, compile the query and save it into cache if (!cached) { compiled_query = codegen::QueryCompiler().Compile( diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index f3b6f7a98de..eef36f89299 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -12,6 +12,7 @@ #include #include +#include #include "catalog/database_catalog.h" @@ -37,6 +38,17 @@ DatabaseCatalogObject::DatabaseCatalogObject(executor::LogicalTile *tile, valid_table_objects(false), txn(txn) {} +DatabaseCatalogObject::DatabaseCatalogObject(codegen::WrappedTuple wrapped_tuple, + concurrency::TransactionContext *txn) + : database_oid(wrapped_tuple.GetValue(DatabaseCatalog::ColumnId::DATABASE_OID) + .GetAs()), + database_name(wrapped_tuple.GetValue(DatabaseCatalog::ColumnId::DATABASE_NAME) + .ToString()), + table_objects_cache(), + table_name_cache(), + valid_table_objects(false), + txn(txn) {} + /* @brief insert table catalog object into cache * @param table_object * @return false if table_name already exists in cache @@ -324,7 +336,7 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( db_oid_const_expr); expression::AbstractExpression *predicate = db_oid_equality_expr; - std::vector result_tuples = + auto result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); if (result_tuples.size() == 1) { diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index cecbf119d00..28d2aef92bf 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -516,7 +516,7 @@ std::shared_ptr TableCatalog::GetTableObject( // ceate predicate refering to seq_scan_test.cpp std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); - LOG_DEBUG("Result size: %lu", result_tuples.size()); + //LOG_DEBUG("Result size: %lu", result_tuples.size()); if (result_tuples.size() == 1) { auto table_object = std::make_shared(result_tuples[0], txn); diff --git a/src/include/catalog/database_catalog.h b/src/include/catalog/database_catalog.h index 2c432ed191b..6857dc3a7bb 100644 --- a/src/include/catalog/database_catalog.h +++ b/src/include/catalog/database_catalog.h @@ -44,6 +44,8 @@ class DatabaseCatalogObject { public: DatabaseCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn); + DatabaseCatalogObject(codegen::WrappedTuple wrapped_tuple, + concurrency::TransactionContext *txn); void EvictAllTableObjects(); std::shared_ptr GetTableObject(oid_t table_oid, From 175e81f731bd263a8c380779f4e57a60ac3c7f06 Mon Sep 17 00:00:00 2001 From: Zeninma Date: Sat, 7 Apr 2018 20:27:12 -0400 Subject: [PATCH 32/85] column_catalog.pp/h --- src/catalog/column_catalog.cpp | 60 +++++++++++++++++++++++----- src/include/catalog/column_catalog.h | 1 + 2 files changed, 50 insertions(+), 11 deletions(-) diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index 6f9b9bdd5c7..e4435c8f9f5 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -10,12 +10,14 @@ // //===----------------------------------------------------------------------===// +#include #include "catalog/column_catalog.h" #include "concurrency/transaction_context.h" #include "catalog/table_catalog.h" #include "storage/data_table.h" #include "type/value_factory.h" +#include "expression/expression_util.h" namespace peloton { namespace catalog { @@ -41,6 +43,32 @@ ColumnCatalogObject::ColumnCatalogObject(executor::LogicalTile *tile, is_not_null(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_NOT_NULL) .GetAs()) {} + + ColumnCatalogObject::ColumnCatalogObject(codegen::WrappedTuple wrapped_tuple, + concurrency::TransactionContext *txn) + : table_oid(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::TABLE_OID) + .GetAs()), + column_name(wrapped_tuple.GetValue( ColumnCatalog::ColumnId::COLUMN_NAME) + .ToString()), + column_id(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_ID) + .GetAs()), + column_offset( + wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_OFFSET) + .GetAs()), + column_type(StringToTypeId( + wrapped_tuple.GetValue( ColumnCatalog::ColumnId::COLUMN_TYPE) + .ToString())), + is_inlined(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_INLINED) + .GetAs()), + is_primary(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_PRIMARY) + .GetAs()), + is_not_null(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_NOT_NULL) + .GetAs()) {} + + + + + ColumnCatalog *ColumnCatalog::GetInstance(storage::Database *pg_catalog, type::AbstractPool *pool, concurrency::TransactionContext *txn) { @@ -232,19 +260,29 @@ ColumnCatalog::GetColumnObjects(oid_t table_oid, // cache miss, get from pg_attribute std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::SKEY_TABLE_OID; // Index of table_oid - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); +// oid_t index_offset = IndexId::SKEY_TABLE_OID; // Index of table_oid +// std::vector values; +// values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + expression::AbstractExpression *tb_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); + expression::AbstractExpression *tb_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *col_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, tb_oid_expr, + tb_oid_const_expr); + + expression::AbstractExpression *predicate = col_oid_equality_expr; + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); + + for (auto tuple : result_tuples) { + + auto column_object = + std::make_shared(tuple, txn); + table_object->InsertColumnObject(column_object); - for (auto &tile : (*result_tiles)) { - for (auto tuple_id : *tile) { - auto column_object = - std::make_shared(tile.get(), tuple_id); - table_object->InsertColumnObject(column_object); - } } return table_object->GetColumnObjects(); diff --git a/src/include/catalog/column_catalog.h b/src/include/catalog/column_catalog.h index 56d8bf5c6b7..5b94db16da1 100644 --- a/src/include/catalog/column_catalog.h +++ b/src/include/catalog/column_catalog.h @@ -41,6 +41,7 @@ namespace catalog { class ColumnCatalogObject { public: ColumnCatalogObject(executor::LogicalTile *tile, int tupleId = 0); + ColumnCatalogObject(codegen::WrappedTuple wrapped_tuple, concurrency::TransactionContext *txn); inline oid_t GetTableOid() { return table_oid; } inline const std::string &GetColumnName() { return column_name; } From 6309f4a7be4c2f66577c7a600859fc0c834c4262 Mon Sep 17 00:00:00 2001 From: Zeninma Date: Sat, 7 Apr 2018 20:32:40 -0400 Subject: [PATCH 33/85] column_catalog.cpp/h --- src/catalog/column_catalog.cpp | 7 +++---- src/include/catalog/column_catalog.h | 2 +- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index e4435c8f9f5..29a28cefcd5 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -44,8 +44,7 @@ ColumnCatalogObject::ColumnCatalogObject(executor::LogicalTile *tile, .GetAs()) {} - ColumnCatalogObject::ColumnCatalogObject(codegen::WrappedTuple wrapped_tuple, - concurrency::TransactionContext *txn) + ColumnCatalogObject::ColumnCatalogObject(codegen::WrappedTuple wrapped_tuple) : table_oid(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::TABLE_OID) .GetAs()), column_name(wrapped_tuple.GetValue( ColumnCatalog::ColumnId::COLUMN_NAME) @@ -63,7 +62,7 @@ ColumnCatalogObject::ColumnCatalogObject(executor::LogicalTile *tile, is_primary(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_PRIMARY) .GetAs()), is_not_null(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_NOT_NULL) - .GetAs()) {} + .GetAs()){} @@ -280,7 +279,7 @@ ColumnCatalog::GetColumnObjects(oid_t table_oid, for (auto tuple : result_tuples) { auto column_object = - std::make_shared(tuple, txn); + std::make_shared(tuple); table_object->InsertColumnObject(column_object); } diff --git a/src/include/catalog/column_catalog.h b/src/include/catalog/column_catalog.h index 5b94db16da1..7dda9da6e09 100644 --- a/src/include/catalog/column_catalog.h +++ b/src/include/catalog/column_catalog.h @@ -41,7 +41,7 @@ namespace catalog { class ColumnCatalogObject { public: ColumnCatalogObject(executor::LogicalTile *tile, int tupleId = 0); - ColumnCatalogObject(codegen::WrappedTuple wrapped_tuple, concurrency::TransactionContext *txn); + ColumnCatalogObject(codegen::WrappedTuple wrapped_tuple); inline oid_t GetTableOid() { return table_oid; } inline const std::string &GetColumnName() { return column_name; } From cb0887bcf6bddc2bb0ee1ef14546342c9e497efe Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 20:58:24 -0400 Subject: [PATCH 34/85] index catalog --- src/catalog/index_catalog.cpp | 113 +++++++++++++++++++++++++++- src/include/catalog/index_catalog.h | 1 + 2 files changed, 113 insertions(+), 1 deletion(-) diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index f1d7683453c..f56eb5031bc 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -13,6 +13,8 @@ #include "catalog/index_catalog.h" #include +#include +#include #include "concurrency/transaction_context.h" #include "catalog/table_catalog.h" @@ -51,6 +53,32 @@ IndexCatalogObject::IndexCatalogObject(executor::LogicalTile *tile, int tupleId) LOG_TRACE("the size for indexed key is %lu", key_attrs.size()); } +IndexCatalogObject::IndexCatalogObject(codegen::WrappedTuple wrapped_tuple) + : index_oid(wrapped_tuple.GetValue(IndexCatalog::ColumnId::INDEX_OID) + .GetAs()), + index_name(wrapped_tuple.GetValue(IndexCatalog::ColumnId::INDEX_NAME) + .ToString()), + table_oid(wrapped_tuple.GetValue(IndexCatalog::ColumnId::TABLE_OID) + .GetAs()), + index_type(wrapped_tuple.GetValue(IndexCatalog::ColumnId::INDEX_TYPE) + .GetAs()), + index_constraint( + wrapped_tuple.GetValue(IndexCatalog::ColumnId::INDEX_CONSTRAINT) + .GetAs()), + unique_keys(wrapped_tuple.GetValue(IndexCatalog::ColumnId::UNIQUE_KEYS) + .GetAs()) { + std::string attr_str = + wrapped_tuple.GetValue(IndexCatalog::ColumnId::INDEXED_ATTRIBUTES) + .ToString(); + std::stringstream ss(attr_str.c_str()); // Turn the string into a stream. + std::string tok; + + while (std::getline(ss, tok, ' ')) { + key_attrs.push_back(std::stoi(tok)); + } + 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) { @@ -201,6 +229,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( return index_object; } + /* // cache miss, get from pg_index std::vector column_ids(all_column_ids); oid_t index_offset = IndexId::PRIMARY_KEY; // Index of index_oid @@ -221,6 +250,34 @@ std::shared_ptr IndexCatalog::GetIndexObject( return table_object->GetIndexObject(index_oid); } else { LOG_DEBUG("Found %lu index with oid %u", result_tiles->size(), index_oid); + }*/ + + std::vector column_ids(all_column_ids); + + expression::AbstractExpression *idx_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::INDEX_OID); + expression::AbstractExpression *idx_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(index_oid).Copy()); + expression::AbstractExpression *idx_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, idx_oid_expr, + idx_oid_const_expr); + + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, idx_oid_equality_expr, txn); + + if (result_tuples.size() == 1) { + auto index_object = + std::make_shared(result_tuples[0]); + // fetch all indexes into table object (cannot use the above index object) + auto table_object = TableCatalog::GetInstance()->GetTableObject( + index_object->GetTableOid(), txn); + PL_ASSERT(table_object && + table_object->GetTableOid() == index_object->GetTableOid()); + return table_object->GetIndexObject(index_oid); + } else { + LOG_DEBUG("Found %lu index with oid %u", result_tuples.size(), index_oid); } // return empty object if not found @@ -239,7 +296,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( } // cache miss, get from pg_index - std::vector column_ids(all_column_ids); + /*std::vector column_ids(all_column_ids); oid_t index_offset = IndexId::SKEY_INDEX_NAME; // Index of index_name std::vector values; values.push_back( @@ -260,6 +317,34 @@ std::shared_ptr IndexCatalog::GetIndexObject( } else { LOG_DEBUG("Found %lu index with name %s", result_tiles->size(), index_name.c_str()); + }*/ + + std::vector column_ids(all_column_ids); + + expression::AbstractExpression *idx_name_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::VARCHAR, 0, ColumnId::INDEX_NAME); + expression::AbstractExpression *idx_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(index_name, nullptr).Copy()); + expression::AbstractExpression *idx_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, idx_name_expr, + idx_name_const_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, idx_name_equality_expr, txn); + + if (result_tuples.size() == 1) { + auto index_object = + std::make_shared(result_tuples[0]); + // fetch all indexes into table object (cannot use the above index object) + auto table_object = TableCatalog::GetInstance()->GetTableObject( + index_object->GetTableOid(), txn); + PL_ASSERT(table_object && + table_object->GetTableOid() == index_object->GetTableOid()); + return table_object->GetIndexObject(index_name); + } else { + LOG_DEBUG("Found %lu index with name %s", result_tuples.size(), + index_name.c_str()); } // return empty object if not found @@ -277,6 +362,7 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, concurrency::TransactionContext * if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } + // try get from cache auto table_object = TableCatalog::GetInstance()->GetTableObject(table_oid, txn); @@ -285,6 +371,7 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, concurrency::TransactionContext * if (index_objects.empty() == false) return index_objects; // cache miss, get from pg_index + /* std::vector column_ids(all_column_ids); oid_t index_offset = IndexId::SKEY_TABLE_OID; // Index of table_oid std::vector values; @@ -299,8 +386,32 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, concurrency::TransactionContext * std::make_shared(tile.get(), tuple_id); table_object->InsertIndexObject(index_object); } + }*/ + + std::vector column_ids(all_column_ids); + + expression::AbstractExpression *oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); + expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, oid_expr, oid_const_expr); + + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, oid_equality_expr, txn); + + + for (auto tuple : result_tuples) { + + auto index_object = + std::make_shared(tuple); + table_object->InsertIndexObject(index_object); + } + return table_object->GetIndexObjects(); } diff --git a/src/include/catalog/index_catalog.h b/src/include/catalog/index_catalog.h index 3e49cf68e91..7df4b83f243 100644 --- a/src/include/catalog/index_catalog.h +++ b/src/include/catalog/index_catalog.h @@ -44,6 +44,7 @@ class IndexCatalogObject { public: IndexCatalogObject(executor::LogicalTile *tile, int tupleId = 0); + IndexCatalogObject(codegen::WrappedTuple wrapped_tuple); inline oid_t GetIndexOid() { return index_oid; } inline const std::string &GetIndexName() { return index_name; } From 9de228dc49a57d32df7c2500e0bca97d817d6716 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 21:09:06 -0400 Subject: [PATCH 35/85] lan catalog --- src/catalog/abstract_catalog.cpp | 2 +- src/catalog/language_catalog.cpp | 30 +++++++++++++++++++++++++- src/include/catalog/abstract_catalog.h | 2 +- src/include/catalog/language_catalog.h | 1 + 4 files changed, 32 insertions(+), 3 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 401c845fac1..e531d483121 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -249,7 +249,7 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, std::vector AbstractCatalog::GetResultWithCompiledSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, - concurrency::TransactionContext *txn) { + concurrency::TransactionContext *txn) const { if (txn == nullptr) throw CatalogException("Scan table requires transaction"); // Create sequential scan diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index fe9dfe64eff..4807bd9c3fc 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -10,6 +10,8 @@ // //===----------------------------------------------------------------------===// +#include +#include #include "catalog/language_catalog.h" #include "catalog/catalog.h" @@ -24,6 +26,10 @@ LanguageCatalogObject::LanguageCatalogObject(executor::LogicalTile *tuple) : lang_oid_(tuple->GetValue(0, 0).GetAs()), lang_name_(tuple->GetValue(0, 1).GetAs()) {} + LanguageCatalogObject::LanguageCatalogObject(codegen::WrappedTuple tuple) + : lang_oid_(tuple.GetValue(0).GetAs()), + lang_name_(tuple.GetValue(1).GetAs()) {} + LanguageCatalog &LanguageCatalog::GetInstance(concurrency::TransactionContext *txn) { static LanguageCatalog language_catalog{txn}; return language_catalog; @@ -75,7 +81,7 @@ bool LanguageCatalog::DeleteLanguage(const std::string &lanname, std::unique_ptr LanguageCatalog::GetLanguageByOid( oid_t lang_oid, concurrency::TransactionContext *txn) const { - std::vector column_ids(all_column_ids); + /*std::vector column_ids(all_column_ids); oid_t index_offset = IndexId::PRIMARY_KEY; std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(lang_oid).Copy()); @@ -88,6 +94,28 @@ std::unique_ptr LanguageCatalog::GetLanguageByOid( if (result_tiles->size() == 1) { PL_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); ret.reset(new LanguageCatalogObject((*result_tiles)[0].get())); + }*/ + + std::vector column_ids(all_column_ids); + + expression::AbstractExpression *oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::OID); + expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(lang_oid).Copy()); + expression::AbstractExpression *oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, oid_expr, oid_const_expr); + + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, oid_equality_expr, txn); + + + PL_ASSERT(result_tuples.size() <= 1); + + std::unique_ptr ret; + if (result_tuples.size() == 1) { + ret.reset(new LanguageCatalogObject(result_tuples[0])); } return ret; diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index f05290c6448..6ca793e464c 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -81,7 +81,7 @@ class AbstractCatalog { std::vector GetResultWithCompiledSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, - concurrency::TransactionContext *txn); + concurrency::TransactionContext *txn) const; void AddIndex(const std::vector &key_attrs, oid_t index_oid, const std::string &index_name, diff --git a/src/include/catalog/language_catalog.h b/src/include/catalog/language_catalog.h index 139f51eda21..cec643fabd5 100644 --- a/src/include/catalog/language_catalog.h +++ b/src/include/catalog/language_catalog.h @@ -39,6 +39,7 @@ namespace catalog { class LanguageCatalogObject { public: LanguageCatalogObject(executor::LogicalTile *tuple); + LanguageCatalogObject(codegen::WrappedTuple tuple); oid_t GetOid() const { return lang_oid_; } From e17af1386a623a8cdf69645e5fb538b7f7a1534f Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 7 Apr 2018 21:11:30 -0400 Subject: [PATCH 36/85] column stat --- src/catalog/column_stats_catalog.cpp | 73 +++++++++++++++++++--------- 1 file changed, 49 insertions(+), 24 deletions(-) diff --git a/src/catalog/column_stats_catalog.cpp b/src/catalog/column_stats_catalog.cpp index c66a9ab02be..478ef7d3dd6 100644 --- a/src/catalog/column_stats_catalog.cpp +++ b/src/catalog/column_stats_catalog.cpp @@ -17,6 +17,8 @@ #include "optimizer/stats/column_stats_collector.h" #include "storage/data_table.h" #include "storage/tuple.h" +#include "expression/expression_util.h" +#include "codegen/buffering_consumer.h" namespace peloton { namespace catalog { @@ -130,38 +132,61 @@ std::unique_ptr> ColumnStatsCatalog::GetColumnStats( {ColumnId::NUM_ROWS, ColumnId::CARDINALITY, ColumnId::FRAC_NULL, ColumnId::MOST_COMMON_VALS, ColumnId::MOST_COMMON_FREQS, ColumnId::HISTOGRAM_BOUNDS, ColumnId::COLUMN_NAME, ColumnId::HAS_INDEX}); - oid_t index_offset = IndexId::SECONDARY_KEY_0; // Secondary key index - - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(database_id).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(table_id).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(column_id).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - PL_ASSERT(result_tiles->size() <= 1); // unique - if (result_tiles->size() == 0) { + expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::DATABASE_ID); + expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_id).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, + db_oid_const_expr); + + expression::AbstractExpression *tb_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::TABLE_ID); + expression::AbstractExpression *tb_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_id).Copy()); + expression::AbstractExpression *tb_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, tb_oid_expr, + tb_oid_const_expr); + + expression::AbstractExpression *col_id_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::COLUMN_ID); + expression::AbstractExpression *col_id_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(column_id).Copy()); + expression::AbstractExpression *col_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, col_id_expr, + col_id_const_expr); + + expression::AbstractExpression *db_and_tb = expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_oid_equality_expr, tb_oid_equality_expr); + expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_and_tb, col_oid_equality_expr); + + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); + + PL_ASSERT(result_tuples.size() <= 1); // unique + if (result_tuples.size() == 0) { return nullptr; } - auto tile = (*result_tiles)[0].get(); - PL_ASSERT(tile->GetTupleCount() <= 1); - if (tile->GetTupleCount() == 0) { - return nullptr; - } + codegen::WrappedTuple tuple = result_tuples[0]; type::Value num_rows, cardinality, frac_null, most_common_vals, most_common_freqs, hist_bounds, column_name, has_index; - num_rows = tile->GetValue(0, ColumnStatsOffset::NUM_ROWS_OFF); - cardinality = tile->GetValue(0, ColumnStatsOffset::CARDINALITY_OFF); - frac_null = tile->GetValue(0, ColumnStatsOffset::FRAC_NULL_OFF); - most_common_vals = tile->GetValue(0, ColumnStatsOffset::COMMON_VALS_OFF); - most_common_freqs = tile->GetValue(0, ColumnStatsOffset::COMMON_FREQS_OFF); - hist_bounds = tile->GetValue(0, ColumnStatsOffset::HIST_BOUNDS_OFF); - column_name = tile->GetValue(0, ColumnStatsOffset::COLUMN_NAME_OFF); - has_index = tile->GetValue(0, ColumnStatsOffset::HAS_INDEX_OFF); + num_rows = tuple.GetValue(ColumnStatsOffset::NUM_ROWS_OFF); + cardinality = tuple.GetValue(ColumnStatsOffset::CARDINALITY_OFF); + frac_null = tuple.GetValue(ColumnStatsOffset::FRAC_NULL_OFF); + most_common_vals = tuple.GetValue(ColumnStatsOffset::COMMON_VALS_OFF); + most_common_freqs = tuple.GetValue(ColumnStatsOffset::COMMON_FREQS_OFF); + hist_bounds = tuple.GetValue(ColumnStatsOffset::HIST_BOUNDS_OFF); + column_name = tuple.GetValue(ColumnStatsOffset::COLUMN_NAME_OFF); + has_index = tuple.GetValue(ColumnStatsOffset::HAS_INDEX_OFF); std::unique_ptr> column_stats( new std::vector({num_rows, cardinality, frac_null, From b84c4c0c74784b10badcf35496f0b507e50e851c Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 21:12:53 -0400 Subject: [PATCH 37/85] lang catalog --- src/catalog/language_catalog.cpp | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index 4807bd9c3fc..1ecd4b49c8a 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -123,6 +123,7 @@ std::unique_ptr LanguageCatalog::GetLanguageByOid( std::unique_ptr LanguageCatalog::GetLanguageByName( const std::string &lang_name, concurrency::TransactionContext *txn) const { + /* std::vector column_ids(all_column_ids); oid_t index_offset = IndexId::SECONDARY_KEY_0; std::vector values; @@ -136,6 +137,27 @@ std::unique_ptr LanguageCatalog::GetLanguageByName( if (result_tiles->size() == 1) { PL_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); ret.reset(new LanguageCatalogObject((*result_tiles)[0].get())); + }*/ + + std::vector column_ids(all_column_ids); + + expression::AbstractExpression *name_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::VARCHAR, 0, ColumnId::LANNAME); + expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(lang_name, nullptr).Copy()); + expression::AbstractExpression *name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, name_expr, + name_const_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, name_equality_expr, txn); + + PL_ASSERT(result_tuples.size() <= 1); + + std::unique_ptr ret; + if (result_tuples.size() == 1) { + ret.reset(new LanguageCatalogObject(result_tuples[0])); } return ret; From 6e0c12eb2037c11fb819a198059ca5aa28d269bf Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 21:26:02 -0400 Subject: [PATCH 38/85] settings catalog --- src/catalog/index_catalog.cpp | 4 +-- src/catalog/language_catalog.cpp | 4 +-- src/catalog/settings_catalog.cpp | 48 ++++++++++++++++++++++++-- src/include/catalog/settings_catalog.h | 2 +- 4 files changed, 51 insertions(+), 7 deletions(-) diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index f56eb5031bc..67332bf6c74 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -13,8 +13,8 @@ #include "catalog/index_catalog.h" #include -#include -#include +#include "codegen/buffering_consumer.h" +#include "expression/expression_util.h" #include "concurrency/transaction_context.h" #include "catalog/table_catalog.h" diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index 1ecd4b49c8a..efa34ab523c 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -10,8 +10,8 @@ // //===----------------------------------------------------------------------===// -#include -#include +#include "codegen/buffering_consumer.h" +#include "expression/expression_util.h" #include "catalog/language_catalog.h" #include "catalog/catalog.h" diff --git a/src/catalog/settings_catalog.cpp b/src/catalog/settings_catalog.cpp index 4739229fc63..5b3191c395d 100644 --- a/src/catalog/settings_catalog.cpp +++ b/src/catalog/settings_catalog.cpp @@ -10,6 +10,8 @@ // //===----------------------------------------------------------------------===// +#include "include/expression/expression_util.h" +#include "codegen/buffering_consumer.h" #include "catalog/settings_catalog.h" #include "catalog/catalog.h" #include "executor/logical_tile.h" @@ -94,7 +96,7 @@ bool SettingsCatalog::DeleteSetting(const std::string &name, std::string SettingsCatalog::GetSettingValue(const std::string &name, concurrency::TransactionContext *txn) { - std::vector column_ids({static_cast(ColumnId::VALUE)}); + /*std::vector column_ids({static_cast(ColumnId::VALUE)}); oid_t index_offset = static_cast(IndexId::SECONDARY_KEY_0); std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); @@ -109,13 +111,36 @@ std::string SettingsCatalog::GetSettingValue(const std::string &name, if ((*result_tiles)[0]->GetTupleCount() != 0) { config_value = (*result_tiles)[0]->GetValue(0, 0).ToString(); } + }*/ + + std::vector column_ids({static_cast(ColumnId::VALUE)}); + + expression::AbstractExpression *name_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::VARCHAR, 0, ColumnId::NAME); + expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); + expression::AbstractExpression *name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, name_expr, + name_const_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, name_equality_expr, txn); + + std::string config_value = ""; + PL_ASSERT(result_tuples.size() <= 1); + if (result_tuples.size() != 0) { + + config_value = (result_tuples[0]).GetValue(0).ToString(); + } + return config_value; } std::string SettingsCatalog::GetDefaultValue(const std::string &name, concurrency::TransactionContext *txn) { - std::vector column_ids({static_cast(ColumnId::VALUE)}); + /*std::vector column_ids({static_cast(ColumnId::VALUE)}); oid_t index_offset = static_cast(IndexId::SECONDARY_KEY_0); std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); @@ -130,6 +155,25 @@ std::string SettingsCatalog::GetDefaultValue(const std::string &name, if ((*result_tiles)[0]->GetTupleCount() != 0) { config_value = (*result_tiles)[0]->GetValue(0, 0).ToString(); } + }*/ + std::vector column_ids({static_cast(ColumnId::VALUE)}); + + expression::AbstractExpression *name_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::VARCHAR, 0, ColumnId::NAME); + expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); + expression::AbstractExpression *name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, name_expr, + name_const_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, name_equality_expr, txn); + + std::string config_value = ""; + PL_ASSERT(result_tuples.size() <= 1); + if (result_tuples.size() != 0) { + config_value = result_tuples[0].GetValue(0).ToString(); } return config_value; } diff --git a/src/include/catalog/settings_catalog.h b/src/include/catalog/settings_catalog.h index a3c8b1bf6df..1879f5d6d3b 100644 --- a/src/include/catalog/settings_catalog.h +++ b/src/include/catalog/settings_catalog.h @@ -45,7 +45,7 @@ class SettingsCatalog : public AbstractCatalog { std::string GetDefaultValue(const std::string &name, concurrency::TransactionContext *txn); - enum class ColumnId { + enum ColumnId { NAME = 0, VALUE = 1, VALUE_TYPE = 2, From be7abc9f2f7d23fbc56bbad0762aee111a7d6a9e Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 7 Apr 2018 21:47:26 -0400 Subject: [PATCH 39/85] trigger catalog --- src/catalog/settings_catalog.cpp | 2 +- src/catalog/trigger_catalog.cpp | 128 ++++++++++++++++++++++++++++++- 2 files changed, 126 insertions(+), 4 deletions(-) diff --git a/src/catalog/settings_catalog.cpp b/src/catalog/settings_catalog.cpp index 5b3191c395d..41e3381dca0 100644 --- a/src/catalog/settings_catalog.cpp +++ b/src/catalog/settings_catalog.cpp @@ -10,7 +10,7 @@ // //===----------------------------------------------------------------------===// -#include "include/expression/expression_util.h" +#include "expression/expression_util.h" #include "codegen/buffering_consumer.h" #include "catalog/settings_catalog.h" #include "catalog/catalog.h" diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index 21e3434d250..0bcadd3cd24 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -10,6 +10,8 @@ // //===----------------------------------------------------------------------===// +#include "expression/expression_util.h" +#include "codegen/buffering_consumer.h" #include "catalog/trigger_catalog.h" #include "catalog/catalog.h" @@ -131,7 +133,7 @@ ResultType TriggerCatalog::DropTrigger(const std::string &database_name, oid_t TriggerCatalog::GetTriggerOid(std::string trigger_name, oid_t table_oid, concurrency::TransactionContext *txn) { - std::vector column_ids({ColumnId::TRIGGER_OID}); + /*std::vector column_ids({ColumnId::TRIGGER_OID}); oid_t index_offset = IndexId::NAME_TABLE_KEY_2; std::vector values; values.push_back(type::ValueFactory::GetVarcharValue(trigger_name).Copy()); @@ -149,7 +151,45 @@ oid_t TriggerCatalog::GetTriggerOid(std::string trigger_name, oid_t table_oid, if ((*result_tiles)[0]->GetTupleCount() != 0) { trigger_oid = (*result_tiles)[0]->GetValue(0, 0).GetAs(); } + }*/ + + std::vector column_ids({ColumnId::TRIGGER_OID}); + + expression::AbstractExpression *name_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::VARCHAR, 0, ColumnId::TRIGGER_NAME); + expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(trigger_name, nullptr).Copy()); + expression::AbstractExpression *name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, name_expr, + name_const_expr); + + expression::AbstractExpression *oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); + expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, oid_expr, + oid_const_expr); + + expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, name_equality_expr, oid_equality_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); + + oid_t trigger_oid = INVALID_OID; + if (result_tuples.size() == 0) { + LOG_INFO("trigger %s doesn't exist", trigger_name.c_str()); + } else { + LOG_INFO("size of the result tiles = %lu", result_tuples.size()); + PL_ASSERT(result_tuples.size() <= 1); + if (result_tuples.size() != 0) { + trigger_oid = result_tuples[0].GetValue(0).GetAs(); + } } + return trigger_oid; } @@ -168,7 +208,7 @@ std::unique_ptr TriggerCatalog::GetTriggersByType( 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( + /*std::vector column_ids( {ColumnId::TRIGGER_NAME, ColumnId::FIRE_CONDITION, ColumnId::FUNCTION_OID, ColumnId::FUNCTION_ARGS}); oid_t index_offset = IndexId::TABLE_TYPE_KEY_0; @@ -202,7 +242,55 @@ std::unique_ptr TriggerCatalog::GetTriggersByType( new_trigger_list->AddTrigger(new_trigger); } } + }*/ + + std::vector column_ids( + {ColumnId::TRIGGER_NAME, ColumnId::FIRE_CONDITION, ColumnId::FUNCTION_OID, + ColumnId::FUNCTION_ARGS}); + + expression::AbstractExpression *type_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::SMALLINT, 0, ColumnId::TRIGGER_TYPE); + expression::AbstractExpression *type_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetSmallIntValue(trigger_type).Copy()); + expression::AbstractExpression *type_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, type_expr, + type_const_expr); + + expression::AbstractExpression *oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); + expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, oid_expr, + oid_const_expr); + + expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, type_equality_expr, oid_equality_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); + + // carefull! the result tile could be null! + LOG_INFO("size of the result tiles = %lu", result_tuples.size()); + + + // create the trigger list + std::unique_ptr new_trigger_list{ + new trigger::TriggerList()}; + + for (unsigned int i = 0; i < result_tuples.size(); i++) { + // create a new trigger instance + trigger::Trigger new_trigger( + result_tuples[i].GetValue(0).ToString(), trigger_type, + result_tuples[i].GetValue(2).ToString(), + result_tuples[i].GetValue(3).ToString(), + result_tuples[i].GetValue(1).GetData()); + new_trigger_list->AddTrigger(new_trigger); + } + return new_trigger_list; } @@ -210,7 +298,7 @@ std::unique_ptr TriggerCatalog::GetTriggers( oid_t table_oid, concurrency::TransactionContext *txn) { LOG_DEBUG("Get triggers for table %d", table_oid); // select trigger_name, fire condition, function_name, function_args - std::vector column_ids( + /*std::vector column_ids( {ColumnId::TRIGGER_NAME, ColumnId::TRIGGER_TYPE, ColumnId::FIRE_CONDITION, ColumnId::FUNCTION_OID, ColumnId::FUNCTION_ARGS}); oid_t index_offset = IndexId::TABLE_KEY_1; @@ -246,6 +334,40 @@ std::unique_ptr TriggerCatalog::GetTriggers( new_trigger_list->AddTrigger(new_trigger); } } + }*/ + + std::vector column_ids( + {ColumnId::TRIGGER_NAME, ColumnId::TRIGGER_TYPE, ColumnId::FIRE_CONDITION, + ColumnId::FUNCTION_OID, ColumnId::FUNCTION_ARGS}); + expression::AbstractExpression *oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); + expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, oid_expr, + oid_const_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, oid_equality_expr, txn); + + // carefull! the result tile could be null! + LOG_INFO("size of the result tiles = %lu", result_tuples.size()); + +// create the trigger list + std::unique_ptr new_trigger_list{ + new trigger::TriggerList()}; + + for (unsigned int i = 0; i < result_tuples.size(); i++) { + // create a new trigger instance + trigger::Trigger new_trigger( + result_tuples[i].GetValue(0).ToString(), + result_tuples[i].GetValue(1).GetAs(), + result_tuples[i].GetValue(3).ToString(), + result_tuples[i].GetValue(4).ToString(), + result_tuples[i].GetValue(2).GetData()); + new_trigger_list->AddTrigger(new_trigger); + } return new_trigger_list; From a246491f3f50c3d25547acd65fbca9679b20bcbe Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 7 Apr 2018 21:28:43 -0400 Subject: [PATCH 40/85] zone map catalog --- src/catalog/zone_map_catalog.cpp | 79 ++++++++++++++++++-------- src/include/catalog/zone_map_catalog.h | 4 +- 2 files changed, 57 insertions(+), 26 deletions(-) diff --git a/src/catalog/zone_map_catalog.cpp b/src/catalog/zone_map_catalog.cpp index b30573ca7b1..8e1e1fa104e 100644 --- a/src/catalog/zone_map_catalog.cpp +++ b/src/catalog/zone_map_catalog.cpp @@ -19,6 +19,8 @@ #include "storage/tuple.h" #include "common/internal_types.h" #include "type/value_factory.h" +#include "expression/expression_util.h" +#include "codegen/buffering_consumer.h" namespace peloton { namespace catalog { @@ -100,34 +102,63 @@ std::unique_ptr> ZoneMapCatalog::GetColumnStatistics( 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) - }); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - - PL_ASSERT(result_tiles->size() <= 1); // unique - if (result_tiles->size() == 0) { + expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::DATABASE_ID); + expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_id).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, + db_oid_const_expr); + + expression::AbstractExpression *tb_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::TABLE_ID); + expression::AbstractExpression *tb_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_id).Copy()); + expression::AbstractExpression *tb_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, tb_oid_expr, + tb_oid_const_expr); + + expression::AbstractExpression *tile_gid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::TILE_GROUP_ID); + expression::AbstractExpression *tile_gid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(tile_group_id).Copy()); + expression::AbstractExpression *tile_gid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, tile_gid_expr, + tile_gid_const_expr); + + expression::AbstractExpression *col_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::COLUMN_ID); + expression::AbstractExpression *col_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(column_id).Copy()); + expression::AbstractExpression *col_id_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, col_oid_expr, + col_oid_const_expr); + + expression::AbstractExpression *db_and_tb = expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_oid_equality_expr, tb_oid_equality_expr); + expression::AbstractExpression *pred_and_tile = expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_and_tb, tile_gid_equality_expr); + expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, pred_and_tile, col_id_equality_expr); + + + auto result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); + + PL_ASSERT(result_tuples.size() <= 1); // unique + if (result_tuples.size() == 0) { LOG_DEBUG("Result Tiles = 0"); return nullptr; } - - auto tile = (*result_tiles)[0].get(); - PL_ASSERT(tile->GetTupleCount() <= 1); - if (tile->GetTupleCount() == 0) { - return nullptr; - } - + auto tuple = result_tuples[0]; type::Value min, max, actual_type; - min = tile->GetValue(0, static_cast(ZoneMapOffset::MINIMUM_OFF)); - max = tile->GetValue(0, static_cast(ZoneMapOffset::MAXIMUM_OFF)); - actual_type = tile->GetValue(0, static_cast(ZoneMapOffset::TYPE_OFF)); + min = tuple.GetValue(ZoneMapOffset::MINIMUM_OFF); + max = tuple.GetValue(ZoneMapOffset::MAXIMUM_OFF); + actual_type = tuple.GetValue(ZoneMapOffset::TYPE_OFF); // min and max are stored as VARCHARs and should be convertd to their // original types. diff --git a/src/include/catalog/zone_map_catalog.h b/src/include/catalog/zone_map_catalog.h index a38d26d0597..143230583bb 100644 --- a/src/include/catalog/zone_map_catalog.h +++ b/src/include/catalog/zone_map_catalog.h @@ -54,7 +54,7 @@ class ZoneMapCatalog : public AbstractCatalog { oid_t database_id, oid_t table_id, oid_t tile_group_id, oid_t column_id, concurrency::TransactionContext *txn); - enum class ColumnId { + enum ColumnId { DATABASE_ID = 0, TABLE_ID = 1, TILE_GROUP_ID = 2, @@ -64,7 +64,7 @@ class ZoneMapCatalog : public AbstractCatalog { TYPE = 6 }; - enum class ZoneMapOffset { + enum ZoneMapOffset { MINIMUM_OFF = 0, MAXIMUM_OFF = 1, TYPE_OFF = 2 From b8bd9a1093eb4bdb5cb114e09128f01b0ae2c56d Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 7 Apr 2018 21:28:43 -0400 Subject: [PATCH 41/85] zone map catalog --- src/catalog/zone_map_catalog.cpp | 79 ++++++++++++++++++-------- src/include/catalog/zone_map_catalog.h | 4 +- 2 files changed, 57 insertions(+), 26 deletions(-) diff --git a/src/catalog/zone_map_catalog.cpp b/src/catalog/zone_map_catalog.cpp index b30573ca7b1..8e1e1fa104e 100644 --- a/src/catalog/zone_map_catalog.cpp +++ b/src/catalog/zone_map_catalog.cpp @@ -19,6 +19,8 @@ #include "storage/tuple.h" #include "common/internal_types.h" #include "type/value_factory.h" +#include "expression/expression_util.h" +#include "codegen/buffering_consumer.h" namespace peloton { namespace catalog { @@ -100,34 +102,63 @@ std::unique_ptr> ZoneMapCatalog::GetColumnStatistics( 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) - }); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - - PL_ASSERT(result_tiles->size() <= 1); // unique - if (result_tiles->size() == 0) { + expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::DATABASE_ID); + expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_id).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, + db_oid_const_expr); + + expression::AbstractExpression *tb_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::TABLE_ID); + expression::AbstractExpression *tb_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_id).Copy()); + expression::AbstractExpression *tb_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, tb_oid_expr, + tb_oid_const_expr); + + expression::AbstractExpression *tile_gid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::TILE_GROUP_ID); + expression::AbstractExpression *tile_gid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(tile_group_id).Copy()); + expression::AbstractExpression *tile_gid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, tile_gid_expr, + tile_gid_const_expr); + + expression::AbstractExpression *col_oid_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::INTEGER, 0, ColumnId::COLUMN_ID); + expression::AbstractExpression *col_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(column_id).Copy()); + expression::AbstractExpression *col_id_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, col_oid_expr, + col_oid_const_expr); + + expression::AbstractExpression *db_and_tb = expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_oid_equality_expr, tb_oid_equality_expr); + expression::AbstractExpression *pred_and_tile = expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_and_tb, tile_gid_equality_expr); + expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, pred_and_tile, col_id_equality_expr); + + + auto result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); + + PL_ASSERT(result_tuples.size() <= 1); // unique + if (result_tuples.size() == 0) { LOG_DEBUG("Result Tiles = 0"); return nullptr; } - - auto tile = (*result_tiles)[0].get(); - PL_ASSERT(tile->GetTupleCount() <= 1); - if (tile->GetTupleCount() == 0) { - return nullptr; - } - + auto tuple = result_tuples[0]; type::Value min, max, actual_type; - min = tile->GetValue(0, static_cast(ZoneMapOffset::MINIMUM_OFF)); - max = tile->GetValue(0, static_cast(ZoneMapOffset::MAXIMUM_OFF)); - actual_type = tile->GetValue(0, static_cast(ZoneMapOffset::TYPE_OFF)); + min = tuple.GetValue(ZoneMapOffset::MINIMUM_OFF); + max = tuple.GetValue(ZoneMapOffset::MAXIMUM_OFF); + actual_type = tuple.GetValue(ZoneMapOffset::TYPE_OFF); // min and max are stored as VARCHARs and should be convertd to their // original types. diff --git a/src/include/catalog/zone_map_catalog.h b/src/include/catalog/zone_map_catalog.h index a38d26d0597..143230583bb 100644 --- a/src/include/catalog/zone_map_catalog.h +++ b/src/include/catalog/zone_map_catalog.h @@ -54,7 +54,7 @@ class ZoneMapCatalog : public AbstractCatalog { oid_t database_id, oid_t table_id, oid_t tile_group_id, oid_t column_id, concurrency::TransactionContext *txn); - enum class ColumnId { + enum ColumnId { DATABASE_ID = 0, TABLE_ID = 1, TILE_GROUP_ID = 2, @@ -64,7 +64,7 @@ class ZoneMapCatalog : public AbstractCatalog { TYPE = 6 }; - enum class ZoneMapOffset { + enum ZoneMapOffset { MINIMUM_OFF = 0, MAXIMUM_OFF = 1, TYPE_OFF = 2 From 74309d985cfbfeec5cc61601f6a0dff958eec0d7 Mon Sep 17 00:00:00 2001 From: Zeninma Date: Sat, 7 Apr 2018 22:06:17 -0400 Subject: [PATCH 42/85] proc_catolog.cpp/h --- src/catalog/proc_catalog.cpp | 59 ++++++++++++++++++++++++------ src/include/catalog/proc_catalog.h | 2 +- 2 files changed, 48 insertions(+), 13 deletions(-) diff --git a/src/catalog/proc_catalog.cpp b/src/catalog/proc_catalog.cpp index 25dd31dbdfa..e8aa68f2d35 100644 --- a/src/catalog/proc_catalog.cpp +++ b/src/catalog/proc_catalog.cpp @@ -10,6 +10,7 @@ // //===----------------------------------------------------------------------===// +#include #include "catalog/proc_catalog.h" #include "catalog/catalog.h" @@ -17,6 +18,7 @@ #include "executor/logical_tile.h" #include "storage/data_table.h" #include "type/value_factory.h" +#include "expression/expression_util.h" namespace peloton { namespace catalog { @@ -33,6 +35,17 @@ ProcCatalogObject::ProcCatalogObject(executor::LogicalTile *tile, src_(tile->GetValue(0, 5).GetAs()), txn_(txn) {} + +ProcCatalogObject::ProcCatalogObject(codegen::WrappedTuple wrapped_tuple, + concurrency::TransactionContext *txn) + : oid_(wrapped_tuple.GetValue(0).GetAs()), + name_(wrapped_tuple.GetValue(1).GetAs()), + ret_type_(wrapped_tuple.GetValue(2).GetAs()), + arg_types_(StringToTypeArray(wrapped_tuple.GetValue(3).GetAs())), + lang_oid_(wrapped_tuple.GetValue(4).GetAs()), + src_(wrapped_tuple.GetValue(5).GetAs()), + txn_(txn) {} + std::unique_ptr ProcCatalogObject::GetLanguage() const { return LanguageCatalog::GetInstance().GetLanguageByOid(GetLangOid(), txn_); } @@ -114,20 +127,42 @@ std::unique_ptr ProcCatalog::GetProcByName( const std::vector &proc_arg_types, concurrency::TransactionContext *txn) const { std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::SECONDARY_KEY_0; - std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue(proc_name).Copy()); - values.push_back(type::ValueFactory::GetVarcharValue( - TypeIdArrayToString(proc_arg_types)).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - PL_ASSERT(result_tiles->size() <= 1); +// 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()); + + expression::AbstractExpression *proc_name_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::VARCHAR, 0, ColumnId::PRONAME); + expression::AbstractExpression *proc_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(proc_name, nullptr).Copy()); + expression::AbstractExpression *proc_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, proc_name_expr, + proc_name_const_expr); + + expression::AbstractExpression *proc_args_expr = expression::ExpressionUtil::TupleValueFactory( + type::TypeId::VARCHAR, 0, ColumnId::PROARGTYPES); + expression::AbstractExpression *proc_args_const_expr = expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(TypeIdArrayToString(proc_arg_types)).Copy()); + expression::AbstractExpression *proc_args_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, proc_args_expr, + proc_args_const_expr); + + expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, proc_name_equality_expr, proc_args_equality_expr); + + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); + + PL_ASSERT(result_tuples.size() <= 1); std::unique_ptr ret; - if (result_tiles->size() == 1) { - PL_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - ret.reset(new ProcCatalogObject((*result_tiles)[0].get(), txn)); + if (result_tuples.size() == 1) { + ret.reset(new ProcCatalogObject(result_tuples[0], txn)); } return ret; diff --git a/src/include/catalog/proc_catalog.h b/src/include/catalog/proc_catalog.h index 0445daecc9d..37322b65662 100644 --- a/src/include/catalog/proc_catalog.h +++ b/src/include/catalog/proc_catalog.h @@ -42,7 +42,7 @@ class LanguageCatalogObject; class ProcCatalogObject { public: ProcCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn); - + ProcCatalogObject(codegen::WrappedTuple wrapped_tuple, concurrency::TransactionContext *txn); // Accessors oid_t GetOid() const { return oid_; } From 42a1a91a041acc28a93b4234b4c2475e12b178f4 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Wed, 11 Apr 2018 15:13:18 -0400 Subject: [PATCH 43/85] delete code --- src/catalog/column_catalog.cpp | 3 -- src/catalog/index_catalog.cpp | 59 -------------------------------- src/catalog/language_catalog.cpp | 29 ---------------- src/catalog/table_catalog.cpp | 33 ++++-------------- 4 files changed, 7 insertions(+), 117 deletions(-) diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index 29a28cefcd5..6165fcc63a7 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -259,9 +259,6 @@ ColumnCatalog::GetColumnObjects(oid_t table_oid, // cache miss, get from pg_attribute std::vector column_ids(all_column_ids); -// oid_t index_offset = IndexId::SKEY_TABLE_OID; // Index of table_oid -// std::vector values; -// values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); expression::AbstractExpression *tb_oid_expr = expression::ExpressionUtil::TupleValueFactory( type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index 67332bf6c74..731b9340aa3 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -229,28 +229,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( return index_object; } - /* // cache miss, get from pg_index - std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::PRIMARY_KEY; // Index of index_oid - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(index_oid).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { - 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); - PL_ASSERT(table_object && - table_object->GetTableOid() == index_object->GetTableOid()); - return table_object->GetIndexObject(index_oid); - } else { - LOG_DEBUG("Found %lu index with oid %u", result_tiles->size(), index_oid); - }*/ std::vector column_ids(all_column_ids); @@ -296,28 +275,6 @@ std::shared_ptr IndexCatalog::GetIndexObject( } // 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 - std::vector values; - values.push_back( - type::ValueFactory::GetVarcharValue(index_name, nullptr).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { - 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); - PL_ASSERT(table_object && - table_object->GetTableOid() == index_object->GetTableOid()); - return table_object->GetIndexObject(index_name); - } else { - LOG_DEBUG("Found %lu index with name %s", result_tiles->size(), - index_name.c_str()); - }*/ std::vector column_ids(all_column_ids); @@ -371,22 +328,6 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, concurrency::TransactionContext * if (index_objects.empty() == false) return index_objects; // cache miss, get from pg_index - /* - std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::SKEY_TABLE_OID; // Index of table_oid - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - - for (auto &tile : (*result_tiles)) { - for (auto tuple_id : *tile) { - auto index_object = - std::make_shared(tile.get(), tuple_id); - table_object->InsertIndexObject(index_object); - } - }*/ std::vector column_ids(all_column_ids); diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index efa34ab523c..36d1d19acd1 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -81,20 +81,6 @@ bool LanguageCatalog::DeleteLanguage(const std::string &lanname, std::unique_ptr LanguageCatalog::GetLanguageByOid( oid_t lang_oid, concurrency::TransactionContext *txn) const { - /*std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::PRIMARY_KEY; - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(lang_oid).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - PL_ASSERT(result_tiles->size() <= 1); - - std::unique_ptr ret; - if (result_tiles->size() == 1) { - PL_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - ret.reset(new LanguageCatalogObject((*result_tiles)[0].get())); - }*/ std::vector column_ids(all_column_ids); @@ -123,21 +109,6 @@ std::unique_ptr LanguageCatalog::GetLanguageByOid( std::unique_ptr LanguageCatalog::GetLanguageByName( const std::string &lang_name, concurrency::TransactionContext *txn) const { - /* - std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::SECONDARY_KEY_0; - std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue(lang_name).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - PL_ASSERT(result_tiles->size() <= 1); - - std::unique_ptr ret; - if (result_tiles->size() == 1) { - PL_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - ret.reset(new LanguageCatalogObject((*result_tiles)[0].get())); - }*/ std::vector column_ids(all_column_ids); diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 28d2aef92bf..9c7a957c3a9 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -470,21 +470,16 @@ std::shared_ptr TableCatalog::GetTableObject( 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); -// if (table_object) return table_object; -// } + + //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); + if (table_object) return table_object; + } // 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 -// std::vector values; -// values.push_back( -// type::ValueFactory::GetVarcharValue(table_name, nullptr).Copy()); -// values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); // need the predicate for the seq scan (conjunction) // table_name == table_name and database_oid need to be same @@ -556,9 +551,6 @@ TableCatalog::GetTableObjects(oid_t database_oid, // cache miss, get from pg_table std::vector column_ids(all_column_ids); - //oid_t index_offset = IndexId::SKEY_DATABASE_OID; // Index of database_oid - //std::vector values; - //values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( type::TypeId::INTEGER, 0, ColumnId::DATABASE_OID); @@ -569,21 +561,10 @@ TableCatalog::GetTableObjects(oid_t database_oid, ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); - //auto result_tiles = - // GetResultWithIndexScan(column_ids, index_offset, values, txn); - expression::AbstractExpression *predicate = db_oid_equality_expr; std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); - /*for (auto &tile : (*result_tiles)) { - for (auto tuple_id : *tile) { - auto table_object = - std::make_shared(tile.get(), txn, tuple_id); - database_object->InsertTableObject(table_object); - } - }*/ - for (auto tuple : result_tuples) { auto table_object = From 38ea8eff2ee3a0cf0ccc55ef11961e8f3e3136d4 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Wed, 11 Apr 2018 15:18:30 -0400 Subject: [PATCH 44/85] clean up db and trigger --- src/catalog/database_catalog.cpp | 46 --------------- src/catalog/trigger_catalog.cpp | 96 +------------------------------- 2 files changed, 1 insertion(+), 141 deletions(-) diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index eef36f89299..ed5b42425cc 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -300,29 +300,6 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( auto database_object = txn->catalog_cache.GetDatabaseObject(database_oid); if (database_object) return database_object; - /* - // cache miss, get from pg_database - std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::PRIMARY_KEY; // Index of database_oid - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { - auto database_object = - std::make_shared((*result_tiles)[0].get(), txn); - // insert into cache - bool success = txn->catalog_cache.InsertDatabaseObject(database_object); - PL_ASSERT(success == true); - (void)success; - return database_object; - } else { - LOG_DEBUG("Found %lu database tiles with oid %u", result_tiles->size(), - database_oid); - }*/ - // cache miss, get from pg_database std::vector column_ids(all_column_ids); @@ -369,29 +346,6 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( auto database_object = txn->catalog_cache.GetDatabaseObject(database_name); if (database_object) return database_object; - /* - // cache miss, get from pg_database - std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::SKEY_DATABASE_NAME; // Index of database_name - std::vector values; - values.push_back( - type::ValueFactory::GetVarcharValue(database_name, nullptr).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { - auto database_object = - std::make_shared((*result_tiles)[0].get(), txn); - if (database_object) { - // insert into cache - bool success = txn->catalog_cache.InsertDatabaseObject(database_object); - PL_ASSERT(success == true); - (void)success; - } - return database_object; - }*/ - std::vector column_ids(all_column_ids); expression::AbstractExpression *db_name_expr = expression::ExpressionUtil::TupleValueFactory( diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index 0bcadd3cd24..4a75345a52e 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -133,25 +133,6 @@ ResultType TriggerCatalog::DropTrigger(const std::string &database_name, oid_t TriggerCatalog::GetTriggerOid(std::string trigger_name, oid_t table_oid, concurrency::TransactionContext *txn) { - /*std::vector column_ids({ColumnId::TRIGGER_OID}); - oid_t index_offset = IndexId::NAME_TABLE_KEY_2; - std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue(trigger_name).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - - oid_t trigger_oid = INVALID_OID; - if (result_tiles->size() == 0) { - LOG_INFO("trigger %s doesn't exist", trigger_name.c_str()); - } else { - LOG_INFO("size of the result tiles = %lu", result_tiles->size()); - PL_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - if ((*result_tiles)[0]->GetTupleCount() != 0) { - trigger_oid = (*result_tiles)[0]->GetValue(0, 0).GetAs(); - } - }*/ std::vector column_ids({ColumnId::TRIGGER_OID}); @@ -207,43 +188,6 @@ bool TriggerCatalog::DeleteTriggerByName(const std::string &trigger_name, std::unique_ptr TriggerCatalog::GetTriggersByType( 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( - {ColumnId::TRIGGER_NAME, ColumnId::FIRE_CONDITION, ColumnId::FUNCTION_OID, - ColumnId::FUNCTION_ARGS}); - oid_t index_offset = IndexId::TABLE_TYPE_KEY_0; - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(trigger_type).Copy()); - - // the result is a vector of executor::LogicalTile - 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()); - } - - // create the trigger list - std::unique_ptr new_trigger_list{ - new trigger::TriggerList()}; - if (result_tiles != nullptr) { - for (unsigned int i = 0; i < result_tiles->size(); i++) { - size_t tuple_count = (*result_tiles)[i]->GetTupleCount(); - for (size_t j = 0; j < tuple_count; j++) { - // create a new trigger instance - trigger::Trigger new_trigger( - (*result_tiles)[i]->GetValue(j, 0).ToString(), trigger_type, - (*result_tiles)[i]->GetValue(j, 2).ToString(), - (*result_tiles)[i]->GetValue(j, 3).ToString(), - (*result_tiles)[i]->GetValue(j, 1).GetData()); - new_trigger_list->AddTrigger(new_trigger); - } - } - }*/ - std::vector column_ids( {ColumnId::TRIGGER_NAME, ColumnId::FIRE_CONDITION, ColumnId::FUNCTION_OID, ColumnId::FUNCTION_ARGS}); @@ -272,7 +216,7 @@ std::unique_ptr TriggerCatalog::GetTriggersByType( std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); - // carefull! the result tile could be null! + // carefull! the result could be null! LOG_INFO("size of the result tiles = %lu", result_tuples.size()); @@ -297,44 +241,6 @@ 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); - // select trigger_name, fire condition, function_name, function_args - /*std::vector column_ids( - {ColumnId::TRIGGER_NAME, ColumnId::TRIGGER_TYPE, ColumnId::FIRE_CONDITION, - ColumnId::FUNCTION_OID, ColumnId::FUNCTION_ARGS}); - oid_t index_offset = IndexId::TABLE_KEY_1; - std::vector values; - // where database_oid = args.database_oid and table_oid = args.table_oid and - // trigger_type = args.trigger_type - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); - - // the result is a vector of executor::LogicalTile - 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()); - } - - // create the trigger list - std::unique_ptr new_trigger_list{ - new trigger::TriggerList()}; - if (result_tiles != nullptr) { - for (unsigned int i = 0; i < result_tiles->size(); i++) { - size_t tuple_count = (*result_tiles)[i]->GetTupleCount(); - for (size_t j = 0; j < tuple_count; j++) { - // create a new trigger instance - trigger::Trigger new_trigger( - (*result_tiles)[i]->GetValue(j, 0).ToString(), - (*result_tiles)[i]->GetValue(j, 1).GetAs(), - (*result_tiles)[i]->GetValue(j, 3).ToString(), - (*result_tiles)[i]->GetValue(j, 4).ToString(), - (*result_tiles)[i]->GetValue(j, 2).GetData()); - new_trigger_list->AddTrigger(new_trigger); - } - } - }*/ std::vector column_ids( {ColumnId::TRIGGER_NAME, ColumnId::TRIGGER_TYPE, ColumnId::FIRE_CONDITION, From f1a5514f5039bbc664369007337e004eb9390b39 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Wed, 11 Apr 2018 15:22:53 -0400 Subject: [PATCH 45/85] cleanup settings catalog --- src/catalog/settings_catalog.cpp | 32 -------------------------------- 1 file changed, 32 deletions(-) diff --git a/src/catalog/settings_catalog.cpp b/src/catalog/settings_catalog.cpp index 41e3381dca0..51618555244 100644 --- a/src/catalog/settings_catalog.cpp +++ b/src/catalog/settings_catalog.cpp @@ -96,22 +96,6 @@ bool SettingsCatalog::DeleteSetting(const std::string &name, 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; - values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - - std::string config_value = ""; - PL_ASSERT(result_tiles->size() <= 1); - if (result_tiles->size() != 0) { - PL_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - if ((*result_tiles)[0]->GetTupleCount() != 0) { - config_value = (*result_tiles)[0]->GetValue(0, 0).ToString(); - } - }*/ std::vector column_ids({static_cast(ColumnId::VALUE)}); @@ -140,22 +124,6 @@ std::string SettingsCatalog::GetSettingValue(const std::string &name, 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; - values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - - std::string config_value = ""; - PL_ASSERT(result_tiles->size() <= 1); - if (result_tiles->size() != 0) { - PL_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - if ((*result_tiles)[0]->GetTupleCount() != 0) { - config_value = (*result_tiles)[0]->GetValue(0, 0).ToString(); - } - }*/ std::vector column_ids({static_cast(ColumnId::VALUE)}); expression::AbstractExpression *name_expr = expression::ExpressionUtil::TupleValueFactory( From 97533df761193eeac0e4f2bfbe2cc773dd043993 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Wed, 11 Apr 2018 15:15:05 -0400 Subject: [PATCH 46/85] delete code --- src/catalog/proc_catalog.cpp | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/catalog/proc_catalog.cpp b/src/catalog/proc_catalog.cpp index e8aa68f2d35..aa3808e07c1 100644 --- a/src/catalog/proc_catalog.cpp +++ b/src/catalog/proc_catalog.cpp @@ -127,11 +127,6 @@ std::unique_ptr ProcCatalog::GetProcByName( const std::vector &proc_arg_types, concurrency::TransactionContext *txn) const { std::vector column_ids(all_column_ids); -// oid_t index_offset = IndexId::SECONDARY_KEY_0; -// std::vector values; -// values.push_back(type::ValueFactory::GetVarcharValue(proc_name).Copy()); -// values.push_back(type::ValueFactory::GetVarcharValue( -// TypeIdArrayToString(proc_arg_types)).Copy()); expression::AbstractExpression *proc_name_expr = expression::ExpressionUtil::TupleValueFactory( type::TypeId::VARCHAR, 0, ColumnId::PRONAME); From bb353ede9085151302c9fe8b1fd9a08adc3e6d2f Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Wed, 11 Apr 2018 15:17:56 -0400 Subject: [PATCH 47/85] restore catalog test --- test/catalog/catalog_test.cpp | 60 +++++++++++++++-------------------- 1 file changed, 25 insertions(+), 35 deletions(-) diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index 036f1ece038..4d3cfc05fbe 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -153,47 +153,37 @@ TEST_F(CatalogTests, CreatingTable) { } TEST_F(CatalogTests, TableObject) { - double avg_time = 0.0; - int num_iterations = 1000; - Timer> timer; - for(int i=0;iGetTableObject( - "EMP_DB", "department_table", txn); - timer.Stop(); - avg_time += timer.GetDuration(); + auto table_object = catalog::Catalog::GetInstance()->GetTableObject( + "EMP_DB", "department_table", txn); - auto index_objects = table_object->GetIndexObjects(); - auto column_objects = table_object->GetColumnObjects(); + auto index_objects = table_object->GetIndexObjects(); + auto column_objects = table_object->GetColumnObjects(); - EXPECT_EQ(1, index_objects.size()); - EXPECT_EQ(2, column_objects.size()); + EXPECT_EQ(1, index_objects.size()); + EXPECT_EQ(2, column_objects.size()); - EXPECT_EQ(table_object->GetTableOid(), column_objects[0]->GetTableOid()); - EXPECT_EQ("id", column_objects[0]->GetColumnName()); - EXPECT_EQ(0, column_objects[0]->GetColumnId()); - EXPECT_EQ(0, column_objects[0]->GetColumnOffset()); - EXPECT_EQ(type::TypeId::INTEGER, column_objects[0]->GetColumnType()); - EXPECT_TRUE(column_objects[0]->IsInlined()); - EXPECT_TRUE(column_objects[0]->IsPrimary()); - EXPECT_FALSE(column_objects[0]->IsNotNull()); + EXPECT_EQ(table_object->GetTableOid(), column_objects[0]->GetTableOid()); + EXPECT_EQ("id", column_objects[0]->GetColumnName()); + EXPECT_EQ(0, column_objects[0]->GetColumnId()); + EXPECT_EQ(0, column_objects[0]->GetColumnOffset()); + EXPECT_EQ(type::TypeId::INTEGER, column_objects[0]->GetColumnType()); + EXPECT_TRUE(column_objects[0]->IsInlined()); + EXPECT_TRUE(column_objects[0]->IsPrimary()); + EXPECT_FALSE(column_objects[0]->IsNotNull()); - EXPECT_EQ(table_object->GetTableOid(), column_objects[1]->GetTableOid()); - EXPECT_EQ("name", column_objects[1]->GetColumnName()); - EXPECT_EQ(1, column_objects[1]->GetColumnId()); - EXPECT_EQ(4, column_objects[1]->GetColumnOffset()); - EXPECT_EQ(type::TypeId::VARCHAR, column_objects[1]->GetColumnType()); - EXPECT_TRUE(column_objects[1]->IsInlined()); - EXPECT_FALSE(column_objects[1]->IsPrimary()); - EXPECT_FALSE(column_objects[1]->IsNotNull()); + EXPECT_EQ(table_object->GetTableOid(), column_objects[1]->GetTableOid()); + EXPECT_EQ("name", column_objects[1]->GetColumnName()); + EXPECT_EQ(1, column_objects[1]->GetColumnId()); + EXPECT_EQ(4, column_objects[1]->GetColumnOffset()); + EXPECT_EQ(type::TypeId::VARCHAR, column_objects[1]->GetColumnType()); + EXPECT_TRUE(column_objects[1]->IsInlined()); + EXPECT_FALSE(column_objects[1]->IsPrimary()); + EXPECT_FALSE(column_objects[1]->IsNotNull()); - txn_manager.CommitTransaction(txn); - } - LOG_TRACE("Avg time: %.4lf", avg_time / num_iterations); + txn_manager.CommitTransaction(txn); } TEST_F(CatalogTests, DroppingTable) { From 6a24d11cbbce7af6b2bd8f21b2607e8bf28be4cc Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Wed, 11 Apr 2018 16:27:45 -0400 Subject: [PATCH 48/85] format --- src/catalog/abstract_catalog.cpp | 18 +-- src/catalog/catalog.cpp | 80 ++++++------ src/catalog/column_catalog.cpp | 67 +++++----- src/catalog/column_stats_catalog.cpp | 65 +++++----- src/catalog/database_catalog.cpp | 55 ++++---- src/catalog/database_metrics_catalog.cpp | 6 +- src/catalog/index_catalog.cpp | 60 +++++---- src/catalog/index_metrics_catalog.cpp | 4 +- src/catalog/language_catalog.cpp | 33 ++--- src/catalog/proc_catalog.cpp | 40 +++--- src/catalog/query_metrics_catalog.cpp | 12 +- src/catalog/schema.cpp | 9 +- src/catalog/settings_catalog.cpp | 41 +++--- src/catalog/table_catalog.cpp | 69 +++++----- src/catalog/table_metrics_catalog.cpp | 4 +- src/catalog/trigger_catalog.cpp | 117 +++++++++-------- src/catalog/zone_map_catalog.cpp | 119 +++++++++--------- src/include/catalog/abstract_catalog.h | 13 +- src/include/catalog/column.h | 5 +- src/include/catalog/column_catalog.h | 10 +- src/include/catalog/constraint.h | 8 +- src/include/catalog/database_catalog.h | 10 +- .../catalog/database_metrics_catalog.h | 3 +- src/include/catalog/foreign_key.h | 10 +- src/include/catalog/index_metrics_catalog.h | 3 +- src/include/catalog/language_catalog.h | 3 +- src/include/catalog/proc_catalog.h | 9 +- src/include/catalog/schema.h | 2 +- src/include/catalog/settings_catalog.h | 6 +- src/include/catalog/table_catalog.h | 14 ++- src/include/catalog/table_metrics_catalog.h | 3 +- src/include/catalog/trigger_catalog.h | 6 +- src/include/catalog/zone_map_catalog.h | 10 +- 33 files changed, 471 insertions(+), 443 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 6503c0327ba..b4db8bedbb2 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -247,13 +247,15 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, * @return Unique pointer of vector of logical tiles */ std::vector -AbstractCatalog::GetResultWithCompiledSeqScan(std::vector column_offsets, - expression::AbstractExpression *predicate, - concurrency::TransactionContext *txn) const { +AbstractCatalog::GetResultWithCompiledSeqScan( + std::vector column_offsets, + expression::AbstractExpression *predicate, + concurrency::TransactionContext *txn) const { if (txn == nullptr) throw CatalogException("Scan table requires transaction"); // Create sequential scan - auto plan_ptr = std::make_shared(catalog_table_, predicate, column_offsets); + auto plan_ptr = std::make_shared( + catalog_table_, predicate, column_offsets); planner::BindingContext scan_context; plan_ptr->PerformBinding(scan_context); @@ -269,16 +271,18 @@ AbstractCatalog::GetResultWithCompiledSeqScan(std::vector column_offsets, codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); std::unique_ptr compiled_query(nullptr); cached = (query != nullptr); - //LOG_DEBUG("cache %d", cached); + // LOG_DEBUG("cache %d", cached); // if not cached, compile the query and save it into cache if (!cached) { compiled_query = codegen::QueryCompiler().Compile( - *plan_ptr, executor_context->GetParams().GetQueryParametersMap(), buffer); + *plan_ptr, executor_context->GetParams().GetQueryParametersMap(), + buffer); query = compiled_query.get(); codegen::QueryCache::Instance().Add(plan_ptr, std::move(compiled_query)); } - query->Execute(std::move(executor_context), buffer, [](executor::ExecutionResult result){return result;}); + query->Execute(std::move(executor_context), buffer, + [](executor::ExecutionResult result) { return result; }); return buffer.GetOutputTuples(); } diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 3ed19e68dc1..9e3a8cdf53f 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); } @@ -614,18 +614,18 @@ ResultType Catalog::DropIndex(oid_t index_oid, ResultType Catalog::DropIndex(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 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); - return result; + return result; } //===--------------------------------------------------------------------===// @@ -1064,11 +1064,11 @@ 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, @@ -1105,33 +1105,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, diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index 34e3f612c34..f951d839c43 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -43,34 +43,29 @@ ColumnCatalogObject::ColumnCatalogObject(executor::LogicalTile *tile, is_not_null(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_NOT_NULL) .GetAs()) {} +ColumnCatalogObject::ColumnCatalogObject(codegen::WrappedTuple wrapped_tuple) + : table_oid(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::TABLE_OID) + .GetAs()), + column_name(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_NAME) + .ToString()), + column_id(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_ID) + .GetAs()), + column_offset( + wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_OFFSET) + .GetAs()), + column_type(StringToTypeId( + wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_TYPE) + .ToString())), + is_inlined(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_INLINED) + .GetAs()), + is_primary(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_PRIMARY) + .GetAs()), + is_not_null(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_NOT_NULL) + .GetAs()) {} - ColumnCatalogObject::ColumnCatalogObject(codegen::WrappedTuple wrapped_tuple) - : table_oid(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::TABLE_OID) - .GetAs()), - column_name(wrapped_tuple.GetValue( ColumnCatalog::ColumnId::COLUMN_NAME) - .ToString()), - column_id(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_ID) - .GetAs()), - column_offset( - wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_OFFSET) - .GetAs()), - column_type(StringToTypeId( - wrapped_tuple.GetValue( ColumnCatalog::ColumnId::COLUMN_TYPE) - .ToString())), - is_inlined(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_INLINED) - .GetAs()), - is_primary(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_PRIMARY) - .GetAs()), - is_not_null(wrapped_tuple.GetValue(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; } @@ -260,25 +255,23 @@ ColumnCatalog::GetColumnObjects(oid_t table_oid, // cache miss, get from pg_attribute std::vector column_ids(all_column_ids); - expression::AbstractExpression *tb_oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); - expression::AbstractExpression *tb_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *tb_oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + expression::AbstractExpression *tb_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); expression::AbstractExpression *col_oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, tb_oid_expr, - tb_oid_const_expr); + ExpressionType::COMPARE_EQUAL, tb_oid_expr, tb_oid_const_expr); expression::AbstractExpression *predicate = col_oid_equality_expr; std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); for (auto tuple : result_tuples) { - - auto column_object = - std::make_shared(tuple); + auto column_object = std::make_shared(tuple); table_object->InsertColumnObject(column_object); - } return table_object->GetColumnObjects(); diff --git a/src/catalog/column_stats_catalog.cpp b/src/catalog/column_stats_catalog.cpp index bc52cc9787e..fc60e8403d5 100644 --- a/src/catalog/column_stats_catalog.cpp +++ b/src/catalog/column_stats_catalog.cpp @@ -112,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; @@ -133,38 +133,43 @@ std::unique_ptr> ColumnStatsCatalog::GetColumnStats( ColumnId::MOST_COMMON_VALS, ColumnId::MOST_COMMON_FREQS, ColumnId::HISTOGRAM_BOUNDS, ColumnId::COLUMN_NAME, ColumnId::HAS_INDEX}); - expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::DATABASE_ID); - expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(database_id).Copy()); + expression::AbstractExpression *db_oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_ID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_id).Copy()); expression::AbstractExpression *db_oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, db_oid_expr, - db_oid_const_expr); - - expression::AbstractExpression *tb_oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::TABLE_ID); - expression::AbstractExpression *tb_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(table_id).Copy()); + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); + + expression::AbstractExpression *tb_oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::TABLE_ID); + expression::AbstractExpression *tb_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_id).Copy()); expression::AbstractExpression *tb_oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, tb_oid_expr, - tb_oid_const_expr); - - expression::AbstractExpression *col_id_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::COLUMN_ID); - expression::AbstractExpression *col_id_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(column_id).Copy()); + ExpressionType::COMPARE_EQUAL, tb_oid_expr, tb_oid_const_expr); + + expression::AbstractExpression *col_id_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::COLUMN_ID); + expression::AbstractExpression *col_id_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(column_id).Copy()); expression::AbstractExpression *col_oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, col_id_expr, - col_id_const_expr); - - expression::AbstractExpression *db_and_tb = expression::ExpressionUtil::ConjunctionFactory( - ExpressionType::CONJUNCTION_AND, db_oid_equality_expr, tb_oid_equality_expr); - expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( - ExpressionType::CONJUNCTION_AND, db_and_tb, col_oid_equality_expr); + ExpressionType::COMPARE_EQUAL, col_id_expr, col_id_const_expr); + expression::AbstractExpression *db_and_tb = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_oid_equality_expr, + tb_oid_equality_expr); + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_and_tb, col_oid_equality_expr); std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); @@ -199,8 +204,8 @@ std::unique_ptr> ColumnStatsCatalog::GetColumnStats( // Return value: number of column stats size_t ColumnStatsCatalog::GetTableStats( oid_t database_id, oid_t table_id, concurrency::TransactionContext *txn, - std::map>> - &column_stats_map) { + std::map>> & + column_stats_map) { std::vector column_ids( {ColumnId::COLUMN_ID, ColumnId::NUM_ROWS, ColumnId::CARDINALITY, ColumnId::FRAC_NULL, ColumnId::MOST_COMMON_VALS, diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 4d060b14b7d..8976865d4b7 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -27,8 +27,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) @@ -38,12 +38,14 @@ DatabaseCatalogObject::DatabaseCatalogObject(executor::LogicalTile *tile, valid_table_objects(false), txn(txn) {} -DatabaseCatalogObject::DatabaseCatalogObject(codegen::WrappedTuple wrapped_tuple, - concurrency::TransactionContext *txn) - : database_oid(wrapped_tuple.GetValue(DatabaseCatalog::ColumnId::DATABASE_OID) - .GetAs()), - database_name(wrapped_tuple.GetValue(DatabaseCatalog::ColumnId::DATABASE_NAME) - .ToString()), +DatabaseCatalogObject::DatabaseCatalogObject( + codegen::WrappedTuple wrapped_tuple, concurrency::TransactionContext *txn) + : database_oid( + wrapped_tuple.GetValue(DatabaseCatalog::ColumnId::DATABASE_OID) + .GetAs()), + database_name( + wrapped_tuple.GetValue(DatabaseCatalog::ColumnId::DATABASE_NAME) + .ToString()), table_objects_cache(), table_name_cache(), valid_table_objects(false), @@ -209,9 +211,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; } @@ -303,18 +305,18 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( // cache miss, get from pg_database std::vector column_ids(all_column_ids); - expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::DATABASE_OID); - expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::AbstractExpression *db_oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); expression::AbstractExpression *db_oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, db_oid_expr, - db_oid_const_expr); + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); expression::AbstractExpression *predicate = db_oid_equality_expr; - auto result_tuples = - GetResultWithCompiledSeqScan(column_ids, predicate, txn); + auto result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); if (result_tuples.size() == 1) { auto database_object = @@ -349,14 +351,15 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( // cache miss, get from pg_database std::vector column_ids(all_column_ids); - expression::AbstractExpression *db_name_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::VARCHAR, 0, ColumnId::DATABASE_NAME); - expression::AbstractExpression *db_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetVarcharValue(database_name, nullptr).Copy()); + expression::AbstractExpression *db_name_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + ColumnId::DATABASE_NAME); + expression::AbstractExpression *db_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(database_name, nullptr).Copy()); expression::AbstractExpression *db_name_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, db_name_expr, - db_name_const_expr); + ExpressionType::COMPARE_EQUAL, db_name_expr, db_name_const_expr); std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, db_name_equality_expr, txn); @@ -367,7 +370,7 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( // insert into cache bool success = txn->catalog_cache.InsertDatabaseObject(database_object); PELOTON_ASSERT(success == true); - (void) success; + (void)success; return database_object; } diff --git a/src/catalog/database_metrics_catalog.cpp b/src/catalog/database_metrics_catalog.cpp index ff670639764..475eb4bd919 100644 --- a/src/catalog/database_metrics_catalog.cpp +++ b/src/catalog/database_metrics_catalog.cpp @@ -25,7 +25,8 @@ 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 " (" @@ -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_catalog.cpp b/src/catalog/index_catalog.cpp index ad34ba6fece..b77011b915e 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -203,7 +203,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()); @@ -232,27 +233,26 @@ std::shared_ptr IndexCatalog::GetIndexObject( // cache miss, get from pg_index std::vector column_ids(all_column_ids); - expression::AbstractExpression *idx_oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::INDEX_OID); - expression::AbstractExpression *idx_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(index_oid).Copy()); + expression::AbstractExpression *idx_oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::INDEX_OID); + expression::AbstractExpression *idx_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(index_oid).Copy()); expression::AbstractExpression *idx_oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, idx_oid_expr, - idx_oid_const_expr); - + ExpressionType::COMPARE_EQUAL, idx_oid_expr, idx_oid_const_expr); std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, idx_oid_equality_expr, txn); if (result_tuples.size() == 1) { - auto index_object = - std::make_shared(result_tuples[0]); + auto index_object = std::make_shared(result_tuples[0]); // 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 && - table_object->GetTableOid() == index_object->GetTableOid()); + table_object->GetTableOid() == index_object->GetTableOid()); return table_object->GetIndexObject(index_oid); } else { LOG_DEBUG("Found %lu index with oid %u", result_tuples.size(), index_oid); @@ -276,26 +276,26 @@ std::shared_ptr IndexCatalog::GetIndexObject( // cache miss, get from pg_index std::vector column_ids(all_column_ids); - expression::AbstractExpression *idx_name_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::VARCHAR, 0, ColumnId::INDEX_NAME); - expression::AbstractExpression *idx_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetVarcharValue(index_name, nullptr).Copy()); + expression::AbstractExpression *idx_name_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + ColumnId::INDEX_NAME); + expression::AbstractExpression *idx_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(index_name, nullptr).Copy()); expression::AbstractExpression *idx_name_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, idx_name_expr, - idx_name_const_expr); + ExpressionType::COMPARE_EQUAL, idx_name_expr, idx_name_const_expr); std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, idx_name_equality_expr, txn); if (result_tuples.size() == 1) { - auto index_object = - std::make_shared(result_tuples[0]); + auto index_object = std::make_shared(result_tuples[0]); // 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 && - table_object->GetTableOid() == index_object->GetTableOid()); + table_object->GetTableOid() == index_object->GetTableOid()); return table_object->GetIndexObject(index_name); } else { LOG_DEBUG("Found %lu index with name %s", result_tuples.size(), @@ -313,7 +313,8 @@ 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!"); } @@ -327,25 +328,22 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, concurrency::TransactionContext * // cache miss, get from pg_index std::vector column_ids(all_column_ids); - expression::AbstractExpression *oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); - expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + expression::AbstractExpression *oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); expression::AbstractExpression *oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( ExpressionType::COMPARE_EQUAL, oid_expr, oid_const_expr); - std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, oid_equality_expr, txn); - for (auto tuple : result_tuples) { - - auto index_object = - std::make_shared(tuple); + auto index_object = std::make_shared(tuple); table_object->InsertIndexObject(index_object); - } return table_object->GetIndexObjects(); diff --git a/src/catalog/index_metrics_catalog.cpp b/src/catalog/index_metrics_catalog.cpp index 3ca114e8c98..6c8c2245fe9 100644 --- a/src/catalog/index_metrics_catalog.cpp +++ b/src/catalog/index_metrics_catalog.cpp @@ -69,8 +69,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/language_catalog.cpp b/src/catalog/language_catalog.cpp index 0e105da1afa..6451ca45902 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -26,11 +26,12 @@ LanguageCatalogObject::LanguageCatalogObject(executor::LogicalTile *tuple) : lang_oid_(tuple->GetValue(0, 0).GetAs()), lang_name_(tuple->GetValue(0, 1).GetAs()) {} - LanguageCatalogObject::LanguageCatalogObject(codegen::WrappedTuple tuple) - : lang_oid_(tuple.GetValue(0).GetAs()), - lang_name_(tuple.GetValue(1).GetAs()) {} +LanguageCatalogObject::LanguageCatalogObject(codegen::WrappedTuple tuple) + : lang_oid_(tuple.GetValue(0).GetAs()), + lang_name_(tuple.GetValue(1).GetAs()) {} -LanguageCatalog &LanguageCatalog::GetInstance(concurrency::TransactionContext *txn) { +LanguageCatalog &LanguageCatalog::GetInstance( + concurrency::TransactionContext *txn) { static LanguageCatalog language_catalog{txn}; return language_catalog; } @@ -83,15 +84,16 @@ std::unique_ptr LanguageCatalog::GetLanguageByOid( oid_t lang_oid, concurrency::TransactionContext *txn) const { std::vector column_ids(all_column_ids); - expression::AbstractExpression *oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::OID); - expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(lang_oid).Copy()); + expression::AbstractExpression *oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::OID); + expression::AbstractExpression *oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(lang_oid).Copy()); expression::AbstractExpression *oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( ExpressionType::COMPARE_EQUAL, oid_expr, oid_const_expr); - std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, oid_equality_expr, txn); @@ -109,14 +111,15 @@ std::unique_ptr LanguageCatalog::GetLanguageByName( const std::string &lang_name, concurrency::TransactionContext *txn) const { std::vector column_ids(all_column_ids); - expression::AbstractExpression *name_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::VARCHAR, 0, ColumnId::LANNAME); - expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetVarcharValue(lang_name, nullptr).Copy()); + expression::AbstractExpression *name_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + ColumnId::LANNAME); + expression::AbstractExpression *name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(lang_name, nullptr).Copy()); expression::AbstractExpression *name_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, name_expr, - name_const_expr); + ExpressionType::COMPARE_EQUAL, name_expr, name_const_expr); std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, name_equality_expr, txn); diff --git a/src/catalog/proc_catalog.cpp b/src/catalog/proc_catalog.cpp index 4cd04c95c09..0052fceee41 100644 --- a/src/catalog/proc_catalog.cpp +++ b/src/catalog/proc_catalog.cpp @@ -35,13 +35,13 @@ ProcCatalogObject::ProcCatalogObject(executor::LogicalTile *tile, src_(tile->GetValue(0, 5).GetAs()), txn_(txn) {} - ProcCatalogObject::ProcCatalogObject(codegen::WrappedTuple wrapped_tuple, concurrency::TransactionContext *txn) : oid_(wrapped_tuple.GetValue(0).GetAs()), name_(wrapped_tuple.GetValue(1).GetAs()), ret_type_(wrapped_tuple.GetValue(2).GetAs()), - arg_types_(StringToTypeArray(wrapped_tuple.GetValue(3).GetAs())), + arg_types_( + StringToTypeArray(wrapped_tuple.GetValue(3).GetAs())), lang_oid_(wrapped_tuple.GetValue(4).GetAs()), src_(wrapped_tuple.GetValue(5).GetAs()), txn_(txn) {} @@ -128,27 +128,31 @@ std::unique_ptr ProcCatalog::GetProcByName( concurrency::TransactionContext *txn) const { std::vector column_ids(all_column_ids); - expression::AbstractExpression *proc_name_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::VARCHAR, 0, ColumnId::PRONAME); - expression::AbstractExpression *proc_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetVarcharValue(proc_name, nullptr).Copy()); + expression::AbstractExpression *proc_name_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + ColumnId::PRONAME); + expression::AbstractExpression *proc_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(proc_name, nullptr).Copy()); expression::AbstractExpression *proc_name_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, proc_name_expr, - proc_name_const_expr); - - expression::AbstractExpression *proc_args_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::VARCHAR, 0, ColumnId::PROARGTYPES); - expression::AbstractExpression *proc_args_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetVarcharValue(TypeIdArrayToString(proc_arg_types)).Copy()); + ExpressionType::COMPARE_EQUAL, proc_name_expr, proc_name_const_expr); + + expression::AbstractExpression *proc_args_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + ColumnId::PROARGTYPES); + expression::AbstractExpression *proc_args_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue( + TypeIdArrayToString(proc_arg_types)).Copy()); expression::AbstractExpression *proc_args_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, proc_args_expr, - proc_args_const_expr); - - expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( - ExpressionType::CONJUNCTION_AND, proc_name_equality_expr, proc_args_equality_expr); + ExpressionType::COMPARE_EQUAL, proc_args_expr, proc_args_const_expr); + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, proc_name_equality_expr, + proc_args_equality_expr); std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 0f3f98320df..5c501b0b8d9 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -106,9 +106,9 @@ bool QueryMetricsCatalog::InsertQueryMetrics( return InsertTuple(std::move(tuple), txn); } -bool QueryMetricsCatalog::DeleteQueryMetrics(const std::string &name, - oid_t database_oid, - concurrency::TransactionContext *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 std::vector values; @@ -145,9 +145,9 @@ 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 std::vector values; diff --git a/src/catalog/schema.cpp b/src/catalog/schema.cpp index e3e088e607a..9fa15702b6c 100644 --- a/src/catalog/schema.cpp +++ b/src/catalog/schema.cpp @@ -21,11 +21,10 @@ namespace peloton { namespace catalog { // Helper function for creating TupleSchema -void Schema::CreateTupleSchema( - const std::vector &column_types, - const std::vector &column_lengths, - const std::vector &column_names, - const std::vector &is_inlined) { +void Schema::CreateTupleSchema(const std::vector &column_types, + const std::vector &column_lengths, + const std::vector &column_names, + const std::vector &is_inlined) { bool tup_is_inlined = true; oid_t num_columns = column_types.size(); oid_t column_offset = 0; diff --git a/src/catalog/settings_catalog.cpp b/src/catalog/settings_catalog.cpp index 190d62b3caf..66ce9ea99d7 100644 --- a/src/catalog/settings_catalog.cpp +++ b/src/catalog/settings_catalog.cpp @@ -23,7 +23,8 @@ namespace peloton { namespace catalog { -SettingsCatalog &SettingsCatalog::GetInstance(concurrency::TransactionContext *txn) { +SettingsCatalog &SettingsCatalog::GetInstance( + concurrency::TransactionContext *txn) { static SettingsCatalog settings_catalog{txn}; return settings_catalog; } @@ -94,18 +95,19 @@ 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)}); - expression::AbstractExpression *name_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::VARCHAR, 0, ColumnId::NAME); - expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); + expression::AbstractExpression *name_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + ColumnId::NAME); + expression::AbstractExpression *name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); expression::AbstractExpression *name_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, name_expr, - name_const_expr); + ExpressionType::COMPARE_EQUAL, name_expr, name_const_expr); std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, name_equality_expr, txn); @@ -113,25 +115,24 @@ std::string SettingsCatalog::GetSettingValue(const std::string &name, std::string config_value = ""; PELOTON_ASSERT(result_tuples.size() <= 1); if (result_tuples.size() != 0) { - config_value = (result_tuples[0]).GetValue(0).ToString(); - } 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)}); - expression::AbstractExpression *name_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::VARCHAR, 0, ColumnId::NAME); - expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); + expression::AbstractExpression *name_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + ColumnId::NAME); + expression::AbstractExpression *name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); expression::AbstractExpression *name_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, name_expr, - name_const_expr); + ExpressionType::COMPARE_EQUAL, name_expr, name_const_expr); std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, name_equality_expr, txn); @@ -139,7 +140,7 @@ std::string SettingsCatalog::GetDefaultValue(const std::string &name, std::string config_value = ""; PELOTON_ASSERT(result_tuples.size() <= 1); if (result_tuples.size() != 0) { - config_value = result_tuples[0].GetValue(0).ToString(); + config_value = result_tuples[0].GetValue(0).ToString(); } return config_value; } diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 71e5942a953..13e7ca171dd 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -399,7 +399,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()); @@ -483,45 +484,49 @@ std::shared_ptr TableCatalog::GetTableObject( // need the predicate for the seq scan (conjunction) // table_name == table_name and database_oid need to be same // only need to get the logical tiles that wrap oid, name, db_oid - expression::AbstractExpression *table_name_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::VARCHAR, 0, ColumnId::TABLE_NAME); - expression::AbstractExpression *table_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetVarcharValue(table_name, nullptr).Copy()); + expression::AbstractExpression *table_name_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + ColumnId::TABLE_NAME); + expression::AbstractExpression *table_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(table_name, nullptr).Copy()); expression::AbstractExpression *table_name_equality_expr = - expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, table_name_expr, - table_name_const_expr); - - expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::DATABASE_OID); - expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, table_name_expr, + table_name_const_expr); + + expression::AbstractExpression *db_oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); expression::AbstractExpression *db_oid_equality_expr = - expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, db_oid_expr, - db_oid_const_expr); - - expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( - ExpressionType::CONJUNCTION_AND, table_name_equality_expr, db_oid_equality_expr); + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, table_name_equality_expr, + db_oid_equality_expr); // LOG_DEBUG("Get table: %s", predicate->GetInfo().c_str()); // change this to seq plan // ceate predicate refering to seq_scan_test.cpp std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); - //LOG_DEBUG("Result size: %lu", result_tuples.size()); + // LOG_DEBUG("Result size: %lu", result_tuples.size()); if (result_tuples.size() == 1) { auto table_object = - std::make_shared(result_tuples[0], txn); + std::make_shared(result_tuples[0], txn); // insert into cache auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( - table_object->GetDatabaseOid(), txn); + table_object->GetDatabaseOid(), txn); PELOTON_ASSERT(database_object); bool success = database_object->InsertTableObject(table_object); PELOTON_ASSERT(success == true); - (void) success; + (void)success; return table_object; } @@ -552,25 +557,23 @@ TableCatalog::GetTableObjects(oid_t database_oid, // cache miss, get from pg_table std::vector column_ids(all_column_ids); - expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::DATABASE_OID); - expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::AbstractExpression *db_oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); expression::AbstractExpression *db_oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, db_oid_expr, - db_oid_const_expr); + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); expression::AbstractExpression *predicate = db_oid_equality_expr; std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); for (auto tuple : result_tuples) { - - auto table_object = - std::make_shared(tuple, txn); + auto table_object = std::make_shared(tuple, txn); database_object->InsertTableObject(table_object); - } database_object->SetValidTableObjects(true); diff --git a/src/catalog/table_metrics_catalog.cpp b/src/catalog/table_metrics_catalog.cpp index 45c603c97f2..5b3ac52b371 100644 --- a/src/catalog/table_metrics_catalog.cpp +++ b/src/catalog/table_metrics_catalog.cpp @@ -69,8 +69,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/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index fb2044873e3..7c286520fe5 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -23,7 +23,8 @@ namespace peloton { namespace catalog { -TriggerCatalog &TriggerCatalog::GetInstance(concurrency::TransactionContext *txn) { +TriggerCatalog &TriggerCatalog::GetInstance( + concurrency::TransactionContext *txn) { static TriggerCatalog trigger_catalog{txn}; return trigger_catalog; } @@ -135,26 +136,30 @@ oid_t TriggerCatalog::GetTriggerOid(std::string trigger_name, oid_t table_oid, concurrency::TransactionContext *txn) { std::vector column_ids({ColumnId::TRIGGER_OID}); - expression::AbstractExpression *name_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::VARCHAR, 0, ColumnId::TRIGGER_NAME); - expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetVarcharValue(trigger_name, nullptr).Copy()); + expression::AbstractExpression *name_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + ColumnId::TRIGGER_NAME); + expression::AbstractExpression *name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(trigger_name, nullptr).Copy()); expression::AbstractExpression *name_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, name_expr, - name_const_expr); - - expression::AbstractExpression *oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); - expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(table_oid).Copy()); + ExpressionType::COMPARE_EQUAL, name_expr, name_const_expr); + + expression::AbstractExpression *oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + expression::AbstractExpression *oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); expression::AbstractExpression *oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, oid_expr, - oid_const_expr); + ExpressionType::COMPARE_EQUAL, oid_expr, oid_const_expr); - expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( - ExpressionType::CONJUNCTION_AND, name_equality_expr, oid_equality_expr); + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, name_equality_expr, + oid_equality_expr); std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); @@ -185,33 +190,38 @@ 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( {ColumnId::TRIGGER_NAME, ColumnId::FIRE_CONDITION, ColumnId::FUNCTION_OID, ColumnId::FUNCTION_ARGS}); - expression::AbstractExpression *type_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::SMALLINT, 0, ColumnId::TRIGGER_TYPE); - expression::AbstractExpression *type_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetSmallIntValue(trigger_type).Copy()); + expression::AbstractExpression *type_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::SMALLINT, 0, + ColumnId::TRIGGER_TYPE); + expression::AbstractExpression *type_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetSmallIntValue(trigger_type).Copy()); expression::AbstractExpression *type_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, type_expr, - type_const_expr); - - expression::AbstractExpression *oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); - expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(table_oid).Copy()); + ExpressionType::COMPARE_EQUAL, type_expr, type_const_expr); + + expression::AbstractExpression *oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + expression::AbstractExpression *oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); expression::AbstractExpression *oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, oid_expr, - oid_const_expr); + ExpressionType::COMPARE_EQUAL, oid_expr, oid_const_expr); - expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( - ExpressionType::CONJUNCTION_AND, type_equality_expr, oid_equality_expr); + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, type_equality_expr, + oid_equality_expr); std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); @@ -219,20 +229,18 @@ std::unique_ptr TriggerCatalog::GetTriggersByType( // carefull! the result could be null! LOG_INFO("size of the result tiles = %lu", result_tuples.size()); - // create the trigger list std::unique_ptr new_trigger_list{ new trigger::TriggerList()}; for (unsigned int i = 0; i < result_tuples.size(); i++) { - // create a new trigger instance - trigger::Trigger new_trigger( - result_tuples[i].GetValue(0).ToString(), trigger_type, - result_tuples[i].GetValue(2).ToString(), - result_tuples[i].GetValue(3).ToString(), - result_tuples[i].GetValue(1).GetData()); - new_trigger_list->AddTrigger(new_trigger); - + // create a new trigger instance + trigger::Trigger new_trigger(result_tuples[i].GetValue(0).ToString(), + trigger_type, + result_tuples[i].GetValue(2).ToString(), + result_tuples[i].GetValue(3).ToString(), + result_tuples[i].GetValue(1).GetData()); + new_trigger_list->AddTrigger(new_trigger); } return new_trigger_list; @@ -245,14 +253,15 @@ std::unique_ptr TriggerCatalog::GetTriggers( std::vector column_ids( {ColumnId::TRIGGER_NAME, ColumnId::TRIGGER_TYPE, ColumnId::FIRE_CONDITION, ColumnId::FUNCTION_OID, ColumnId::FUNCTION_ARGS}); - expression::AbstractExpression *oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); - expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + expression::AbstractExpression *oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); expression::AbstractExpression *oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, oid_expr, - oid_const_expr); + ExpressionType::COMPARE_EQUAL, oid_expr, oid_const_expr); std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, oid_equality_expr, txn); @@ -260,20 +269,18 @@ std::unique_ptr TriggerCatalog::GetTriggers( // carefull! the result tile could be null! LOG_INFO("size of the result tiles = %lu", result_tuples.size()); -// create the trigger list + // create the trigger list std::unique_ptr new_trigger_list{ new trigger::TriggerList()}; for (unsigned int i = 0; i < result_tuples.size(); i++) { // create a new trigger instance - trigger::Trigger new_trigger( - result_tuples[i].GetValue(0).ToString(), - result_tuples[i].GetValue(1).GetAs(), - result_tuples[i].GetValue(3).ToString(), - result_tuples[i].GetValue(4).ToString(), - result_tuples[i].GetValue(2).GetData()); + trigger::Trigger new_trigger(result_tuples[i].GetValue(0).ToString(), + result_tuples[i].GetValue(1).GetAs(), + result_tuples[i].GetValue(3).ToString(), + result_tuples[i].GetValue(4).ToString(), + result_tuples[i].GetValue(2).GetData()); new_trigger_list->AddTrigger(new_trigger); - } return new_trigger_list; diff --git a/src/catalog/zone_map_catalog.cpp b/src/catalog/zone_map_catalog.cpp index aeefac82146..b9749407bac 100644 --- a/src/catalog/zone_map_catalog.cpp +++ b/src/catalog/zone_map_catalog.cpp @@ -10,7 +10,6 @@ // //===----------------------------------------------------------------------===// - #include "catalog/zone_map_catalog.h" #include "catalog/catalog.h" @@ -29,7 +28,8 @@ 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; } @@ -70,8 +70,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); @@ -80,74 +82,77 @@ 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)}); - - expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::DATABASE_ID); - expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(database_id).Copy()); + std::vector column_ids({static_cast(ColumnId::MINIMUM), + static_cast(ColumnId::MAXIMUM), + static_cast(ColumnId::TYPE)}); + + expression::AbstractExpression *db_oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_ID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_id).Copy()); expression::AbstractExpression *db_oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, db_oid_expr, - db_oid_const_expr); - - expression::AbstractExpression *tb_oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::TABLE_ID); - expression::AbstractExpression *tb_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(table_id).Copy()); + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); + + expression::AbstractExpression *tb_oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::TABLE_ID); + expression::AbstractExpression *tb_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_id).Copy()); expression::AbstractExpression *tb_oid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, tb_oid_expr, - tb_oid_const_expr); - - expression::AbstractExpression *tile_gid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::TILE_GROUP_ID); - expression::AbstractExpression *tile_gid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(tile_group_id).Copy()); + ExpressionType::COMPARE_EQUAL, tb_oid_expr, tb_oid_const_expr); + + expression::AbstractExpression *tile_gid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::TILE_GROUP_ID); + expression::AbstractExpression *tile_gid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(tile_group_id).Copy()); expression::AbstractExpression *tile_gid_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, tile_gid_expr, - tile_gid_const_expr); - - expression::AbstractExpression *col_oid_expr = expression::ExpressionUtil::TupleValueFactory( - type::TypeId::INTEGER, 0, ColumnId::COLUMN_ID); - expression::AbstractExpression *col_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(column_id).Copy()); + ExpressionType::COMPARE_EQUAL, tile_gid_expr, tile_gid_const_expr); + + expression::AbstractExpression *col_oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::COLUMN_ID); + expression::AbstractExpression *col_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(column_id).Copy()); expression::AbstractExpression *col_id_equality_expr = expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, col_oid_expr, - col_oid_const_expr); - - expression::AbstractExpression *db_and_tb = expression::ExpressionUtil::ConjunctionFactory( - ExpressionType::CONJUNCTION_AND, db_oid_equality_expr, tb_oid_equality_expr); - expression::AbstractExpression *pred_and_tile = expression::ExpressionUtil::ConjunctionFactory( - ExpressionType::CONJUNCTION_AND, db_and_tb, tile_gid_equality_expr); - expression::AbstractExpression *predicate = expression::ExpressionUtil::ConjunctionFactory( - ExpressionType::CONJUNCTION_AND, pred_and_tile, col_id_equality_expr); - - - auto result_tuples = - GetResultWithCompiledSeqScan(column_ids, predicate, txn); + ExpressionType::COMPARE_EQUAL, col_oid_expr, col_oid_const_expr); + + expression::AbstractExpression *db_and_tb = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_oid_equality_expr, + tb_oid_equality_expr); + expression::AbstractExpression *pred_and_tile = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_and_tb, tile_gid_equality_expr); + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, pred_and_tile, col_id_equality_expr); + + auto result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); PELOTON_ASSERT(result_tuples.size() <= 1); // unique if (result_tuples.size() == 0) { diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index 6ca793e464c..c1c6f4cf1ac 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -75,19 +75,18 @@ class AbstractCatalog { std::unique_ptr>> GetResultWithSeqScan(std::vector column_offsets, - expression::AbstractExpression *predicate, - concurrency::TransactionContext *txn); - - std::vector - GetResultWithCompiledSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, - concurrency::TransactionContext *txn) const; + concurrency::TransactionContext *txn); + + std::vector GetResultWithCompiledSeqScan( + std::vector column_offsets, + expression::AbstractExpression *predicate, + concurrency::TransactionContext *txn) const; void AddIndex(const std::vector &key_attrs, oid_t index_oid, const std::string &index_name, IndexConstraintType index_constraint); - //===--------------------------------------------------------------------===// // Members //===--------------------------------------------------------------------===// diff --git a/src/include/catalog/column.h b/src/include/catalog/column.h index f351f72c5b9..6abc62ccce0 100644 --- a/src/include/catalog/column.h +++ b/src/include/catalog/column.h @@ -33,9 +33,8 @@ class Column : public Printable { // Nothing to see... } - Column(type::TypeId value_type, size_t column_length, - std::string column_name, bool is_inlined = false, - oid_t column_offset = INVALID_OID) + Column(type::TypeId value_type, size_t column_length, std::string column_name, + bool is_inlined = false, oid_t column_offset = INVALID_OID) : column_name(column_name), column_type(value_type), fixed_length(INVALID_OID), diff --git a/src/include/catalog/column_catalog.h b/src/include/catalog/column_catalog.h index 7dda9da6e09..3daa9fbe6ab 100644 --- a/src/include/catalog/column_catalog.h +++ b/src/include/catalog/column_catalog.h @@ -71,9 +71,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(); @@ -87,7 +88,8 @@ class ColumnCatalog : public AbstractCatalog { oid_t column_id, oid_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); diff --git a/src/include/catalog/constraint.h b/src/include/catalog/constraint.h index c63b881c727..67f5b391d3c 100644 --- a/src/include/catalog/constraint.h +++ b/src/include/catalog/constraint.h @@ -10,7 +10,6 @@ // //===----------------------------------------------------------------------===// - #pragma once #include @@ -65,16 +64,15 @@ class Constraint : public Printable { // Todo: default union data structure, // For default constraint void addDefaultValue(const type::Value &value) { - if (constraint_type != ConstraintType::DEFAULT || default_value.get() != nullptr) { + if (constraint_type != ConstraintType::DEFAULT || + default_value.get() != nullptr) { return; } default_value.reset(new peloton::type::Value(value)); } - type::Value* getDefaultValue() { - return default_value.get(); - } + type::Value *getDefaultValue() { return default_value.get(); } // Add check constrain void AddCheck(ExpressionType op, peloton::type::Value val) { diff --git a/src/include/catalog/database_catalog.h b/src/include/catalog/database_catalog.h index 6857dc3a7bb..5f23c792f78 100644 --- a/src/include/catalog/database_catalog.h +++ b/src/include/catalog/database_catalog.h @@ -100,9 +100,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; } @@ -110,7 +111,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/database_metrics_catalog.h b/src/include/catalog/database_metrics_catalog.h index a035063a1a5..1eae00bc325 100644 --- a/src/include/catalog/database_metrics_catalog.h +++ b/src/include/catalog/database_metrics_catalog.h @@ -49,7 +49,8 @@ class DatabaseMetricsCatalog : public AbstractCatalog { oid_t txn_aborted, oid_t time_stamp, type::AbstractPool *pool, concurrency::TransactionContext *txn); - bool DeleteDatabaseMetrics(oid_t database_oid, concurrency::TransactionContext *txn); + bool DeleteDatabaseMetrics(oid_t database_oid, + concurrency::TransactionContext *txn); //===--------------------------------------------------------------------===// // Read-only Related API diff --git a/src/include/catalog/foreign_key.h b/src/include/catalog/foreign_key.h index 02b28d7abf6..a69897fe1e0 100644 --- a/src/include/catalog/foreign_key.h +++ b/src/include/catalog/foreign_key.h @@ -10,7 +10,6 @@ // //===----------------------------------------------------------------------===// - #pragma once #include @@ -28,12 +27,9 @@ namespace catalog { // Stores info about foreign key constraints, like the sink table id etc. class ForeignKey { public: - ForeignKey(oid_t source_table_id, - oid_t sink_table_id, - std::vector sink_col_ids, - std::vector source_col_ids, - FKConstrActionType update_action, - FKConstrActionType delete_action, + ForeignKey(oid_t source_table_id, oid_t sink_table_id, + std::vector sink_col_ids, std::vector source_col_ids, + FKConstrActionType update_action, FKConstrActionType delete_action, std::string constraint_name) : source_table_id(source_table_id), diff --git a/src/include/catalog/index_metrics_catalog.h b/src/include/catalog/index_metrics_catalog.h index ca64280457b..8a83eb13694 100644 --- a/src/include/catalog/index_metrics_catalog.h +++ b/src/include/catalog/index_metrics_catalog.h @@ -52,7 +52,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 diff --git a/src/include/catalog/language_catalog.h b/src/include/catalog/language_catalog.h index cec643fabd5..ce5f5b49197 100644 --- a/src/include/catalog/language_catalog.h +++ b/src/include/catalog/language_catalog.h @@ -55,7 +55,8 @@ class LanguageCatalog : public AbstractCatalog { ~LanguageCatalog(); // Global Singleton - static LanguageCatalog &GetInstance(concurrency::TransactionContext *txn = nullptr); + static LanguageCatalog &GetInstance( + concurrency::TransactionContext *txn = nullptr); //===--------------------------------------------------------------------===// // write Related API diff --git a/src/include/catalog/proc_catalog.h b/src/include/catalog/proc_catalog.h index 37322b65662..71ea0ab090a 100644 --- a/src/include/catalog/proc_catalog.h +++ b/src/include/catalog/proc_catalog.h @@ -41,8 +41,10 @@ class LanguageCatalogObject; //===----------------------------------------------------------------------===// class ProcCatalogObject { public: - ProcCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn); - ProcCatalogObject(codegen::WrappedTuple wrapped_tuple, concurrency::TransactionContext *txn); + ProcCatalogObject(executor::LogicalTile *tile, + concurrency::TransactionContext *txn); + ProcCatalogObject(codegen::WrappedTuple wrapped_tuple, + concurrency::TransactionContext *txn); // Accessors oid_t GetOid() const { return oid_; } @@ -80,7 +82,8 @@ class ProcCatalog : public AbstractCatalog { ~ProcCatalog(); // Global Singleton - static ProcCatalog &GetInstance(concurrency::TransactionContext *txn = nullptr); + static ProcCatalog &GetInstance( + concurrency::TransactionContext *txn = nullptr); //===--------------------------------------------------------------------===// // write Related API diff --git a/src/include/catalog/schema.h b/src/include/catalog/schema.h index 8a2feec5dcd..8865c3c696a 100644 --- a/src/include/catalog/schema.h +++ b/src/include/catalog/schema.h @@ -191,7 +191,7 @@ class Schema : public Printable { } // Get the default value for the column - inline type::Value* GetDefaultValue(const oid_t column_id) const { + inline type::Value *GetDefaultValue(const oid_t column_id) const { for (auto constraint : columns[column_id].GetConstraints()) { if (constraint.GetType() == ConstraintType::DEFAULT) { return constraint.getDefaultValue(); diff --git a/src/include/catalog/settings_catalog.h b/src/include/catalog/settings_catalog.h index 1879f5d6d3b..2c78ed61d54 100644 --- a/src/include/catalog/settings_catalog.h +++ b/src/include/catalog/settings_catalog.h @@ -22,7 +22,8 @@ class SettingsCatalog : public AbstractCatalog { ~SettingsCatalog(); // Global Singleton - static SettingsCatalog &GetInstance(concurrency::TransactionContext *txn = nullptr); + static SettingsCatalog &GetInstance( + concurrency::TransactionContext *txn = nullptr); //===--------------------------------------------------------------------===// // write Related API @@ -34,7 +35,8 @@ class SettingsCatalog : public AbstractCatalog { bool is_persistent, type::AbstractPool *pool, concurrency::TransactionContext *txn); - bool DeleteSetting(const std::string &name, concurrency::TransactionContext *txn); + bool DeleteSetting(const std::string &name, + concurrency::TransactionContext *txn); //===--------------------------------------------------------------------===// // Read-only Related API diff --git a/src/include/catalog/table_catalog.h b/src/include/catalog/table_catalog.h index 02fff38e0bf..c50cda51ce3 100644 --- a/src/include/catalog/table_catalog.h +++ b/src/include/catalog/table_catalog.h @@ -45,9 +45,10 @@ class TableCatalogObject { friend class ColumnCatalog; public: - TableCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn, - int tupleId = 0); - TableCatalogObject(codegen::WrappedTuple wrapped_tuple, concurrency::TransactionContext *txn); + TableCatalogObject(executor::LogicalTile *tile, + concurrency::TransactionContext *txn, int tupleId = 0); + TableCatalogObject(codegen::WrappedTuple wrapped_tuple, + concurrency::TransactionContext *txn); public: // Get indexes @@ -120,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; } diff --git a/src/include/catalog/table_metrics_catalog.h b/src/include/catalog/table_metrics_catalog.h index 9f23a15cf17..a55b8de807b 100644 --- a/src/include/catalog/table_metrics_catalog.h +++ b/src/include/catalog/table_metrics_catalog.h @@ -52,7 +52,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 diff --git a/src/include/catalog/trigger_catalog.h b/src/include/catalog/trigger_catalog.h index 14c9acbf888..02b8fa9bb8f 100644 --- a/src/include/catalog/trigger_catalog.h +++ b/src/include/catalog/trigger_catalog.h @@ -50,7 +50,8 @@ class TriggerCatalog : public AbstractCatalog { ~TriggerCatalog(); // Global Singleton - static TriggerCatalog &GetInstance(concurrency::TransactionContext *txn = nullptr); + static TriggerCatalog &GetInstance( + concurrency::TransactionContext *txn = nullptr); //===--------------------------------------------------------------------===// // write Related API @@ -74,7 +75,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 diff --git a/src/include/catalog/zone_map_catalog.h b/src/include/catalog/zone_map_catalog.h index 143230583bb..c5624680a63 100644 --- a/src/include/catalog/zone_map_catalog.h +++ b/src/include/catalog/zone_map_catalog.h @@ -10,7 +10,6 @@ // //===----------------------------------------------------------------------===// - #pragma once #include @@ -31,7 +30,8 @@ class ZoneMapCatalog : public AbstractCatalog { // am sorry to do this. When PelotonMain() becomes a reality, I will // fix this for sure. - static ZoneMapCatalog *GetInstance(concurrency::TransactionContext *txn = nullptr); + static ZoneMapCatalog *GetInstance( + concurrency::TransactionContext *txn = nullptr); //===--------------------------------------------------------------------===// // write Related API @@ -64,11 +64,7 @@ class ZoneMapCatalog : public AbstractCatalog { TYPE = 6 }; - enum ZoneMapOffset { - MINIMUM_OFF = 0, - MAXIMUM_OFF = 1, - TYPE_OFF = 2 - }; + enum ZoneMapOffset { MINIMUM_OFF = 0, MAXIMUM_OFF = 1, TYPE_OFF = 2 }; private: ZoneMapCatalog(concurrency::TransactionContext *txn); From 0f8e163fbe257214ab60d987c0be037a9003dbfa Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Wed, 11 Apr 2018 20:17:42 -0400 Subject: [PATCH 49/85] fix include format --- src/catalog/column_catalog.cpp | 4 ++-- src/catalog/database_catalog.cpp | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index f951d839c43..95334d5b285 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -10,11 +10,11 @@ // //===----------------------------------------------------------------------===// -#include #include "catalog/column_catalog.h" -#include "concurrency/transaction_context.h" #include "catalog/table_catalog.h" +#include "codegen/buffering_consumer.h" +#include "concurrency/transaction_context.h" #include "storage/data_table.h" #include "type/value_factory.h" #include "expression/expression_util.h" diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 8976865d4b7..6fc5153a179 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -11,14 +11,14 @@ //===----------------------------------------------------------------------===// #include -#include "expression/expression_util.h" -#include "codegen/buffering_consumer.h" #include "catalog/database_catalog.h" #include "concurrency/transaction_context.h" #include "catalog/table_catalog.h" #include "catalog/column_catalog.h" +#include "expression/expression_util.h" +#include "codegen/buffering_consumer.h" #include "executor/logical_tile.h" #include "storage/data_table.h" #include "storage/tuple.h" From c74f089960641e7fe73ea093abf0fb4f24d67aab Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Thu, 12 Apr 2018 15:45:00 -0400 Subject: [PATCH 50/85] fix bug in scan plan by prashanth --- src/planner/abstract_scan_plan.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/planner/abstract_scan_plan.cpp b/src/planner/abstract_scan_plan.cpp index a9fa6214412..21a5c85fd6b 100644 --- a/src/planner/abstract_scan_plan.cpp +++ b/src/planner/abstract_scan_plan.cpp @@ -50,7 +50,7 @@ void AbstractScan::PerformBinding(BindingContext &binding_context) { const auto &ai = attributes_[input_col_ids[col_id]]; LOG_TRACE("Attribute '%s.%s' (%u) binds to AI %p", GetTable()->GetName().c_str(), ai.name.c_str(), col_id, &ai); - binding_context.BindNew(col_id, &ai); + binding_context.BindNew(input_col_ids[col_id], &ai); } } From b2c5569ddb0ba72a0b27de41cd7939a091174fc6 Mon Sep 17 00:00:00 2001 From: nickwang Date: Sat, 14 Apr 2018 04:17:05 +0800 Subject: [PATCH 51/85] add index test --- src/catalog/abstract_catalog.cpp | 3 +- src/catalog/catalog.cpp | 4 +- src/catalog/index_catalog.cpp | 48 +++++++++---------- .../expression/comparison_translator.cpp | 2 + src/include/catalog/index_catalog.h | 1 - test/catalog/catalog_test.cpp | 25 ++++++++++ test/optimizer/old_optimizer_test.cpp | 9 ++++ 7 files changed, 62 insertions(+), 30 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index b4db8bedbb2..6d080377c00 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -270,7 +270,8 @@ AbstractCatalog::GetResultWithCompiledSeqScan( // search for query codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); std::unique_ptr compiled_query(nullptr); - cached = (query != nullptr); + // cached = (query != nullptr); + cached = false; // LOG_DEBUG("cache %d", cached); // if not cached, compile the query and save it into cache if (!cached) { diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 9e3a8cdf53f..495aeef0033 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -552,14 +552,14 @@ ResultType Catalog::DropTable(const std::string &database_name, */ ResultType Catalog::DropTable(oid_t database_oid, oid_t table_oid, concurrency::TransactionContext *txn) { - LOG_TRACE("Dropping table %d from database %d", database_oid, table_oid); + LOG_WARN("Dropping table %d from database %d", database_oid, table_oid); auto storage_manager = storage::StorageManager::GetInstance(); auto database = storage_manager->GetDatabaseWithOid(database_oid); auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); auto table_object = database_object->GetTableObject(table_oid); auto index_objects = table_object->GetIndexObjects(); - LOG_TRACE("dropping #%d indexes", (int)index_objects.size()); + LOG_WARN("dropping #%d indexes", (int)index_objects.size()); for (auto it : index_objects) DropIndex(it.second->GetIndexOid(), txn); ColumnCatalog::GetInstance()->DeleteColumns(table_oid, txn); diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index b77011b915e..0cad6d32d7f 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -225,10 +225,10 @@ std::shared_ptr IndexCatalog::GetIndexObject( throw CatalogException("Transaction is invalid!"); } // try get from cache - auto index_object = txn->catalog_cache.GetCachedIndexObject(index_oid); - if (index_object) { - return index_object; - } + // auto index_object = txn->catalog_cache.GetCachedIndexObject(index_oid); + // if (index_object) { + // return index_object; + //} // cache miss, get from pg_index std::vector column_ids(all_column_ids); @@ -258,6 +258,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( LOG_DEBUG("Found %lu index with oid %u", result_tuples.size(), index_oid); } + LOG_INFO("index catalog not found"); // return empty object if not found return nullptr; } @@ -268,37 +269,32 @@ std::shared_ptr IndexCatalog::GetIndexObject( throw CatalogException("Transaction is invalid!"); } // try get from cache - auto index_object = txn->catalog_cache.GetCachedIndexObject(index_name); - if (index_object) { - return index_object; - } + // auto index_object = txn->catalog_cache.GetCachedIndexObject(index_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 + std::vector values; + values.push_back( + type::ValueFactory::GetVarcharValue(index_name, nullptr).Copy()); - expression::AbstractExpression *idx_name_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, - ColumnId::INDEX_NAME); - expression::AbstractExpression *idx_name_const_expr = - expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetVarcharValue(index_name, nullptr).Copy()); - expression::AbstractExpression *idx_name_equality_expr = - expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, idx_name_expr, idx_name_const_expr); - - std::vector result_tuples = - GetResultWithCompiledSeqScan(column_ids, idx_name_equality_expr, txn); + auto result_tiles = + GetResultWithIndexScan(column_ids, index_offset, values, txn); - if (result_tuples.size() == 1) { - auto index_object = std::make_shared(result_tuples[0]); + if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { + 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 && - table_object->GetTableOid() == index_object->GetTableOid()); + table_object->GetTableOid() == index_object->GetTableOid()); return table_object->GetIndexObject(index_name); } else { - LOG_DEBUG("Found %lu index with name %s", result_tuples.size(), + LOG_DEBUG("Found %lu index with name %s", result_tiles->size(), index_name.c_str()); } @@ -322,8 +318,8 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, auto table_object = TableCatalog::GetInstance()->GetTableObject(table_oid, txn); PELOTON_ASSERT(table_object && table_object->GetTableOid() == table_oid); - auto index_objects = table_object->GetIndexObjects(true); - if (index_objects.empty() == false) return index_objects; + // auto index_objects = table_object->GetIndexObjects(true); + // if (index_objects.empty() == false) return index_objects; // cache miss, get from pg_index std::vector column_ids(all_column_ids); diff --git a/src/codegen/expression/comparison_translator.cpp b/src/codegen/expression/comparison_translator.cpp index 92d996996c1..3e84a8dd62e 100644 --- a/src/codegen/expression/comparison_translator.cpp +++ b/src/codegen/expression/comparison_translator.cpp @@ -34,6 +34,8 @@ codegen::Value ComparisonTranslator::DeriveValue(CodeGen &codegen, codegen::Value left = row.DeriveValue(codegen, *comparison.GetChild(0)); codegen::Value right = row.DeriveValue(codegen, *comparison.GetChild(1)); + codegen.CallPrintf("left: %u, right: %u\n", {left.GetValue(), right.GetValue()}); + switch (comparison.GetExpressionType()) { case ExpressionType::COMPARE_EQUAL: return left.CompareEq(codegen, right); diff --git a/src/include/catalog/index_catalog.h b/src/include/catalog/index_catalog.h index 7df4b83f243..e1b6e453ba9 100644 --- a/src/include/catalog/index_catalog.h +++ b/src/include/catalog/index_catalog.h @@ -93,7 +93,6 @@ class IndexCatalog : public AbstractCatalog { std::shared_ptr GetIndexObject( const std::string &index_name, concurrency::TransactionContext *txn); - private: std::shared_ptr GetIndexObject( oid_t index_oid, concurrency::TransactionContext *txn); diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index 4d3cfc05fbe..c2d2cbe6336 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -151,6 +151,27 @@ TEST_F(CatalogTests, CreatingTable) { // ->GetLength(), // 72); } +TEST_F(CatalogTests, IndexObject) { + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); + auto txn = txn_manager.BeginTransaction(); + + auto table_object = catalog::Catalog::GetInstance()->GetTableObject( + "EMP_DB", "department_table", txn); + LOG_INFO("table name: %u", table_object->GetTableOid()); + auto index_objects = table_object->GetIndexObjects(); + for (auto it=index_objects.begin();it != index_objects.end();it++) { + auto index_obj = it->second; + LOG_INFO("index oid %u, %s, %u", index_obj->GetIndexOid(), index_obj->GetIndexName().c_str(), index_obj->GetTableOid()); + } + + auto index_oid = index_objects.begin()->second->GetIndexOid(); + LOG_INFO("index oid %u", index_oid); + auto index_obj = catalog::IndexCatalog::GetInstance()->GetIndexObject(index_oid, txn); + EXPECT_NE(nullptr, index_obj); + // LOG_INFO("Found index oid %u, %s, %u", index_obj->GetIndexOid(), index_obj->GetIndexName().c_str(), index_obj->GetTableOid()); + + txn_manager.CommitTransaction(txn); +} TEST_F(CatalogTests, TableObject) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); @@ -160,6 +181,10 @@ TEST_F(CatalogTests, TableObject) { "EMP_DB", "department_table", txn); auto index_objects = table_object->GetIndexObjects(); + // auto index_oid = index_objects.begin()->second->GetIndexOid(); + // auto index_obj = catalog::IndexCatalog::GetInstance()->GetIndexObject(index_oid, txn); + // LOG_INFO("index oid %u", index_oid); + auto column_objects = table_object->GetColumnObjects(); EXPECT_EQ(1, index_objects.size()); diff --git a/test/optimizer/old_optimizer_test.cpp b/test/optimizer/old_optimizer_test.cpp index 6de7891516a..09341562f0f 100644 --- a/test/optimizer/old_optimizer_test.cpp +++ b/test/optimizer/old_optimizer_test.cpp @@ -12,6 +12,8 @@ #include #include "catalog/catalog.h" +#include "catalog/table_catalog.h" +#include "catalog/index_catalog.h" #include "common/statement.h" #include "concurrency/transaction_manager_factory.h" #include "executor/create_executor.h" @@ -169,6 +171,11 @@ TEST_F(OldOptimizerTests, UpdateDelWithIndexScanTest) { auto target_table_ = catalog::Catalog::GetInstance()->GetTableWithName( DEFAULT_DB_NAME, "department_table", txn); // Expected 1 , Primary key index + created index + auto table_obj = catalog::Catalog::GetInstance()->GetTableObject( + DEFAULT_DB_NAME, "department_table", txn); + LOG_WARN("Index count: %lu", table_obj->GetIndexObjects().size()); + auto index_obj = catalog::IndexCatalog::GetInstance()->GetIndexObject(50331753, txn); + LOG_WARN("index: %u", index_obj->GetIndexOid()); EXPECT_EQ(target_table_->GetIndexCount(), 2); txn_manager.CommitTransaction(txn); @@ -225,10 +232,12 @@ TEST_F(OldOptimizerTests, UpdateDelWithIndexScanTest) { txn_manager.CommitTransaction(txn); EXPECT_EQ(del_scan_plan_seq->GetPlanNodeType(), PlanNodeType::SEQSCAN); + LOG_WARN("here3"); // free the database just created txn = txn_manager.BeginTransaction(); catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); txn_manager.CommitTransaction(txn); + LOG_WARN("here4"); } } // namespace test From 6a3ecd9b14e0714c5b8a76fcf28a602cb516e00f Mon Sep 17 00:00:00 2001 From: Zeninma Date: Sun, 22 Apr 2018 19:50:59 -0400 Subject: [PATCH 52/85] fixed binding for tuple_value_expression, and changed query_cache_test --- src/catalog/abstract_catalog.cpp | 4 +- src/catalog/catalog.cpp | 2 - src/catalog/index_catalog.cpp | 12 +- .../expression/comparison_translator.cpp | 1 - src/planner/abstract_scan_plan.cpp | 2 +- test/catalog/catalog_test.cpp | 1 - test/codegen/query_cache_test.cpp | 111 ++++++++++++++++-- 7 files changed, 110 insertions(+), 23 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 6d080377c00..6aa5ec27ad0 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -270,8 +270,8 @@ AbstractCatalog::GetResultWithCompiledSeqScan( // search for query codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); std::unique_ptr compiled_query(nullptr); - // cached = (query != nullptr); - cached = false; + cached = (query != nullptr); +// cached = false; // LOG_DEBUG("cache %d", cached); // if not cached, compile the query and save it into cache if (!cached) { diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 495aeef0033..8e3f066c425 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -552,14 +552,12 @@ ResultType Catalog::DropTable(const std::string &database_name, */ ResultType Catalog::DropTable(oid_t database_oid, oid_t table_oid, concurrency::TransactionContext *txn) { - LOG_WARN("Dropping table %d from database %d", database_oid, table_oid); auto storage_manager = storage::StorageManager::GetInstance(); auto database = storage_manager->GetDatabaseWithOid(database_oid); auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); auto table_object = database_object->GetTableObject(table_oid); auto index_objects = table_object->GetIndexObjects(); - LOG_WARN("dropping #%d indexes", (int)index_objects.size()); for (auto it : index_objects) DropIndex(it.second->GetIndexOid(), txn); ColumnCatalog::GetInstance()->DeleteColumns(table_oid, txn); diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index 0cad6d32d7f..98231544351 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -233,9 +233,10 @@ std::shared_ptr IndexCatalog::GetIndexObject( // cache miss, get from pg_index std::vector column_ids(all_column_ids); - expression::AbstractExpression *idx_oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + auto *idx_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, ColumnId::INDEX_OID); + idx_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::INDEX_OID); expression::AbstractExpression *idx_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(index_oid).Copy()); @@ -258,7 +259,6 @@ std::shared_ptr IndexCatalog::GetIndexObject( LOG_DEBUG("Found %lu index with oid %u", result_tuples.size(), index_oid); } - LOG_INFO("index catalog not found"); // return empty object if not found return nullptr; } @@ -324,9 +324,11 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, // cache miss, get from pg_index std::vector column_ids(all_column_ids); - expression::AbstractExpression *oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + auto *oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); + oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TABLE_OID); + expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(table_oid).Copy()); diff --git a/src/codegen/expression/comparison_translator.cpp b/src/codegen/expression/comparison_translator.cpp index 3e84a8dd62e..230a46e32e7 100644 --- a/src/codegen/expression/comparison_translator.cpp +++ b/src/codegen/expression/comparison_translator.cpp @@ -34,7 +34,6 @@ codegen::Value ComparisonTranslator::DeriveValue(CodeGen &codegen, codegen::Value left = row.DeriveValue(codegen, *comparison.GetChild(0)); codegen::Value right = row.DeriveValue(codegen, *comparison.GetChild(1)); - codegen.CallPrintf("left: %u, right: %u\n", {left.GetValue(), right.GetValue()}); switch (comparison.GetExpressionType()) { case ExpressionType::COMPARE_EQUAL: diff --git a/src/planner/abstract_scan_plan.cpp b/src/planner/abstract_scan_plan.cpp index 21a5c85fd6b..a9fa6214412 100644 --- a/src/planner/abstract_scan_plan.cpp +++ b/src/planner/abstract_scan_plan.cpp @@ -50,7 +50,7 @@ void AbstractScan::PerformBinding(BindingContext &binding_context) { const auto &ai = attributes_[input_col_ids[col_id]]; LOG_TRACE("Attribute '%s.%s' (%u) binds to AI %p", GetTable()->GetName().c_str(), ai.name.c_str(), col_id, &ai); - binding_context.BindNew(input_col_ids[col_id], &ai); + binding_context.BindNew(col_id, &ai); } } diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index c2d2cbe6336..e7fdeec8169 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -165,7 +165,6 @@ TEST_F(CatalogTests, IndexObject) { } auto index_oid = index_objects.begin()->second->GetIndexOid(); - LOG_INFO("index oid %u", index_oid); auto index_obj = catalog::IndexCatalog::GetInstance()->GetIndexObject(index_oid, txn); EXPECT_NE(nullptr, index_obj); // LOG_INFO("Found index oid %u, %s, %u", index_obj->GetIndexOid(), index_obj->GetIndexName().c_str(), index_obj->GetTableOid()); diff --git a/test/codegen/query_cache_test.cpp b/test/codegen/query_cache_test.cpp index 8babf573003..eb8d8438c43 100644 --- a/test/codegen/query_cache_test.cpp +++ b/test/codegen/query_cache_test.cpp @@ -51,6 +51,29 @@ class QueryCacheTest : public PelotonCodeGenTest { &GetTestTable(TestTableId()), a_gt_40, {0, 1})); } + std::shared_ptr GetSeqScanPlanA() { + auto *a_col_exp = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, 0); + a_col_exp->SetBoundOid(GetDatabase().GetOid(), TestTableId(), 0); + auto *const_40_exp = PelotonCodeGenTest::ConstIntExpr(40).release(); + auto *a_eq_40 = new expression::ComparisonExpression( + ExpressionType::COMPARE_EQUAL, a_col_exp, const_40_exp); + return std::shared_ptr(new planner::SeqScanPlan( + &GetTestTable(TestTableId()), a_eq_40, {0, 1})); + } + + + std::shared_ptr GetSeqScanPlanB() { + auto *b_col_exp = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, 1); + b_col_exp->SetBoundOid(GetDatabase().GetOid(), TestTableId(), 1); + auto *const_41_exp = PelotonCodeGenTest::ConstIntExpr(41).release(); + auto *b_eq_41 = new expression::ComparisonExpression( + ExpressionType::COMPARE_EQUAL, b_col_exp, const_41_exp); + return std::shared_ptr(new planner::SeqScanPlan( + &GetTestTable(TestTableId()), b_eq_41, {0, 1})); + } + // SELECT a, b, c FROM table where a >= 20 and b = 21; std::shared_ptr GetSeqScanPlanWithPredicate() { auto *a_col_exp = @@ -209,6 +232,62 @@ class QueryCacheTest : public PelotonCodeGenTest { uint32_t num_rows_to_insert = 64; }; + + + TEST_F(QueryCacheTest, SimpleCacheWithDiffPredicate) { + std::shared_ptr plan_a = GetSeqScanPlanA(); + + std::shared_ptr plan_b = GetSeqScanPlanB(); + // Do binding + planner::BindingContext context_1; + plan_a->PerformBinding(context_1); + planner::BindingContext context_2; + plan_b->PerformBinding(context_2); + + // check if the two plans are the same + auto hash_equal = (plan_a->Hash() == plan_b->Hash()); + EXPECT_FALSE(hash_equal); + + auto is_equal = (*plan_a.get() == *plan_b.get()); + EXPECT_FALSE(is_equal); + + // execute SELECT a FROM table where a == 40; + codegen::BufferingConsumer buffer_1{{0, 1}, context_1}; + bool cached; + CompileAndExecuteCache(plan_a, buffer_1, cached); + auto &results_1 = buffer_1.GetOutputTuples(); + EXPECT_EQ(1, results_1.size()); + EXPECT_FALSE(cached); + + // clear the cache for plan_b + codegen::QueryCache::Instance().Clear(); + EXPECT_EQ(0, codegen::QueryCache::Instance().GetCount()); + + // execute SELECT b FROM table where b == 41; + codegen::BufferingConsumer buffer_2{{0, 1}, context_2}; + CompileAndExecuteCache(plan_b, buffer_2, cached); + + const auto &results_2 = buffer_2.GetOutputTuples(); + EXPECT_EQ(1, results_2.size()); + EXPECT_FALSE(cached); + + // cache has plan_b + EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + + // re-execute SELECT a FROM table where a == 40; + codegen::BufferingConsumer buffer_3{{0, 1}, context_1}; + CompileAndExecuteCache(plan_a, buffer_3, cached); + + // cache should hit because two plans are the same + EXPECT_FALSE(cached); + + const auto &results_3 = buffer_3.GetOutputTuples(); + EXPECT_EQ(1, results_3.size()); // fails here + + codegen::QueryCache::Instance().Clear(); + EXPECT_EQ(0, codegen::QueryCache::Instance().GetCount()); + } + TEST_F(QueryCacheTest, SimpleCache) { // SELECT b FROM table where a >= 40; std::shared_ptr scan1 = GetSeqScanPlan(); @@ -227,6 +306,8 @@ TEST_F(QueryCacheTest, SimpleCache) { auto is_equal = (*scan1.get() == *scan2.get()); EXPECT_TRUE(is_equal); + int init_count = codegen::QueryCache::Instance().GetCount(); + // Execute a new query codegen::BufferingConsumer buffer_1{{0}, context_1}; bool cached; @@ -234,7 +315,7 @@ 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(init_count+1, codegen::QueryCache::Instance().GetCount()); // Execute a query cached codegen::BufferingConsumer buffer_2{{0}, context_2}; @@ -243,7 +324,7 @@ TEST_F(QueryCacheTest, SimpleCache) { EXPECT_TRUE(cached); EXPECT_EQ(NumRowsInTestTable() - 4, results_2.size()); - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(init_count+1, codegen::QueryCache::Instance().GetCount()); // PelotonCodeTest dies after each TEST_F() // So, we delete the cache @@ -268,6 +349,8 @@ TEST_F(QueryCacheTest, CacheSeqScanPlan) { auto is_equal = (*scan1.get() == *scan2.get()); EXPECT_TRUE(is_equal); + int init_count = codegen::QueryCache::Instance().GetCount(); + codegen::BufferingConsumer buffer_1{{0, 1, 2}, context_1}; bool cached; @@ -292,7 +375,7 @@ TEST_F(QueryCacheTest, CacheSeqScanPlan) { EXPECT_EQ(CmpBool::CmpTrue, results_2[0].GetValue(1).CompareEquals( type::ValueFactory::GetIntegerValue(21))); EXPECT_TRUE(cached); - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(init_count+1, codegen::QueryCache::Instance().GetCount()); // PelotonCodeTest dies after each TEST_F() // So, we delete the cache @@ -315,6 +398,8 @@ TEST_F(QueryCacheTest, CacheHashJoinPlan) { bool is_equal = (*hj_plan1.get() == *hj_plan_2.get()); EXPECT_TRUE(is_equal); + int init_count = codegen::QueryCache::Instance().GetCount(); + // We collect the results of the query into an in-memory buffer codegen::BufferingConsumer buffer_1{{0, 1, 2, 3}, context_1}; @@ -350,7 +435,7 @@ TEST_F(QueryCacheTest, CacheHashJoinPlan) { EXPECT_EQ(tuple.GetValue(0).CompareEquals(tuple.GetValue(1)), CmpBool::CmpTrue); } - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(init_count+1, codegen::QueryCache::Instance().GetCount()); // PelotonCodeTest dies after each TEST_F() // So, we delete the cache @@ -398,6 +483,8 @@ TEST_F(QueryCacheTest, CacheOrderByPlan) { is_equal = (*order_by_plan_1.get() == *order_by_plan_3.get()); EXPECT_FALSE(is_equal); + int init_count = codegen::QueryCache::Instance().GetCount(); + codegen::BufferingConsumer buffer_1{{0, 1}, context_1}; codegen::BufferingConsumer buffer_2{{0, 1}, context_2}; @@ -428,7 +515,7 @@ TEST_F(QueryCacheTest, CacheOrderByPlan) { std::move(order_by_plan_3)) == nullptr); EXPECT_EQ(found, 1); - EXPECT_EQ(1, codegen::QueryCache::Instance().GetCount()); + EXPECT_EQ(init_count+1, codegen::QueryCache::Instance().GetCount()); // PelotonCodeTest dies after each TEST_F() // So, we delete the cache @@ -449,7 +536,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()); + + int init_count = codegen::QueryCache::Instance().GetCount(); codegen::BufferingConsumer buffer_1{{0, 1}, context_1}; codegen::BufferingConsumer buffer_2{{0, 1}, context_2}; @@ -461,7 +549,7 @@ 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(init_count+1, codegen::QueryCache::Instance().GetCount()); // Compile and execute with the cached query CompileAndExecuteCache(agg_plan_2, buffer_2, cached); @@ -471,7 +559,7 @@ 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(init_count+1, codegen::QueryCache::Instance().GetCount()); codegen::QueryCache::Instance().Clear(); EXPECT_EQ(0, codegen::QueryCache::Instance().GetCount()); @@ -496,7 +584,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()); + + int init_count = codegen::QueryCache::Instance().GetCount(); codegen::BufferingConsumer buffer_1{{0, 1}, context_1}; codegen::BufferingConsumer buffer_2{{0, 1}, context_2}; @@ -505,14 +594,14 @@ 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(init_count+1, 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(init_count+1, codegen::QueryCache::Instance().GetCount()); codegen::QueryCache::Instance().Clear(); EXPECT_EQ(0, codegen::QueryCache::Instance().GetCount()); From e340a809b11206458df8720a9540dbd5e5cb93a0 Mon Sep 17 00:00:00 2001 From: Zeninma Date: Sun, 22 Apr 2018 21:18:21 -0400 Subject: [PATCH 53/85] added Insert and Delete with Compiled Query in abstract_catalog and table_catalog --- src/catalog/abstract_catalog.cpp | 110 +++++++++++++++++++++++++ src/catalog/table_catalog.cpp | 71 ++++++++++++---- src/include/catalog/abstract_catalog.h | 9 ++ 3 files changed, 172 insertions(+), 18 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 6aa5ec27ad0..a1a28c8653a 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -105,6 +105,58 @@ bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, return status; } + /*@brief insert tuple(reord) helper function +* @param tuple tuple to be inserted +* @param txn TransactionContext +* @return Whether insertion is Successful +*/ + bool AbstractCatalog::InsertTupleWithCompiledPlan(const std::vector>> *insert_values, + concurrency::TransactionContext *txn) { + if (txn == nullptr) + throw CatalogException("Insert tuple requires transaction"); + + std::vector columns; + std::shared_ptr insert_plan( + new planner::InsertPlan(catalog_table_, &columns, insert_values)); + + // Bind the plan + planner::BindingContext context; + insert_plan->PerformBinding(context); + + // Prepare a consumer to collect the result + codegen::BufferingConsumer buffer{{}, context}; + + + bool cached; + + codegen::QueryParameters parameters(*insert_plan, {}); + std::unique_ptr executor_context( + new executor::ExecutorContext(txn, std::move(parameters))); + + // search for query + codegen::Query *query = codegen::QueryCache::Instance().Find(insert_plan);; + std::unique_ptr compiled_query(nullptr); + cached = (query != nullptr); +// cached = false; + // LOG_DEBUG("cache %d", cached); + // if not cached, compile the query and save it into cache + executor::ExecutionResult ret; + if (!cached) { + compiled_query = codegen::QueryCompiler().Compile( + *insert_plan, executor_context->GetParams().GetQueryParametersMap(), + buffer); + query = compiled_query.get(); + codegen::QueryCache::Instance().Add(insert_plan, std::move(compiled_query)); + } + + query->Execute(std::move(executor_context), buffer, + [&ret](executor::ExecutionResult result) { ret = result; }); + + return ret.m_result == peloton::ResultType::SUCCESS; + } + + /*@brief Delete a tuple using index scan * @param index_offset Offset of index for scan * @param values Values for search @@ -154,6 +206,64 @@ bool AbstractCatalog::DeleteWithIndexScan( return status; } + + /*@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 +*/ + bool AbstractCatalog::DeleteWithCompiledSeqScan( + std::vector column_offsets, + expression::AbstractExpression *predicate, + concurrency::TransactionContext *txn) { + if (txn == nullptr) + throw CatalogException("Delete tuple requires transaction"); + + std::shared_ptr delete_plan{ + new planner::DeletePlan(catalog_table_)}; + + std::unique_ptr scan{new planner::SeqScanPlan( + catalog_table_, predicate, column_offsets)}; + delete_plan->AddChild(std::move(scan)); + + // Do binding + planner::BindingContext context; + delete_plan->PerformBinding(context); + + codegen::BufferingConsumer buffer{column_offsets, context}; + + bool cached; + + codegen::QueryParameters parameters(*delete_plan, {}); + std::unique_ptr executor_context( + new executor::ExecutorContext(txn, std::move(parameters))); + + // search for query + codegen::Query *query = codegen::QueryCache::Instance().Find(delete_plan);; + std::unique_ptr compiled_query(nullptr); + cached = (query != nullptr); +// cached = false; + // LOG_DEBUG("cache %d", cached); + // if not cached, compile the query and save it into cache + executor::ExecutionResult ret; + if (!cached) { + compiled_query = codegen::QueryCompiler().Compile( + *delete_plan, executor_context->GetParams().GetQueryParametersMap(), + buffer); + query = compiled_query.get(); + codegen::QueryCache::Instance().Add(delete_plan, std::move(compiled_query)); + } + + query->Execute(std::move(executor_context), buffer, + [&ret](executor::ExecutionResult result) { ret = result; }); + + return ret.m_result == peloton::ResultType::SUCCESS; + } + + + + /*@brief Index scan helper function * @param column_offsets Column ids for search (projection) * @param index_offset Offset of index for scan diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 13e7ca171dd..770337d4a9a 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -28,7 +28,7 @@ namespace peloton { namespace catalog { - + using ExpressionPtr = std::unique_ptr; TableCatalogObject::TableCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn, int tupleId) @@ -378,20 +378,38 @@ std::unique_ptr TableCatalog::InitializeSchema() { bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, oid_t database_oid, type::AbstractPool *pool, concurrency::TransactionContext *txn) { + (void) pool; // Create the tuple first - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); +// std::unique_ptr tuple( +// new storage::Tuple(catalog_table_->GetSchema(), true)); + + std::vector> tuples; auto val0 = type::ValueFactory::GetIntegerValue(table_oid); auto val1 = type::ValueFactory::GetVarcharValue(table_name, nullptr); auto val2 = type::ValueFactory::GetIntegerValue(database_oid); - tuple->SetValue(TableCatalog::ColumnId::TABLE_OID, val0, pool); - tuple->SetValue(TableCatalog::ColumnId::TABLE_NAME, val1, pool); - tuple->SetValue(TableCatalog::ColumnId::DATABASE_OID, val2, pool); + auto constant_expr_0 = new expression::ConstantValueExpression( + val0); + auto constant_expr_1 = new expression::ConstantValueExpression( + val1); + auto constant_expr_2 = new expression::ConstantValueExpression( + val2); + + + tuples.push_back(std::vector()); + auto &values = tuples[0]; + values.push_back(ExpressionPtr(constant_expr_0)); + values.push_back(ExpressionPtr(constant_expr_1)); + values.push_back(ExpressionPtr(constant_expr_2)); +// +// tuple->SetValue(TableCatalog::ColumnId::TABLE_OID, val0, pool); +// tuple->SetValue(TableCatalog::ColumnId::TABLE_NAME, val1, pool); +// tuple->SetValue(TableCatalog::ColumnId::DATABASE_OID, val2, pool); // Insert the tuple - return InsertTuple(std::move(tuple), txn); +// return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } /*@brief delete a tuple about table info from pg_table(using index scan) @@ -401,19 +419,36 @@ bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, */ 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()); +// oid_t index_offset = IndexId::PRIMARY_KEY; // Index of 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); - database_object->EvictTableObject(table_oid); - } + std::vector column_ids(all_column_ids); + + + auto *table_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + table_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TABLE_OID); + + + expression::AbstractExpression *table_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *table_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, table_oid_expr, table_oid_const_expr); + + bool result = DeleteWithCompiledSeqScan(column_ids, table_oid_equality_expr, txn); - return DeleteWithIndexScan(index_offset, values, txn); + if(result){ + // 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); + database_object->EvictTableObject(table_oid); + } + } + return result; } /*@brief read table catalog object from pg_table using table oid diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index c1c6f4cf1ac..fbf566801df 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -65,9 +65,18 @@ class AbstractCatalog { bool InsertTuple(std::unique_ptr tuple, concurrency::TransactionContext *txn); + bool InsertTupleWithCompiledPlan(const std::vector>> *insert_values, + concurrency::TransactionContext *txn); + bool DeleteWithIndexScan(oid_t index_offset, std::vector values, concurrency::TransactionContext *txn); + bool DeleteWithCompiledSeqScan( + std::vector column_offsets, + expression::AbstractExpression *predicate, + concurrency::TransactionContext *txn); + std::unique_ptr>> GetResultWithIndexScan(std::vector column_offsets, oid_t index_offset, std::vector values, From 44371e2646ee1003f72d41e9863c248cb32853ec Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sun, 22 Apr 2018 21:23:25 -0400 Subject: [PATCH 54/85] compiled seq plan for table catalog by looking up table_oid --- src/catalog/abstract_catalog.cpp | 171 ++++++++++++------------- src/catalog/table_catalog.cpp | 110 ++++++++-------- src/include/catalog/abstract_catalog.h | 4 +- 3 files changed, 142 insertions(+), 143 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index a1a28c8653a..244fa9deb8b 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -105,56 +105,56 @@ bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, return status; } - /*@brief insert tuple(reord) helper function +/*@brief insert tuple(reord) helper function * @param tuple tuple to be inserted * @param txn TransactionContext * @return Whether insertion is Successful */ - bool AbstractCatalog::InsertTupleWithCompiledPlan(const std::vector>> *insert_values, - concurrency::TransactionContext *txn) { - if (txn == nullptr) - throw CatalogException("Insert tuple requires transaction"); +bool AbstractCatalog::InsertTupleWithCompiledPlan(const std::vector>> *insert_values, + concurrency::TransactionContext *txn) { + if (txn == nullptr) + throw CatalogException("Insert tuple requires transaction"); - std::vector columns; - std::shared_ptr insert_plan( - new planner::InsertPlan(catalog_table_, &columns, insert_values)); + std::vector columns; + std::shared_ptr insert_plan( + new planner::InsertPlan(catalog_table_, &columns, insert_values)); - // Bind the plan - planner::BindingContext context; - insert_plan->PerformBinding(context); + // Bind the plan + planner::BindingContext context; + insert_plan->PerformBinding(context); - // Prepare a consumer to collect the result - codegen::BufferingConsumer buffer{{}, context}; + // Prepare a consumer to collect the result + codegen::BufferingConsumer buffer{{}, context}; - bool cached; + bool cached; - codegen::QueryParameters parameters(*insert_plan, {}); - std::unique_ptr executor_context( - new executor::ExecutorContext(txn, std::move(parameters))); + codegen::QueryParameters parameters(*insert_plan, {}); + std::unique_ptr executor_context( + new executor::ExecutorContext(txn, std::move(parameters))); - // search for query - codegen::Query *query = codegen::QueryCache::Instance().Find(insert_plan);; - std::unique_ptr compiled_query(nullptr); - cached = (query != nullptr); + // search for query + codegen::Query *query = codegen::QueryCache::Instance().Find(insert_plan);; + std::unique_ptr compiled_query(nullptr); + cached = (query != nullptr); // cached = false; - // LOG_DEBUG("cache %d", cached); - // if not cached, compile the query and save it into cache - executor::ExecutionResult ret; - if (!cached) { - compiled_query = codegen::QueryCompiler().Compile( - *insert_plan, executor_context->GetParams().GetQueryParametersMap(), - buffer); - query = compiled_query.get(); - codegen::QueryCache::Instance().Add(insert_plan, std::move(compiled_query)); - } - - query->Execute(std::move(executor_context), buffer, - [&ret](executor::ExecutionResult result) { ret = result; }); - - return ret.m_result == peloton::ResultType::SUCCESS; - } + // LOG_DEBUG("cache %d", cached); + // if not cached, compile the query and save it into cache + executor::ExecutionResult ret; + if (!cached) { + compiled_query = codegen::QueryCompiler().Compile( + *insert_plan, executor_context->GetParams().GetQueryParametersMap(), + buffer); + query = compiled_query.get(); + codegen::QueryCache::Instance().Add(insert_plan, std::move(compiled_query)); + } + + query->Execute(std::move(executor_context), buffer, + [&ret](executor::ExecutionResult result) { ret = result; }); + + return ret.m_result == peloton::ResultType::SUCCESS; +} /*@brief Delete a tuple using index scan @@ -207,59 +207,58 @@ bool AbstractCatalog::DeleteWithIndexScan( } - /*@brief Delete a tuple using index scan +/*@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 */ - bool AbstractCatalog::DeleteWithCompiledSeqScan( - std::vector column_offsets, - expression::AbstractExpression *predicate, - concurrency::TransactionContext *txn) { - if (txn == nullptr) - throw CatalogException("Delete tuple requires transaction"); - - std::shared_ptr delete_plan{ - new planner::DeletePlan(catalog_table_)}; - - std::unique_ptr scan{new planner::SeqScanPlan( - catalog_table_, predicate, column_offsets)}; - delete_plan->AddChild(std::move(scan)); - - // Do binding - planner::BindingContext context; - delete_plan->PerformBinding(context); - - codegen::BufferingConsumer buffer{column_offsets, context}; - - bool cached; - - codegen::QueryParameters parameters(*delete_plan, {}); - std::unique_ptr executor_context( - new executor::ExecutorContext(txn, std::move(parameters))); - - // search for query - codegen::Query *query = codegen::QueryCache::Instance().Find(delete_plan);; - std::unique_ptr compiled_query(nullptr); - cached = (query != nullptr); -// cached = false; - // LOG_DEBUG("cache %d", cached); - // if not cached, compile the query and save it into cache - executor::ExecutionResult ret; - if (!cached) { - compiled_query = codegen::QueryCompiler().Compile( - *delete_plan, executor_context->GetParams().GetQueryParametersMap(), - buffer); - query = compiled_query.get(); - codegen::QueryCache::Instance().Add(delete_plan, std::move(compiled_query)); - } - - query->Execute(std::move(executor_context), buffer, - [&ret](executor::ExecutionResult result) { ret = result; }); - - return ret.m_result == peloton::ResultType::SUCCESS; - } +bool AbstractCatalog::DeleteWithCompiledSeqScan( + std::vector column_offsets, + expression::AbstractExpression *predicate, + concurrency::TransactionContext *txn) { + if (txn == nullptr) + throw CatalogException("Delete tuple requires transaction"); + + std::shared_ptr delete_plan{ + new planner::DeletePlan(catalog_table_)}; + + std::unique_ptr scan{new planner::SeqScanPlan( + catalog_table_, predicate, column_offsets)}; + delete_plan->AddChild(std::move(scan)); + + // Do binding + planner::BindingContext context; + delete_plan->PerformBinding(context); + + codegen::BufferingConsumer buffer{column_offsets, context}; + + bool cached; + + codegen::QueryParameters parameters(*delete_plan, {}); + std::unique_ptr executor_context( + new executor::ExecutorContext(txn, std::move(parameters))); + + // search for query + codegen::Query *query = codegen::QueryCache::Instance().Find(delete_plan);; + std::unique_ptr compiled_query(nullptr); + cached = (query != nullptr); + + // if not cached, compile the query and save it into cache + executor::ExecutionResult ret; + if (!cached) { + compiled_query = codegen::QueryCompiler().Compile( + *delete_plan, executor_context->GetParams().GetQueryParametersMap(), + buffer); + query = compiled_query.get(); + codegen::QueryCache::Instance().Add(delete_plan, std::move(compiled_query)); + } + + query->Execute(std::move(executor_context), buffer, + [&ret](executor::ExecutionResult result) { ret = result; }); + + return ret.m_result == peloton::ResultType::SUCCESS; +} diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 770337d4a9a..4cc2d82dbef 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -378,38 +378,29 @@ std::unique_ptr TableCatalog::InitializeSchema() { bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, oid_t database_oid, type::AbstractPool *pool, concurrency::TransactionContext *txn) { - (void) pool; + (void) pool; // Create the tuple first -// std::unique_ptr tuple( -// new storage::Tuple(catalog_table_->GetSchema(), true)); - - std::vector> tuples; + std::vector> tuples; auto val0 = type::ValueFactory::GetIntegerValue(table_oid); auto val1 = type::ValueFactory::GetVarcharValue(table_name, nullptr); auto val2 = type::ValueFactory::GetIntegerValue(database_oid); - auto constant_expr_0 = new expression::ConstantValueExpression( - val0); - auto constant_expr_1 = new expression::ConstantValueExpression( - val1); - auto constant_expr_2 = new expression::ConstantValueExpression( - val2); + auto constant_expr_0 = new expression::ConstantValueExpression( + val0); + auto constant_expr_1 = new expression::ConstantValueExpression( + val1); + auto constant_expr_2 = new expression::ConstantValueExpression( + val2); - tuples.push_back(std::vector()); - auto &values = tuples[0]; - values.push_back(ExpressionPtr(constant_expr_0)); - values.push_back(ExpressionPtr(constant_expr_1)); - values.push_back(ExpressionPtr(constant_expr_2)); -// -// tuple->SetValue(TableCatalog::ColumnId::TABLE_OID, val0, pool); -// tuple->SetValue(TableCatalog::ColumnId::TABLE_NAME, val1, pool); -// tuple->SetValue(TableCatalog::ColumnId::DATABASE_OID, val2, pool); + tuples.push_back(std::vector()); + auto &values = tuples[0]; + values.push_back(ExpressionPtr(constant_expr_0)); + values.push_back(ExpressionPtr(constant_expr_1)); + values.push_back(ExpressionPtr(constant_expr_2)); - // Insert the tuple -// return InsertTuple(std::move(tuple), txn); - return InsertTupleWithCompiledPlan(&tuples, txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } /*@brief delete a tuple about table info from pg_table(using index scan) @@ -419,36 +410,35 @@ bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, */ bool TableCatalog::DeleteTable(oid_t table_oid, concurrency::TransactionContext *txn) { -// oid_t index_offset = IndexId::PRIMARY_KEY; // Index of table_oid - std::vector column_ids(all_column_ids); + std::vector column_ids(all_column_ids); - auto *table_oid_expr = - new expression::TupleValueExpression(type::TypeId::INTEGER, 0, - ColumnId::TABLE_OID); - table_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TABLE_OID); + auto *table_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + table_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TABLE_OID); - expression::AbstractExpression *table_oid_const_expr = - expression::ExpressionUtil::ConstantValueFactory( - type::ValueFactory::GetIntegerValue(table_oid).Copy()); - expression::AbstractExpression *table_oid_equality_expr = - expression::ExpressionUtil::ComparisonFactory( - ExpressionType::COMPARE_EQUAL, table_oid_expr, table_oid_const_expr); + expression::AbstractExpression *table_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *table_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, table_oid_expr, table_oid_const_expr); - bool result = DeleteWithCompiledSeqScan(column_ids, table_oid_equality_expr, txn); - - if(result){ - // 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); - database_object->EvictTableObject(table_oid); - } - } - return result; + bool result = DeleteWithCompiledSeqScan(column_ids, table_oid_equality_expr, txn); + + if(result) { + // 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); + database_object->EvictTableObject(table_oid); + } + } + return result; } /*@brief read table catalog object from pg_table using table oid @@ -467,16 +457,25 @@ std::shared_ptr TableCatalog::GetTableObject( // cache miss, get from pg_table std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::PRIMARY_KEY; // Index of table_oid - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + auto *table_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + table_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TABLE_OID); + expression::AbstractExpression *table_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *table_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, table_oid_expr, table_oid_const_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, table_oid_equality_expr, txn); - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { + if (result_tuples.size() == 1) { auto table_object = - std::make_shared((*result_tiles)[0].get(), txn); + std::make_shared(result_tuples[0], txn); + // insert into cache auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject( table_object->GetDatabaseOid(), txn); @@ -484,9 +483,10 @@ std::shared_ptr TableCatalog::GetTableObject( bool success = database_object->InsertTableObject(table_object); PELOTON_ASSERT(success == true); (void)success; + return table_object; } else { - LOG_DEBUG("Found %lu table with oid %u", result_tiles->size(), table_oid); + LOG_DEBUG("Found %lu table with oid %u", result_tuples.size(), table_oid); } // return empty object if not found diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index fbf566801df..92cab0795cf 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -65,14 +65,14 @@ class AbstractCatalog { bool InsertTuple(std::unique_ptr tuple, concurrency::TransactionContext *txn); - bool InsertTupleWithCompiledPlan(const std::vector>> *insert_values, concurrency::TransactionContext *txn); bool DeleteWithIndexScan(oid_t index_offset, std::vector values, concurrency::TransactionContext *txn); - bool DeleteWithCompiledSeqScan( + bool DeleteWithCompiledSeqScan( std::vector column_offsets, expression::AbstractExpression *predicate, concurrency::TransactionContext *txn); From 88facc3cdf5c1d41c8ee7eeca9fcb6d6604ff4a0 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sun, 22 Apr 2018 21:56:26 -0400 Subject: [PATCH 55/85] fix trigger --- src/catalog/trigger_catalog.cpp | 32 ++++++++++++--------------- src/include/catalog/trigger_catalog.h | 6 +++-- 2 files changed, 18 insertions(+), 20 deletions(-) diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index 7c286520fe5..2f7f824c91c 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -61,7 +61,7 @@ TriggerCatalog::TriggerCatalog(concurrency::TransactionContext *txn) TriggerCatalog::~TriggerCatalog() {} bool TriggerCatalog::InsertTrigger(oid_t table_oid, std::string trigger_name, - int16_t trigger_type, std::string proc_oid, + int16_t trigger_type, std::string proc_name, std::string function_arguments, type::Value fire_condition, type::Value timestamp, @@ -75,7 +75,7 @@ bool TriggerCatalog::InsertTrigger(oid_t table_oid, std::string trigger_name, auto val0 = type::ValueFactory::GetIntegerValue(GetNextOid()); auto val1 = type::ValueFactory::GetIntegerValue(table_oid); auto val2 = type::ValueFactory::GetVarcharValue(trigger_name); - auto val3 = type::ValueFactory::GetVarcharValue(proc_oid); + auto val3 = type::ValueFactory::GetVarcharValue(proc_name); auto val4 = type::ValueFactory::GetIntegerValue(trigger_type); auto val5 = type::ValueFactory::GetVarcharValue(function_arguments); auto val6 = fire_condition; @@ -84,7 +84,7 @@ bool TriggerCatalog::InsertTrigger(oid_t table_oid, std::string trigger_name, tuple->SetValue(ColumnId::TRIGGER_OID, val0, pool); tuple->SetValue(ColumnId::TABLE_OID, val1, pool); tuple->SetValue(ColumnId::TRIGGER_NAME, val2, pool); - tuple->SetValue(ColumnId::FUNCTION_OID, val3, pool); + tuple->SetValue(ColumnId::FUNCTION_NAME, val3, pool); tuple->SetValue(ColumnId::TRIGGER_TYPE, val4, pool); tuple->SetValue(ColumnId::FUNCTION_ARGS, val5, pool); tuple->SetValue(ColumnId::FIRE_CONDITION, val6, pool); @@ -194,9 +194,7 @@ std::unique_ptr TriggerCatalog::GetTriggersByType( 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( - {ColumnId::TRIGGER_NAME, ColumnId::FIRE_CONDITION, ColumnId::FUNCTION_OID, - ColumnId::FUNCTION_ARGS}); + std::vector column_ids(all_column_ids); expression::AbstractExpression *type_expr = expression::ExpressionUtil::TupleValueFactory(type::TypeId::SMALLINT, 0, @@ -235,11 +233,11 @@ std::unique_ptr TriggerCatalog::GetTriggersByType( for (unsigned int i = 0; i < result_tuples.size(); i++) { // create a new trigger instance - trigger::Trigger new_trigger(result_tuples[i].GetValue(0).ToString(), + trigger::Trigger new_trigger(result_tuples[i].GetValue(ColumnId::TRIGGER_NAME).ToString(), trigger_type, - result_tuples[i].GetValue(2).ToString(), - result_tuples[i].GetValue(3).ToString(), - result_tuples[i].GetValue(1).GetData()); + result_tuples[i].GetValue(ColumnId::FUNCTION_NAME).ToString(), + result_tuples[i].GetValue(ColumnId::FUNCTION_ARGS).ToString(), + result_tuples[i].GetValue(ColumnId::FIRE_CONDITION).GetData()); new_trigger_list->AddTrigger(new_trigger); } @@ -250,9 +248,7 @@ std::unique_ptr TriggerCatalog::GetTriggers( oid_t table_oid, concurrency::TransactionContext *txn) { 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, - ColumnId::FUNCTION_OID, ColumnId::FUNCTION_ARGS}); + std::vector column_ids(all_column_ids); expression::AbstractExpression *oid_expr = expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); @@ -275,11 +271,11 @@ std::unique_ptr TriggerCatalog::GetTriggers( for (unsigned int i = 0; i < result_tuples.size(); i++) { // create a new trigger instance - trigger::Trigger new_trigger(result_tuples[i].GetValue(0).ToString(), - result_tuples[i].GetValue(1).GetAs(), - result_tuples[i].GetValue(3).ToString(), - result_tuples[i].GetValue(4).ToString(), - result_tuples[i].GetValue(2).GetData()); + trigger::Trigger new_trigger(result_tuples[i].GetValue(ColumnId::TRIGGER_NAME).ToString(), + result_tuples[i].GetValue(ColumnId::TRIGGER_TYPE).GetAs(), + result_tuples[i].GetValue(ColumnId::FUNCTION_NAME).ToString(), + result_tuples[i].GetValue(ColumnId::FUNCTION_ARGS).ToString(), + result_tuples[i].GetValue(ColumnId::FIRE_CONDITION).GetData()); new_trigger_list->AddTrigger(new_trigger); } diff --git a/src/include/catalog/trigger_catalog.h b/src/include/catalog/trigger_catalog.h index 02b8fa9bb8f..5d99fa6def3 100644 --- a/src/include/catalog/trigger_catalog.h +++ b/src/include/catalog/trigger_catalog.h @@ -17,7 +17,7 @@ // 0: oid (pkey) // 1: tgrelid : table_name // 2: tgname : trigger_name -// 3: tgfoid : function_oid +// 3: tgfoid : function_name // 4: tgtype : trigger_type // 5: tgargs : function_arguemnts // 6: tgqual : fire_condition @@ -91,7 +91,7 @@ class TriggerCatalog : public AbstractCatalog { TRIGGER_OID = 0, TABLE_OID = 1, TRIGGER_NAME = 2, - FUNCTION_OID = 3, + FUNCTION_NAME = 3, TRIGGER_TYPE = 4, FUNCTION_ARGS = 5, FIRE_CONDITION = 6, @@ -103,6 +103,8 @@ class TriggerCatalog : public AbstractCatalog { oid_t GetNextOid() { return oid_++ | TRIGGER_OID_MASK; } + std::vector all_column_ids = {0, 1, 2, 3, 4, 5, 6, 7}; + enum IndexId { PRIMARY_KEY = 0, TABLE_TYPE_KEY_0 = 1, From d2447ff44c755fc604b59e92327629310b7fd673 Mon Sep 17 00:00:00 2001 From: Zeninma Date: Sun, 22 Apr 2018 23:01:07 -0400 Subject: [PATCH 56/85] changed trigger_test, changed the wrong assumption that triggers are in a certain order --- test/trigger/trigger_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/trigger/trigger_test.cpp b/test/trigger/trigger_test.cpp index cd8588b6bb0..de4891daba5 100644 --- a/test/trigger/trigger_test.cpp +++ b/test/trigger/trigger_test.cpp @@ -150,7 +150,7 @@ class TriggerTests : public PelotonTest { table_name, txn); txn_manager.CommitTransaction(txn); EXPECT_EQ(trigger_number, target_table->GetTriggerNumber()); - trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(0); + trigger::Trigger *new_trigger = target_table->GetTriggerByIndex(trigger_number-1); EXPECT_EQ(trigger_name, new_trigger->GetTriggerName()); } }; From 0ebfd381c1ae3fac78f0c8ce6cdcbd3c09847e86 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 15:21:36 -0400 Subject: [PATCH 57/85] fix settings catalog --- src/catalog/index_catalog.cpp | 2 +- src/catalog/settings_catalog.cpp | 33 ++++++++++++++++++-------- src/include/catalog/settings_catalog.h | 1 + 3 files changed, 25 insertions(+), 11 deletions(-) diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index 98231544351..d9156f9209c 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -236,7 +236,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( auto *idx_oid_expr = new expression::TupleValueExpression(type::TypeId::INTEGER, 0, ColumnId::INDEX_OID); - idx_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::INDEX_OID); + idx_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::INDEX_OID); expression::AbstractExpression *idx_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(index_oid).Copy()); diff --git a/src/catalog/settings_catalog.cpp b/src/catalog/settings_catalog.cpp index 66ce9ea99d7..845bd8622f0 100644 --- a/src/catalog/settings_catalog.cpp +++ b/src/catalog/settings_catalog.cpp @@ -97,11 +97,17 @@ bool SettingsCatalog::DeleteSetting(const std::string &name, std::string SettingsCatalog::GetSettingValue( const std::string &name, concurrency::TransactionContext *txn) { - std::vector column_ids({static_cast(ColumnId::VALUE)}); + std::vector column_ids(all_column_ids); + + auto *name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, + ColumnId::NAME); + + name_expr->SetBoundOid( + catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::NAME); - expression::AbstractExpression *name_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, - ColumnId::NAME); expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); @@ -115,18 +121,25 @@ std::string SettingsCatalog::GetSettingValue( std::string config_value = ""; PELOTON_ASSERT(result_tuples.size() <= 1); if (result_tuples.size() != 0) { - config_value = (result_tuples[0]).GetValue(0).ToString(); + config_value = (result_tuples[0]).GetValue(ColumnId::VALUE).ToString(); } return config_value; } std::string SettingsCatalog::GetDefaultValue( const std::string &name, concurrency::TransactionContext *txn) { - std::vector column_ids({static_cast(ColumnId::VALUE)}); + std::vector column_ids(all_column_ids); + + auto *name_expr = + new expression::TupleValueExpression( + type::TypeId::VARCHAR, 0, + ColumnId::NAME); + + name_expr->SetBoundOid( + catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::NAME); - expression::AbstractExpression *name_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, - ColumnId::NAME); expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); @@ -140,7 +153,7 @@ std::string SettingsCatalog::GetDefaultValue( std::string config_value = ""; PELOTON_ASSERT(result_tuples.size() <= 1); if (result_tuples.size() != 0) { - config_value = result_tuples[0].GetValue(0).ToString(); + config_value = result_tuples[0].GetValue(ColumnId::DEFAULT_VALUE).ToString(); } return config_value; } diff --git a/src/include/catalog/settings_catalog.h b/src/include/catalog/settings_catalog.h index 2c78ed61d54..7925e765fe7 100644 --- a/src/include/catalog/settings_catalog.h +++ b/src/include/catalog/settings_catalog.h @@ -59,6 +59,7 @@ class SettingsCatalog : public AbstractCatalog { IS_PERSISTENT = 8, // Add new columns here in creation order }; + std::vector all_column_ids = {0, 1, 2, 3, 4, 5, 6, 7, 8}; private: SettingsCatalog(concurrency::TransactionContext *txn); From b1e1ca363607a26e50410e0bd7a7c5025c7e7ed5 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 15:49:27 -0400 Subject: [PATCH 58/85] query metrics catalog --- src/catalog/query_metrics_catalog.cpp | 60 +++++++++++++++------ src/include/catalog/query_metrics_catalog.h | 5 +- src/include/catalog/settings_catalog.h | 1 + 3 files changed, 50 insertions(+), 16 deletions(-) diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 5c501b0b8d9..55d476a4f83 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -12,6 +12,8 @@ #include "catalog/query_metrics_catalog.h" +#include "codegen/buffering_consumer.h" +#include "expression/expression_util.h" #include "catalog/catalog.h" #include "executor/logical_tile.h" #include "storage/data_table.h" @@ -148,24 +150,52 @@ stats::QueryMetric::QueryParamBuf QueryMetricsCatalog::GetParamTypes( 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 - 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); + std::vector column_ids(all_column_ids); + + auto *name_expr = + new expression::TupleValueExpression( + type::TypeId::VARCHAR, 0, + ColumnId::NAME); + + name_expr->SetBoundOid( + catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::NAME); + + expression::AbstractExpression *name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); + expression::AbstractExpression *name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, name_expr, name_const_expr); + + auto *db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); + + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, name_equality_expr, + db_oid_equality_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); int64_t num_params = 0; - PELOTON_ASSERT(result_tiles->size() <= 1); // unique - if (result_tiles->size() != 0) { - PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - if ((*result_tiles)[0]->GetTupleCount() != 0) { - num_params = (*result_tiles)[0] - ->GetValue(0, 0) - .GetAs(); // After projection left 1 column - } + PELOTON_ASSERT(result_tuples.size() <= 1); // unique + if (result_tuples.size() != 0) { + num_params = result_tuples[0].GetValue(ColumnId::NUM_PARAMS) + .GetAs(); // After projection left 1 column } return num_params; diff --git a/src/include/catalog/query_metrics_catalog.h b/src/include/catalog/query_metrics_catalog.h index 84005093832..2efcc8b2de6 100644 --- a/src/include/catalog/query_metrics_catalog.h +++ b/src/include/catalog/query_metrics_catalog.h @@ -93,7 +93,10 @@ class QueryMetricsCatalog : public AbstractCatalog { // Add new columns here in creation order }; - private: + std::vector all_column_ids = {0, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12}; + +private: QueryMetricsCatalog(concurrency::TransactionContext *txn); enum IndexId { diff --git a/src/include/catalog/settings_catalog.h b/src/include/catalog/settings_catalog.h index 7925e765fe7..236a48a7faa 100644 --- a/src/include/catalog/settings_catalog.h +++ b/src/include/catalog/settings_catalog.h @@ -59,6 +59,7 @@ class SettingsCatalog : public AbstractCatalog { IS_PERSISTENT = 8, // Add new columns here in creation order }; + std::vector all_column_ids = {0, 1, 2, 3, 4, 5, 6, 7, 8}; private: From 2a6a3a80f263cdf73fc236efe9fec6545ef4a4fa Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 15:55:08 -0400 Subject: [PATCH 59/85] query metrics catalog --- src/catalog/query_metrics_catalog.cpp | 61 ++++++++++++++++++++------- 1 file changed, 45 insertions(+), 16 deletions(-) diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 55d476a4f83..98d093a5254 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -123,25 +123,54 @@ bool QueryMetricsCatalog::DeleteQueryMetrics( 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 - 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); + std::vector column_ids(all_column_ids); + + auto *name_expr = + new expression::TupleValueExpression( + type::TypeId::VARCHAR, 0, + ColumnId::NAME); + + name_expr->SetBoundOid( + catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::NAME); + + expression::AbstractExpression *name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); + expression::AbstractExpression *name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, name_expr, name_const_expr); + + auto *db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); + + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, name_equality_expr, + db_oid_equality_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); stats::QueryMetric::QueryParamBuf param_types; - PELOTON_ASSERT(result_tiles->size() <= 1); // unique - if (result_tiles->size() != 0) { - PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - if ((*result_tiles)[0]->GetTupleCount() != 0) { - auto param_types_value = (*result_tiles)[0]->GetValue(0, 0); - param_types.buf = const_cast( - reinterpret_cast(param_types_value.GetData())); - param_types.len = param_types_value.GetLength(); - } + PELOTON_ASSERT(result_tuples.size() <= 1); // unique + if (result_tuples.size() != 0) { + auto param_types_value = result_tuples[0].GetValue(ColumnId::PARAM_TYPES); + param_types.buf = const_cast( + reinterpret_cast(param_types_value.GetData())); + param_types.len = param_types_value.GetLength(); } return param_types; From 98759d75d161a5c3c996f568cac5a90b24429964 Mon Sep 17 00:00:00 2001 From: Zeninma Date: Sat, 28 Apr 2018 16:03:45 -0400 Subject: [PATCH 60/85] Changed zone_map_catalog, having issue running zone_map_scan_test --- src/catalog/zone_map_catalog.cpp | 14 ++++---- src/include/catalog/zone_map_catalog.h | 2 ++ src/storage/zone_map_manager.cpp | 3 ++ test/codegen/testing_codegen_util.cpp | 7 ++++ test/codegen/zone_map_scan_test.cpp | 36 +++++++++++---------- test/include/codegen/testing_codegen_util.h | 3 ++ 6 files changed, 42 insertions(+), 23 deletions(-) diff --git a/src/catalog/zone_map_catalog.cpp b/src/catalog/zone_map_catalog.cpp index b9749407bac..1e839841e81 100644 --- a/src/catalog/zone_map_catalog.cpp +++ b/src/catalog/zone_map_catalog.cpp @@ -97,9 +97,11 @@ bool ZoneMapCatalog::DeleteColumnStatistics( 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)}); + + std::vector column_ids(all_column_ids); expression::AbstractExpression *db_oid_expr = expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, @@ -161,9 +163,9 @@ std::unique_ptr> ZoneMapCatalog::GetColumnStatistics( } auto tuple = result_tuples[0]; type::Value min, max, actual_type; - min = tuple.GetValue(ZoneMapOffset::MINIMUM_OFF); - max = tuple.GetValue(ZoneMapOffset::MAXIMUM_OFF); - actual_type = tuple.GetValue(ZoneMapOffset::TYPE_OFF); + min = tuple.GetValue(ColumnId ::MINIMUM); + max = tuple.GetValue(ColumnId::MAXIMUM); + actual_type = tuple.GetValue(ColumnId::TYPE); // min and max are stored as VARCHARs and should be convertd to their // original types. diff --git a/src/include/catalog/zone_map_catalog.h b/src/include/catalog/zone_map_catalog.h index c5624680a63..d275ac01045 100644 --- a/src/include/catalog/zone_map_catalog.h +++ b/src/include/catalog/zone_map_catalog.h @@ -66,6 +66,8 @@ class ZoneMapCatalog : public AbstractCatalog { enum ZoneMapOffset { MINIMUM_OFF = 0, MAXIMUM_OFF = 1, TYPE_OFF = 2 }; + std::vector all_column_ids = {0, 1, 2, 3, 4, 5, 6}; + private: ZoneMapCatalog(concurrency::TransactionContext *txn); diff --git a/src/storage/zone_map_manager.cpp b/src/storage/zone_map_manager.cpp index 81765df3094..2e13913bcbc 100644 --- a/src/storage/zone_map_manager.cpp +++ b/src/storage/zone_map_manager.cpp @@ -199,6 +199,9 @@ ZoneMapManager::GetResultVectorAsZoneMap( bool ZoneMapManager::ShouldScanTileGroup( storage::PredicateInfo *parsed_predicates, int32_t num_predicates, storage::DataTable *table, int64_t tile_group_idx) { + if (table->GetName() == ZONE_MAP_CATALOG_NAME) { + return true; + } for (int32_t i = 0; i < num_predicates; i++) { // Extract the col_id, operator and predicate_value int col_id = parsed_predicates[i].col_id; diff --git a/test/codegen/testing_codegen_util.cpp b/test/codegen/testing_codegen_util.cpp index 91cc858927b..74f2682df52 100644 --- a/test/codegen/testing_codegen_util.cpp +++ b/test/codegen/testing_codegen_util.cpp @@ -264,6 +264,13 @@ ExpressionPtr PelotonCodeGenTest::ColRefExpr(type::TypeId type, return ExpressionPtr{expr}; } +ExpressionPtr PelotonCodeGenTest::ColRefExpr(storage::DataTable &table ,type::TypeId type, + uint32_t col_id) { + auto *expr = new expression::TupleValueExpression(type, 0, col_id); + expr->SetBoundOid(table.GetDatabaseOid(), table.GetOid(), col_id); + return ExpressionPtr{expr}; +} + ExpressionPtr PelotonCodeGenTest::ColRefExpr(type::TypeId type, bool left, uint32_t col_id) { return ExpressionPtr{ diff --git a/test/codegen/zone_map_scan_test.cpp b/test/codegen/zone_map_scan_test.cpp index f3b24ac7e53..81a93e6002d 100644 --- a/test/codegen/zone_map_scan_test.cpp +++ b/test/codegen/zone_map_scan_test.cpp @@ -67,27 +67,28 @@ class ZoneMapScanTest : public PelotonCodeGenTest { uint32_t num_rows_to_insert = 100; }; -TEST_F(ZoneMapScanTest, ScanNoPredicates) { - // SELECT a, b, c FROM table; - // 1) Setup the scan plan node - planner::SeqScanPlan scan{&GetTestTable(TestTableId()), nullptr, {0, 1, 2}}; - // 2) Do binding - planner::BindingContext context; - scan.PerformBinding(context); - codegen::BufferingConsumer buffer{{0, 1, 2}, context}; - // COMPILE and execute - CompileAndExecute(scan, buffer); - const auto &results = buffer.GetOutputTuples(); - EXPECT_EQ(NumRowsInTestTable(), results.size()); -} +//TEST_F(ZoneMapScanTest, ScanNoPredicates) { +// // SELECT a, b, c FROM table; +// // 1) Setup the scan plan node +// planner::SeqScanPlan scan{&GetTestTable(TestTableId()), nullptr, {0, 1, 2}}; +// // 2) Do binding +// planner::BindingContext context; +// scan.PerformBinding(context); +// codegen::BufferingConsumer buffer{{0, 1, 2}, context}; +// // COMPILE and execute +// CompileAndExecute(scan, buffer); +// const auto &results = buffer.GetOutputTuples(); +// EXPECT_EQ(NumRowsInTestTable(), results.size()); +//} TEST_F(ZoneMapScanTest, SimplePredicate) { // SELECT a, b, c FROM table where a >= 20; // 1) Setup the predicate + auto &table = GetTestTable(TestTableId()); ExpressionPtr a_gt_20 = - CmpGteExpr(ColRefExpr(type::TypeId::INTEGER, 0), ConstIntExpr(20)); + CmpGteExpr(ColRefExpr(table ,type::TypeId::INTEGER, 0), ConstIntExpr(20)); // 2) Setup the scan plan node - auto &table = GetTestTable(TestTableId()); + planner::SeqScanPlan scan{&table, a_gt_20.release(), {0, 1, 2}}; // 3) Do binding planner::BindingContext context; @@ -104,10 +105,11 @@ TEST_F(ZoneMapScanTest, SimplePredicate) { TEST_F(ZoneMapScanTest, PredicateOnNonOutputColumn) { // SELECT b FROM table where a >= 40; // 1) Setup the predicate + auto &table = GetTestTable(TestTableId()); ExpressionPtr a_gt_40 = - CmpGteExpr(ColRefExpr(type::TypeId::INTEGER, 0), ConstIntExpr(40)); + CmpGteExpr(ColRefExpr(table, type::TypeId::INTEGER, 0), ConstIntExpr(40)); // 2) Setup the scan plan node - auto &table = GetTestTable(TestTableId()); + planner::SeqScanPlan scan{&table, a_gt_40.release(), {0, 1}}; // 3) Do binding planner::BindingContext context; diff --git a/test/include/codegen/testing_codegen_util.h b/test/include/codegen/testing_codegen_util.h index c4f3943db66..eeab82d264c 100644 --- a/test/include/codegen/testing_codegen_util.h +++ b/test/include/codegen/testing_codegen_util.h @@ -101,6 +101,9 @@ class PelotonCodeGenTest : public PelotonTest { ExpressionPtr ConstDecimalExpr(double val); ExpressionPtr ColRefExpr(type::TypeId type, uint32_t col_id); + + ExpressionPtr ColRefExpr(storage::DataTable &table ,type::TypeId type, + uint32_t col_id); ExpressionPtr ColRefExpr(type::TypeId type, bool left, uint32_t col_id); ExpressionPtr CmpExpr(ExpressionType cmp_type, ExpressionPtr &&left, From 107b9b00befe327d661bcd80f3ac78e81130f7d6 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 16:23:44 -0400 Subject: [PATCH 61/85] database catalog insert --- src/catalog/database_catalog.cpp | 30 ++++++++++++++++++++------ src/include/catalog/database_catalog.h | 1 - 2 files changed, 24 insertions(+), 7 deletions(-) diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 6fc5153a179..75a1ebe2ea4 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -268,17 +268,35 @@ bool DatabaseCatalog::InsertDatabase(oid_t database_oid, const std::string &database_name, type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); +// std::unique_ptr tuple( +// new storage::Tuple(catalog_table_->GetSchema(), true)); +// +// auto val0 = type::ValueFactory::GetIntegerValue(database_oid); +// auto val1 = type::ValueFactory::GetVarcharValue(database_name, nullptr); +// +// tuple->SetValue(ColumnId::DATABASE_OID, val0, pool); +// tuple->SetValue(ColumnId::DATABASE_NAME, val1, pool); +// +// // Insert the tuple +// return InsertTuple(std::move(tuple), txn); + (void) pool; + + std::vector> tuples; auto val0 = type::ValueFactory::GetIntegerValue(database_oid); auto val1 = type::ValueFactory::GetVarcharValue(database_name, nullptr); - tuple->SetValue(ColumnId::DATABASE_OID, val0, pool); - tuple->SetValue(ColumnId::DATABASE_NAME, val1, pool); + auto constant_expr_0 = new expression::ConstantValueExpression( + val0); + auto constant_expr_1 = new expression::ConstantValueExpression( + val1); + + tuples.push_back(std::vector()); + auto &values = tuples[0]; + values.push_back(ExpressionPtr(constant_expr_0)); + values.push_back(ExpressionPtr(constant_expr_1)); - // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool DatabaseCatalog::DeleteDatabase(oid_t database_oid, diff --git a/src/include/catalog/database_catalog.h b/src/include/catalog/database_catalog.h index 5f23c792f78..5e6bb19add9 100644 --- a/src/include/catalog/database_catalog.h +++ b/src/include/catalog/database_catalog.h @@ -32,7 +32,6 @@ namespace peloton { namespace catalog { - class TableCatalogObject; class IndexCatalogObject; From 25bb23484ccb06fa435ae74f98a9d4f2ba155fee Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 28 Apr 2018 16:25:14 -0400 Subject: [PATCH 62/85] using expressionPtr --- src/catalog/table_catalog.cpp | 2 +- src/include/catalog/abstract_catalog.h | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 4cc2d82dbef..4463496e729 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -28,7 +28,7 @@ namespace peloton { namespace catalog { - using ExpressionPtr = std::unique_ptr; + TableCatalogObject::TableCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn, int tupleId) diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index 92cab0795cf..a3f5197476e 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -45,6 +45,8 @@ class Tuple; namespace catalog { +using ExpressionPtr = std::unique_ptr; + class AbstractCatalog { public: virtual ~AbstractCatalog() {} From 2fae5d1d9e3e36af160c40fe3198de156ed64890 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 16:32:42 -0400 Subject: [PATCH 63/85] database catalog bound --- src/catalog/database_catalog.cpp | 34 +++++++++++++++----------------- 1 file changed, 16 insertions(+), 18 deletions(-) diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 75a1ebe2ea4..e337a74a329 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -268,17 +268,6 @@ bool DatabaseCatalog::InsertDatabase(oid_t database_oid, const std::string &database_name, 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::GetVarcharValue(database_name, nullptr); -// -// tuple->SetValue(ColumnId::DATABASE_OID, val0, pool); -// tuple->SetValue(ColumnId::DATABASE_NAME, val1, pool); -// -// // Insert the tuple -// return InsertTuple(std::move(tuple), txn); (void) pool; @@ -323,9 +312,14 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( // cache miss, get from pg_database std::vector column_ids(all_column_ids); - expression::AbstractExpression *db_oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, - ColumnId::DATABASE_OID); + auto *db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(database_oid).Copy()); @@ -369,10 +363,14 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( // cache miss, get from pg_database std::vector column_ids(all_column_ids); - expression::AbstractExpression *db_name_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, - ColumnId::DATABASE_NAME); - expression::AbstractExpression *db_name_const_expr = + auto *db_name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, + ColumnId::DATABASE_NAME); + db_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_NAME); + + expression::AbstractExpression *db_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetVarcharValue(database_name, nullptr).Copy()); expression::AbstractExpression *db_name_equality_expr = From edeee6697044d78f1b63319e52553673d1cc27dc Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 16:39:54 -0400 Subject: [PATCH 64/85] index metrics catalog insert --- src/catalog/index_metrics_catalog.cpp | 41 ++++++++++++++++++++------- 1 file changed, 30 insertions(+), 11 deletions(-) diff --git a/src/catalog/index_metrics_catalog.cpp b/src/catalog/index_metrics_catalog.cpp index 6c8c2245fe9..d8da23ee6f5 100644 --- a/src/catalog/index_metrics_catalog.cpp +++ b/src/catalog/index_metrics_catalog.cpp @@ -12,6 +12,7 @@ #include "catalog/index_metrics_catalog.h" +#include "expression/expression_util.h" #include "executor/logical_tile.h" #include "storage/data_table.h" #include "type/value_factory.h" @@ -46,8 +47,10 @@ 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) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + + (void) pool; + // Create the tuple first + std::vector> tuples; auto val0 = type::ValueFactory::GetIntegerValue(database_oid); auto val1 = type::ValueFactory::GetIntegerValue(table_oid); @@ -57,16 +60,32 @@ 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); - tuple->SetValue(ColumnId::DELETES, val4, pool); - tuple->SetValue(ColumnId::INSERTS, val5, pool); - tuple->SetValue(ColumnId::TIME_STAMP, val6, pool); + auto constant_expr_0 = new expression::ConstantValueExpression( + val0); + auto constant_expr_1 = new expression::ConstantValueExpression( + val1); + auto constant_expr_2 = new expression::ConstantValueExpression( + val2); + auto constant_expr_3 = new expression::ConstantValueExpression( + val0); + auto constant_expr_4 = new expression::ConstantValueExpression( + val1); + auto constant_expr_5 = new expression::ConstantValueExpression( + val2); + auto constant_expr_6 = new expression::ConstantValueExpression( + val2); + + tuples.push_back(std::vector()); + auto &values = tuples[0]; + values.push_back(ExpressionPtr(constant_expr_0)); + values.push_back(ExpressionPtr(constant_expr_1)); + values.push_back(ExpressionPtr(constant_expr_2)); + values.push_back(ExpressionPtr(constant_expr_3)); + values.push_back(ExpressionPtr(constant_expr_4)); + values.push_back(ExpressionPtr(constant_expr_5)); + values.push_back(ExpressionPtr(constant_expr_6)); - // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool IndexMetricsCatalog::DeleteIndexMetrics( From b7f2df2344a6ca9caf714a28ebcec871d78e4b4e Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 16:43:59 -0400 Subject: [PATCH 65/85] query history catalog --- src/catalog/index_metrics_catalog.cpp | 8 ++++---- src/catalog/query_history_catalog.cpp | 26 ++++++++++++++++++-------- 2 files changed, 22 insertions(+), 12 deletions(-) diff --git a/src/catalog/index_metrics_catalog.cpp b/src/catalog/index_metrics_catalog.cpp index d8da23ee6f5..6ad1aec4325 100644 --- a/src/catalog/index_metrics_catalog.cpp +++ b/src/catalog/index_metrics_catalog.cpp @@ -67,13 +67,13 @@ bool IndexMetricsCatalog::InsertIndexMetrics( auto constant_expr_2 = new expression::ConstantValueExpression( val2); auto constant_expr_3 = new expression::ConstantValueExpression( - val0); + val3); auto constant_expr_4 = new expression::ConstantValueExpression( - val1); + val4); auto constant_expr_5 = new expression::ConstantValueExpression( - val2); + val5); auto constant_expr_6 = new expression::ConstantValueExpression( - val2); + val6); tuples.push_back(std::vector()); auto &values = tuples[0]; diff --git a/src/catalog/query_history_catalog.cpp b/src/catalog/query_history_catalog.cpp index fa3868dfab1..b63088c3679 100644 --- a/src/catalog/query_history_catalog.cpp +++ b/src/catalog/query_history_catalog.cpp @@ -13,6 +13,7 @@ #include "catalog/query_history_catalog.h" #include "catalog/catalog.h" +#include "expression/expression_util.h" #include "storage/data_table.h" #include "type/value_factory.h" @@ -40,20 +41,29 @@ bool QueryHistoryCatalog::InsertQueryHistory( const std::string &query_string, const std::string &fingerprint, uint64_t timestamp, type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + + (void) pool; + // Create the tuple first + std::vector> tuples; auto val0 = type::ValueFactory::GetVarcharValue(query_string); auto val1 = type::ValueFactory::GetVarcharValue(fingerprint); auto val2 = type::ValueFactory::GetTimestampValue(timestamp); - tuple->SetValue(ColumnId::QUERY_STRING, val0, - pool != nullptr ? pool : &pool_); - tuple->SetValue(ColumnId::FINGERPRINT, val1, pool != nullptr ? pool : &pool_); - tuple->SetValue(ColumnId::TIMESTAMP, val2, pool != nullptr ? pool : &pool_); + auto constant_expr_0 = new expression::ConstantValueExpression( + val0); + auto constant_expr_1 = new expression::ConstantValueExpression( + val1); + auto constant_expr_2 = new expression::ConstantValueExpression( + val2); + + tuples.push_back(std::vector()); + auto &values = tuples[0]; + values.push_back(ExpressionPtr(constant_expr_0)); + values.push_back(ExpressionPtr(constant_expr_1)); + values.push_back(ExpressionPtr(constant_expr_2)); - // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } } // namespace catalog From 71224a429945bfa9f17465c041808223c99bcda5 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 16:46:06 -0400 Subject: [PATCH 66/85] table metrics insert --- src/catalog/table_metrics_catalog.cpp | 41 ++++++++++++++++++++------- 1 file changed, 30 insertions(+), 11 deletions(-) diff --git a/src/catalog/table_metrics_catalog.cpp b/src/catalog/table_metrics_catalog.cpp index 5b3ac52b371..2d035fa02ab 100644 --- a/src/catalog/table_metrics_catalog.cpp +++ b/src/catalog/table_metrics_catalog.cpp @@ -13,6 +13,7 @@ #include "catalog/table_metrics_catalog.h" #include "executor/logical_tile.h" +#include "expression/expression_util.h" #include "storage/data_table.h" #include "type/value_factory.h" @@ -46,8 +47,10 @@ 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) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + + (void) pool; + // Create the tuple first + std::vector> tuples; auto val0 = type::ValueFactory::GetIntegerValue(database_oid); auto val1 = type::ValueFactory::GetIntegerValue(table_oid); @@ -57,16 +60,32 @@ 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); - tuple->SetValue(ColumnId::DELETES, val4, pool); - tuple->SetValue(ColumnId::INSERTS, val5, pool); - tuple->SetValue(ColumnId::TIME_STAMP, val6, pool); + auto constant_expr_0 = new expression::ConstantValueExpression( + val0); + auto constant_expr_1 = new expression::ConstantValueExpression( + val1); + auto constant_expr_2 = new expression::ConstantValueExpression( + val2); + auto constant_expr_3 = new expression::ConstantValueExpression( + val3); + auto constant_expr_4 = new expression::ConstantValueExpression( + val4); + auto constant_expr_5 = new expression::ConstantValueExpression( + val5); + auto constant_expr_6 = new expression::ConstantValueExpression( + val6); + + tuples.push_back(std::vector()); + auto &values = tuples[0]; + values.push_back(ExpressionPtr(constant_expr_0)); + values.push_back(ExpressionPtr(constant_expr_1)); + values.push_back(ExpressionPtr(constant_expr_2)); + values.push_back(ExpressionPtr(constant_expr_3)); + values.push_back(ExpressionPtr(constant_expr_4)); + values.push_back(ExpressionPtr(constant_expr_5)); + values.push_back(ExpressionPtr(constant_expr_6)); - // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool TableMetricsCatalog::DeleteTableMetrics( From 22fe699270a58e569fe166b21c46270e08dc74b1 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 16:57:13 -0400 Subject: [PATCH 67/85] database catalog delete --- src/catalog/database_catalog.cpp | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-) diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index e337a74a329..e14d12d75cb 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -290,14 +290,31 @@ bool DatabaseCatalog::InsertDatabase(oid_t database_oid, bool DatabaseCatalog::DeleteDatabase(oid_t database_oid, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Index of database_oid - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); + + // cache miss, get from pg_database + std::vector column_ids(all_column_ids); + + auto *db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_OID); + + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); + + expression::AbstractExpression *predicate = db_oid_equality_expr; // evict cache txn->catalog_cache.EvictDatabaseObject(database_oid); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); } std::shared_ptr DatabaseCatalog::GetDatabaseObject( From 65f0ea130d36a120099db02160b8376f5ad261ec Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 28 Apr 2018 17:00:45 -0400 Subject: [PATCH 68/85] modify catalog inserts --- src/catalog/column_stats_catalog.cpp | 45 ++++++++++++++++------- src/catalog/database_metrics_catalog.cpp | 30 +++++++++++---- src/catalog/language_catalog.cpp | 14 ++++--- src/catalog/query_metrics_catalog.cpp | 47 ++++++++++++++++-------- src/catalog/trigger_catalog.cpp | 33 +++++++++++------ 5 files changed, 116 insertions(+), 53 deletions(-) diff --git a/src/catalog/column_stats_catalog.cpp b/src/catalog/column_stats_catalog.cpp index fc60e8403d5..888288e4537 100644 --- a/src/catalog/column_stats_catalog.cpp +++ b/src/catalog/column_stats_catalog.cpp @@ -63,8 +63,10 @@ bool ColumnStatsCatalog::InsertColumnStats( std::string most_common_freqs, std::string histogram_bounds, std::string column_name, bool has_index, type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + (void) pool; + std::vector> tuples; +// std::unique_ptr tuple( +// new storage::Tuple(catalog_table_->GetSchema(), true)); auto val_db_id = type::ValueFactory::GetIntegerValue(database_id); auto val_table_id = type::ValueFactory::GetIntegerValue(table_id); @@ -96,20 +98,35 @@ bool ColumnStatsCatalog::InsertColumnStats( type::ValueFactory::GetVarcharValue(column_name); type::Value val_has_index = type::ValueFactory::GetBooleanValue(has_index); - tuple->SetValue(ColumnId::DATABASE_ID, val_db_id, nullptr); - tuple->SetValue(ColumnId::TABLE_ID, val_table_id, nullptr); - tuple->SetValue(ColumnId::COLUMN_ID, val_column_id, nullptr); - tuple->SetValue(ColumnId::NUM_ROWS, val_num_row, nullptr); - tuple->SetValue(ColumnId::CARDINALITY, val_cardinality, nullptr); - tuple->SetValue(ColumnId::FRAC_NULL, val_frac_null, nullptr); - tuple->SetValue(ColumnId::MOST_COMMON_VALS, val_common_val, pool); - tuple->SetValue(ColumnId::MOST_COMMON_FREQS, val_common_freq, pool); - tuple->SetValue(ColumnId::HISTOGRAM_BOUNDS, val_hist_bounds, pool); - tuple->SetValue(ColumnId::COLUMN_NAME, val_column_name, pool); - tuple->SetValue(ColumnId::HAS_INDEX, val_has_index, nullptr); + tuples.push_back(std::vector()); + auto &values = tuples[0]; + + values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_db_id))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_table_id))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_column_id))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_num_row))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_cardinality))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_frac_null))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_common_val))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_common_freq))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_hist_bounds))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_column_name))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_has_index))); + +// tuple->SetValue(ColumnId::DATABASE_ID, val_db_id, nullptr); +// tuple->SetValue(ColumnId::TABLE_ID, val_table_id, nullptr); +// tuple->SetValue(ColumnId::COLUMN_ID, val_column_id, nullptr); +// tuple->SetValue(ColumnId::NUM_ROWS, val_num_row, nullptr); +// tuple->SetValue(ColumnId::CARDINALITY, val_cardinality, nullptr); +// tuple->SetValue(ColumnId::FRAC_NULL, val_frac_null, nullptr); +// tuple->SetValue(ColumnId::MOST_COMMON_VALS, val_common_val, pool); +// tuple->SetValue(ColumnId::MOST_COMMON_FREQS, val_common_freq, pool); +// tuple->SetValue(ColumnId::HISTOGRAM_BOUNDS, val_hist_bounds, pool); +// tuple->SetValue(ColumnId::COLUMN_NAME, val_column_name, pool); +// tuple->SetValue(ColumnId::HAS_INDEX, val_has_index, nullptr); // Insert the tuple into catalog table - return InsertTuple(std::move(tuple), txn); + return InsertTuple(&tuples, txn); } bool ColumnStatsCatalog::DeleteColumnStats( diff --git a/src/catalog/database_metrics_catalog.cpp b/src/catalog/database_metrics_catalog.cpp index 475eb4bd919..cc254fee97e 100644 --- a/src/catalog/database_metrics_catalog.cpp +++ b/src/catalog/database_metrics_catalog.cpp @@ -14,6 +14,8 @@ #include "executor/logical_tile.h" #include "storage/data_table.h" +#include "expression/abstract_expression.h" +#include "expression/expression_util.h" #include "type/value_factory.h" namespace peloton { @@ -44,21 +46,35 @@ 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) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + (void) pool; + std::vector> tuples; + tuples.push_back(std::vector()); + auto &values = tuples[0]; + +// std::unique_ptr tuple( +// new storage::Tuple(catalog_table_->GetSchema(), true)); auto val0 = type::ValueFactory::GetIntegerValue(database_oid); auto val1 = type::ValueFactory::GetIntegerValue(txn_committed); auto val2 = type::ValueFactory::GetIntegerValue(txn_aborted); auto val3 = type::ValueFactory::GetIntegerValue(time_stamp); - tuple->SetValue(ColumnId::DATABASE_OID, val0, pool); - tuple->SetValue(ColumnId::TXN_COMMITTED, val1, pool); - tuple->SetValue(ColumnId::TXN_ABORTED, val2, pool); - tuple->SetValue(ColumnId::TIME_STAMP, val3, pool); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val0))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val1))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val2))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val3))); + +// tuple->SetValue(ColumnId::DATABASE_OID, val0, pool); +// tuple->SetValue(ColumnId::TXN_COMMITTED, val1, pool); +// tuple->SetValue(ColumnId::TXN_ABORTED, val2, pool); +// tuple->SetValue(ColumnId::TIME_STAMP, val3, pool); // Insert the tuple into catalog table - return InsertTuple(std::move(tuple), txn); + return InsertTuple(&tuples, txn); } bool DatabaseMetricsCatalog::DeleteDatabaseMetrics( diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index 6451ca45902..c7e0bfeecac 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -54,18 +54,22 @@ LanguageCatalog::LanguageCatalog(concurrency::TransactionContext *txn) bool LanguageCatalog::InsertLanguage(const std::string &lanname, type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + (void) pool; + std::vector> tuples; + tuples.push_back(std::vector()); + auto &values = tuples[0]; oid_t language_oid = GetNextOid(); auto val0 = type::ValueFactory::GetIntegerValue(language_oid); auto val1 = type::ValueFactory::GetVarcharValue(lanname); - tuple->SetValue(ColumnId::OID, val0, pool); - tuple->SetValue(ColumnId::LANNAME, val1, pool); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val0))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val1))); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(&tuples, txn); } // delete a language by name diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 98d093a5254..6a0fdad5b01 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -62,8 +62,10 @@ bool QueryMetricsCatalog::InsertQueryMetrics( int64_t updates, int64_t deletes, int64_t inserts, int64_t latency, int64_t cpu_time, int64_t time_stamp, type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + + std::vector> tuples; + tuples.push_back(std::vector()); + auto &values = tuples[0]; auto val0 = type::ValueFactory::GetVarcharValue(name, pool); auto val1 = type::ValueFactory::GetIntegerValue(database_oid); @@ -90,22 +92,35 @@ bool QueryMetricsCatalog::InsertQueryMetrics( auto val11 = type::ValueFactory::GetIntegerValue(cpu_time); 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); - tuple->SetValue(ColumnId::PARAM_VALUES, val5, pool); - tuple->SetValue(ColumnId::READS, val6, pool); - tuple->SetValue(ColumnId::UPDATES, val7, pool); - tuple->SetValue(ColumnId::DELETES, val8, pool); - tuple->SetValue(ColumnId::INSERTS, val9, pool); - tuple->SetValue(ColumnId::LATENCY, val10, pool); - tuple->SetValue(ColumnId::CPU_TIME, val11, pool); - tuple->SetValue(ColumnId::TIME_STAMP, val12, pool); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val0))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val1))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val2))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val3))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val4))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val5))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val6))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val7))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val8))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val9))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val10))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val11))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val12))); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(&tuples, txn); } bool QueryMetricsCatalog::DeleteQueryMetrics( diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index 2f7f824c91c..6462b6344ba 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -67,11 +67,14 @@ bool TriggerCatalog::InsertTrigger(oid_t table_oid, std::string trigger_name, type::Value timestamp, type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); LOG_INFO("type of trigger inserted:%d", trigger_type); + (void) pool; + std::vector> tuples; + tuples.push_back(std::vector()); + auto &values = tuples[0]; + auto val0 = type::ValueFactory::GetIntegerValue(GetNextOid()); auto val1 = type::ValueFactory::GetIntegerValue(table_oid); auto val2 = type::ValueFactory::GetVarcharValue(trigger_name); @@ -81,17 +84,25 @@ bool TriggerCatalog::InsertTrigger(oid_t table_oid, std::string trigger_name, auto val6 = fire_condition; auto val7 = timestamp; - tuple->SetValue(ColumnId::TRIGGER_OID, val0, pool); - tuple->SetValue(ColumnId::TABLE_OID, val1, pool); - tuple->SetValue(ColumnId::TRIGGER_NAME, val2, pool); - tuple->SetValue(ColumnId::FUNCTION_NAME, val3, pool); - tuple->SetValue(ColumnId::TRIGGER_TYPE, val4, pool); - tuple->SetValue(ColumnId::FUNCTION_ARGS, val5, pool); - tuple->SetValue(ColumnId::FIRE_CONDITION, val6, pool); - tuple->SetValue(ColumnId::TIMESTAMP, val7, pool); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val0))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val1))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val2))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val3))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val4))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val5))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val6))); + values.push_back(ExpressionPtr(new expression::ConstantValueExpression( + val7))); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTuple(&tuples, txn); } ResultType TriggerCatalog::DropTrigger(const std::string &database_name, From e70be9a502df248d1c86b43fcbf868ad354b27b1 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 28 Apr 2018 17:05:48 -0400 Subject: [PATCH 69/85] change to complied insert plan --- src/catalog/column_stats_catalog.cpp | 16 +--------------- src/catalog/database_metrics_catalog.cpp | 9 +-------- src/catalog/language_catalog.cpp | 2 +- src/catalog/query_metrics_catalog.cpp | 2 +- src/catalog/trigger_catalog.cpp | 2 +- 5 files changed, 5 insertions(+), 26 deletions(-) diff --git a/src/catalog/column_stats_catalog.cpp b/src/catalog/column_stats_catalog.cpp index 888288e4537..f16d347d7f5 100644 --- a/src/catalog/column_stats_catalog.cpp +++ b/src/catalog/column_stats_catalog.cpp @@ -65,8 +65,6 @@ bool ColumnStatsCatalog::InsertColumnStats( concurrency::TransactionContext *txn) { (void) pool; std::vector> tuples; -// std::unique_ptr tuple( -// new storage::Tuple(catalog_table_->GetSchema(), true)); auto val_db_id = type::ValueFactory::GetIntegerValue(database_id); auto val_table_id = type::ValueFactory::GetIntegerValue(table_id); @@ -113,20 +111,8 @@ bool ColumnStatsCatalog::InsertColumnStats( values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_column_name))); values.push_back(ExpressionPtr(new expression::ConstantValueExpression(val_has_index))); -// tuple->SetValue(ColumnId::DATABASE_ID, val_db_id, nullptr); -// tuple->SetValue(ColumnId::TABLE_ID, val_table_id, nullptr); -// tuple->SetValue(ColumnId::COLUMN_ID, val_column_id, nullptr); -// tuple->SetValue(ColumnId::NUM_ROWS, val_num_row, nullptr); -// tuple->SetValue(ColumnId::CARDINALITY, val_cardinality, nullptr); -// tuple->SetValue(ColumnId::FRAC_NULL, val_frac_null, nullptr); -// tuple->SetValue(ColumnId::MOST_COMMON_VALS, val_common_val, pool); -// tuple->SetValue(ColumnId::MOST_COMMON_FREQS, val_common_freq, pool); -// tuple->SetValue(ColumnId::HISTOGRAM_BOUNDS, val_hist_bounds, pool); -// tuple->SetValue(ColumnId::COLUMN_NAME, val_column_name, pool); -// tuple->SetValue(ColumnId::HAS_INDEX, val_has_index, nullptr); - // Insert the tuple into catalog table - return InsertTuple(&tuples, txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool ColumnStatsCatalog::DeleteColumnStats( diff --git a/src/catalog/database_metrics_catalog.cpp b/src/catalog/database_metrics_catalog.cpp index cc254fee97e..8f379a2a9b8 100644 --- a/src/catalog/database_metrics_catalog.cpp +++ b/src/catalog/database_metrics_catalog.cpp @@ -51,9 +51,6 @@ bool DatabaseMetricsCatalog::InsertDatabaseMetrics( tuples.push_back(std::vector()); auto &values = tuples[0]; -// std::unique_ptr tuple( -// new storage::Tuple(catalog_table_->GetSchema(), true)); - auto val0 = type::ValueFactory::GetIntegerValue(database_oid); auto val1 = type::ValueFactory::GetIntegerValue(txn_committed); auto val2 = type::ValueFactory::GetIntegerValue(txn_aborted); @@ -68,13 +65,9 @@ bool DatabaseMetricsCatalog::InsertDatabaseMetrics( values.push_back(ExpressionPtr(new expression::ConstantValueExpression( val3))); -// tuple->SetValue(ColumnId::DATABASE_OID, val0, pool); -// tuple->SetValue(ColumnId::TXN_COMMITTED, val1, pool); -// tuple->SetValue(ColumnId::TXN_ABORTED, val2, pool); -// tuple->SetValue(ColumnId::TIME_STAMP, val3, pool); // Insert the tuple into catalog table - return InsertTuple(&tuples, txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool DatabaseMetricsCatalog::DeleteDatabaseMetrics( diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index c7e0bfeecac..6b8e1e95f26 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -69,7 +69,7 @@ bool LanguageCatalog::InsertLanguage(const std::string &lanname, val1))); // Insert the tuple - return InsertTuple(&tuples, txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } // delete a language by name diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 6a0fdad5b01..6b51a85270d 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -120,7 +120,7 @@ bool QueryMetricsCatalog::InsertQueryMetrics( val12))); // Insert the tuple - return InsertTuple(&tuples, txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool QueryMetricsCatalog::DeleteQueryMetrics( diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index 6462b6344ba..809747a5713 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -102,7 +102,7 @@ bool TriggerCatalog::InsertTrigger(oid_t table_oid, std::string trigger_name, val7))); // Insert the tuple - return InsertTuple(&tuples, txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } ResultType TriggerCatalog::DropTrigger(const std::string &database_name, From 0a02fbf671cfcac8e87d166c67320b93396b41c2 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 17:07:50 -0400 Subject: [PATCH 70/85] intex metrics catalog delete --- src/catalog/index_metrics_catalog.cpp | 25 +++++++++++++++++---- src/include/catalog/index_metrics_catalog.h | 2 ++ 2 files changed, 23 insertions(+), 4 deletions(-) diff --git a/src/catalog/index_metrics_catalog.cpp b/src/catalog/index_metrics_catalog.cpp index 6ad1aec4325..ec6d5fa8ec7 100644 --- a/src/catalog/index_metrics_catalog.cpp +++ b/src/catalog/index_metrics_catalog.cpp @@ -90,12 +90,29 @@ bool IndexMetricsCatalog::InsertIndexMetrics( bool IndexMetricsCatalog::DeleteIndexMetrics( oid_t index_oid, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(index_oid).Copy()); + // cache miss, get from pg_database + std::vector column_ids(all_column_ids); + + auto *oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + + oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_OID); + + expression::AbstractExpression *oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(index_oid).Copy()); + expression::AbstractExpression *oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, oid_expr, oid_const_expr); + + expression::AbstractExpression *predicate = oid_equality_expr; + + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); - return DeleteWithIndexScan(index_offset, values, txn); } } // namespace catalog diff --git a/src/include/catalog/index_metrics_catalog.h b/src/include/catalog/index_metrics_catalog.h index 8a83eb13694..0e654bd245b 100644 --- a/src/include/catalog/index_metrics_catalog.h +++ b/src/include/catalog/index_metrics_catalog.h @@ -74,6 +74,8 @@ class IndexMetricsCatalog : public AbstractCatalog { // Add new columns here in creation order }; + std::vector all_column_ids = {0, 1, 2, 3, 4, 5, 6}; + enum IndexId { PRIMARY_KEY = 0, // Add new indexes here in creation order From 8da46b563c2271ef6899d695d1604c5c9b854de6 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 17:10:43 -0400 Subject: [PATCH 71/85] table metrics catalog delete --- src/catalog/table_metrics_catalog.cpp | 23 +++++++++++++++++---- src/include/catalog/table_metrics_catalog.h | 2 ++ 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/src/catalog/table_metrics_catalog.cpp b/src/catalog/table_metrics_catalog.cpp index 2d035fa02ab..428f92d0fb1 100644 --- a/src/catalog/table_metrics_catalog.cpp +++ b/src/catalog/table_metrics_catalog.cpp @@ -90,12 +90,27 @@ bool TableMetricsCatalog::InsertTableMetrics( bool TableMetricsCatalog::DeleteTableMetrics( oid_t table_oid, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); + std::vector column_ids(all_column_ids); - return DeleteWithIndexScan(index_offset, values, txn); + auto *oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + + oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_OID); + + expression::AbstractExpression *oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, oid_expr, oid_const_expr); + + expression::AbstractExpression *predicate = oid_equality_expr; + + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); } } // namespace catalog diff --git a/src/include/catalog/table_metrics_catalog.h b/src/include/catalog/table_metrics_catalog.h index a55b8de807b..2be217f8057 100644 --- a/src/include/catalog/table_metrics_catalog.h +++ b/src/include/catalog/table_metrics_catalog.h @@ -74,6 +74,8 @@ class TableMetricsCatalog : public AbstractCatalog { // Add new columns here in creation order }; + std::vector all_column_ids = {0, 1, 2, 3, 4, 5, 6}; + enum IndexId { PRIMARY_KEY = 0, // Add new indexes here in creation order From 9c4a1ee47eca993b077f07e6b2bb344fb4e30841 Mon Sep 17 00:00:00 2001 From: Zeninma Date: Sat, 28 Apr 2018 17:39:56 -0400 Subject: [PATCH 72/85] Edited cloumn_catalog, index_catalog, proc_catalog, settings_catalog Added Insert and Delete with Compiled Query Fixed Binding for TupleValueExpression --- src/catalog/column_catalog.cpp | 80 +++++++++++++++++++++++--------- src/catalog/index_catalog.cpp | 70 +++++++++++++++++++++------- src/catalog/proc_catalog.cpp | 50 ++++++++++++++------ src/catalog/settings_catalog.cpp | 63 ++++++++++++++++++------- 4 files changed, 193 insertions(+), 70 deletions(-) diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index 95334d5b285..20c8cc27d1e 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -168,9 +168,9 @@ bool ColumnCatalog::InsertColumn(oid_t table_oid, const std::vector &constraints, type::AbstractPool *pool, concurrency::TransactionContext *txn) { + (void) pool; // Create the tuple first - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + std::vector> tuples; auto val0 = type::ValueFactory::GetIntegerValue(table_oid); auto val1 = type::ValueFactory::GetVarcharValue(column_name, nullptr); @@ -191,17 +191,36 @@ bool ColumnCatalog::InsertColumn(oid_t table_oid, auto val6 = type::ValueFactory::GetBooleanValue(is_primary); auto val7 = type::ValueFactory::GetBooleanValue(is_not_null); - tuple->SetValue(ColumnId::TABLE_OID, val0, pool); - tuple->SetValue(ColumnId::COLUMN_NAME, val1, pool); - tuple->SetValue(ColumnId::COLUMN_ID, val2, pool); - tuple->SetValue(ColumnId::COLUMN_OFFSET, val3, pool); - tuple->SetValue(ColumnId::COLUMN_TYPE, val4, pool); - tuple->SetValue(ColumnId::IS_INLINED, val5, pool); - tuple->SetValue(ColumnId::IS_PRIMARY, val6, pool); - tuple->SetValue(ColumnId::IS_NOT_NULL, val7, pool); - + auto constant_expr_0 = new expression::ConstantValueExpression( + val0); + auto constant_expr_1 = new expression::ConstantValueExpression( + val1); + auto constant_expr_2 = new expression::ConstantValueExpression( + val2); + auto constant_expr_3 = new expression::ConstantValueExpression( + val3); + auto constant_expr_4 = new expression::ConstantValueExpression( + val4); + auto constant_expr_5 = new expression::ConstantValueExpression( + val5); + auto constant_expr_6 = new expression::ConstantValueExpression( + val6); + auto constant_expr_7 = new expression::ConstantValueExpression( + val7); + + tuples.push_back(std::vector()); + auto &values = tuples[0]; + + values.push_back(ExpressionPtr(constant_expr_0)); + values.push_back(ExpressionPtr(constant_expr_1)); + values.push_back(ExpressionPtr(constant_expr_2)); + values.push_back(ExpressionPtr(constant_expr_3)); + values.push_back(ExpressionPtr(constant_expr_4)); + values.push_back(ExpressionPtr(constant_expr_5)); + values.push_back(ExpressionPtr(constant_expr_6)); + values.push_back(ExpressionPtr(constant_expr_7)); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool ColumnCatalog::DeleteColumn(oid_t table_oid, @@ -230,16 +249,30 @@ bool ColumnCatalog::DeleteColumn(oid_t table_oid, */ bool ColumnCatalog::DeleteColumns(oid_t table_oid, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::SKEY_TABLE_OID; // Index of table_oid - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); + + std::vector column_ids(all_column_ids); + + auto *table_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + table_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TABLE_OID); + + expression::AbstractExpression *table_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *table_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, table_oid_expr, table_oid_const_expr); + + bool result = DeleteWithCompiledSeqScan(column_ids, table_oid_equality_expr, txn); // delete columns from cache - auto table_object = + if(result){ + auto table_object = TableCatalog::GetInstance()->GetTableObject(table_oid, txn); - table_object->EvictAllColumnObjects(); - - return DeleteWithIndexScan(index_offset, values, txn); + table_object->EvictAllColumnObjects(); + } + return result; } const std::unordered_map> @@ -255,9 +288,12 @@ ColumnCatalog::GetColumnObjects(oid_t table_oid, // cache miss, get from pg_attribute std::vector column_ids(all_column_ids); - expression::AbstractExpression *tb_oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, - ColumnId::TABLE_OID); + auto tb_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + + tb_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TABLE_OID); + expression::AbstractExpression *tb_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(table_oid).Copy()); diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index d9156f9209c..19eabe93135 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -175,9 +175,9 @@ bool IndexCatalog::InsertIndex(oid_t index_oid, const std::string &index_name, bool unique_keys, std::vector indekeys, type::AbstractPool *pool, concurrency::TransactionContext *txn) { + (void) pool; // Create the tuple first - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + std::vector> tuples; auto val0 = type::ValueFactory::GetIntegerValue(index_oid); auto val1 = type::ValueFactory::GetVarcharValue(index_name, nullptr); @@ -191,32 +191,68 @@ bool IndexCatalog::InsertIndex(oid_t index_oid, const std::string &index_name, for (oid_t indkey : indekeys) os << std::to_string(indkey) << " "; auto val6 = 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); + auto constant_expr_0 = new expression::ConstantValueExpression( + val0); + auto constant_expr_1 = new expression::ConstantValueExpression( + val1); + auto constant_expr_2 = new expression::ConstantValueExpression( + val2); + auto constant_expr_3 = new expression::ConstantValueExpression( + val3); + auto constant_expr_4 = new expression::ConstantValueExpression( + val4); + auto constant_expr_5 = new expression::ConstantValueExpression( + val5); + auto constant_expr_6 = new expression::ConstantValueExpression( + val6); + + tuples.push_back(std::vector()); + auto &values = tuples[0]; + values.push_back(ExpressionPtr(constant_expr_0)); + values.push_back(ExpressionPtr(constant_expr_1)); + values.push_back(ExpressionPtr(constant_expr_2)); + values.push_back(ExpressionPtr(constant_expr_3)); + values.push_back(ExpressionPtr(constant_expr_4)); + values.push_back(ExpressionPtr(constant_expr_5)); + values.push_back(ExpressionPtr(constant_expr_6)); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool IndexCatalog::DeleteIndex(oid_t index_oid, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Index of index_oid + std::vector column_ids(all_column_ids); + + std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(index_oid).Copy()); - auto index_object = txn->catalog_cache.GetCachedIndexObject(index_oid); - if (index_object) { - auto table_object = + auto index_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::INDEX_OID); + index_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::TABLE_OID); + + + expression::AbstractExpression *index_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(index_oid).Copy()); + expression::AbstractExpression *index_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, index_oid_expr, index_oid_const_expr); + + bool result = DeleteWithCompiledSeqScan(column_ids, index_oid_equality_expr, txn); + + if(result){ + auto index_object = txn->catalog_cache.GetCachedIndexObject(index_oid); + if (index_object) { + auto table_object = txn->catalog_cache.GetCachedTableObject(index_object->GetTableOid()); - table_object->EvictAllIndexObjects(); + table_object->EvictAllIndexObjects(); + } } - - return DeleteWithIndexScan(index_offset, values, txn); + return result; } std::shared_ptr IndexCatalog::GetIndexObject( diff --git a/src/catalog/proc_catalog.cpp b/src/catalog/proc_catalog.cpp index 0052fceee41..aae73e6b7d1 100644 --- a/src/catalog/proc_catalog.cpp +++ b/src/catalog/proc_catalog.cpp @@ -79,8 +79,9 @@ bool ProcCatalog::InsertProc(const std::string &proname, oid_t prolang, const std::string &prosrc, type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + (void) pool; + // Create the tuple first + std::vector> tuples; oid_t proc_oid = GetNextOid(); auto val0 = type::ValueFactory::GetIntegerValue(proc_oid); @@ -91,15 +92,29 @@ bool ProcCatalog::InsertProc(const std::string &proname, auto val4 = type::ValueFactory::GetIntegerValue(prolang); auto val5 = type::ValueFactory::GetVarcharValue(prosrc); - tuple->SetValue(ColumnId::OID, val0, pool); - tuple->SetValue(ColumnId::PRONAME, val1, pool); - tuple->SetValue(ColumnId::PRORETTYPE, val2, pool); - tuple->SetValue(ColumnId::PROARGTYPES, val3, pool); - tuple->SetValue(ColumnId::PROLANG, val4, pool); - tuple->SetValue(ColumnId::PROSRC, val5, pool); - - // Insert the tuple - return InsertTuple(std::move(tuple), txn); + auto constant_expr_0 = new expression::ConstantValueExpression( + val0); + auto constant_expr_1 = new expression::ConstantValueExpression( + val1); + auto constant_expr_2 = new expression::ConstantValueExpression( + val2); + auto constant_expr_3 = new expression::ConstantValueExpression( + val3); + auto constant_expr_4 = new expression::ConstantValueExpression( + val4); + auto constant_expr_5 = new expression::ConstantValueExpression( + val5); + + tuples.push_back(std::vector()); + auto &values = tuples[0]; + values.push_back(ExpressionPtr(constant_expr_0)); + values.push_back(ExpressionPtr(constant_expr_1)); + values.push_back(ExpressionPtr(constant_expr_2)); + values.push_back(ExpressionPtr(constant_expr_3)); + values.push_back(ExpressionPtr(constant_expr_4)); + values.push_back(ExpressionPtr(constant_expr_5)); + + return InsertTupleWithCompiledPlan(&tuples, txn); } std::unique_ptr ProcCatalog::GetProcByOid( @@ -128,9 +143,12 @@ std::unique_ptr ProcCatalog::GetProcByName( concurrency::TransactionContext *txn) const { std::vector column_ids(all_column_ids); - expression::AbstractExpression *proc_name_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + auto *proc_name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, ColumnId::PRONAME); + proc_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::PRONAME); + expression::AbstractExpression *proc_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetVarcharValue(proc_name, nullptr).Copy()); @@ -138,9 +156,11 @@ std::unique_ptr ProcCatalog::GetProcByName( expression::ExpressionUtil::ComparisonFactory( ExpressionType::COMPARE_EQUAL, proc_name_expr, proc_name_const_expr); - expression::AbstractExpression *proc_args_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + auto *proc_args_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, ColumnId::PROARGTYPES); + proc_args_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::PROARGTYPES); expression::AbstractExpression *proc_args_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetVarcharValue( diff --git a/src/catalog/settings_catalog.cpp b/src/catalog/settings_catalog.cpp index 845bd8622f0..0f412c17db2 100644 --- a/src/catalog/settings_catalog.cpp +++ b/src/catalog/settings_catalog.cpp @@ -57,9 +57,9 @@ bool SettingsCatalog::InsertSetting( const std::string &max_value, const std::string &default_value, bool is_mutable, bool is_persistent, type::AbstractPool *pool, concurrency::TransactionContext *txn) { + (void) pool; // Create the tuple first - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + std::vector> tuples; auto val0 = type::ValueFactory::GetVarcharValue(name, pool); auto val1 = type::ValueFactory::GetVarcharValue(value, pool); @@ -72,27 +72,58 @@ bool SettingsCatalog::InsertSetting( auto val7 = type::ValueFactory::GetBooleanValue(is_mutable); auto val8 = type::ValueFactory::GetBooleanValue(is_persistent); - tuple->SetValue(static_cast(ColumnId::NAME), val0, pool); - tuple->SetValue(static_cast(ColumnId::VALUE), val1, pool); - tuple->SetValue(static_cast(ColumnId::VALUE_TYPE), val2, pool); - tuple->SetValue(static_cast(ColumnId::DESCRIPTION), val3, pool); - tuple->SetValue(static_cast(ColumnId::MIN_VALUE), val4, pool); - tuple->SetValue(static_cast(ColumnId::MAX_VALUE), val5, pool); - tuple->SetValue(static_cast(ColumnId::DEFAULT_VALUE), val6, pool); - tuple->SetValue(static_cast(ColumnId::IS_MUTABLE), val7, pool); - tuple->SetValue(static_cast(ColumnId::IS_PERSISTENT), val8, pool); + auto constant_expr_0 = new expression::ConstantValueExpression( + val0); + auto constant_expr_1 = new expression::ConstantValueExpression( + val1); + auto constant_expr_2 = new expression::ConstantValueExpression( + val2); + auto constant_expr_3 = new expression::ConstantValueExpression( + val3); + auto constant_expr_4 = new expression::ConstantValueExpression( + val4); + auto constant_expr_5 = new expression::ConstantValueExpression( + val5); + auto constant_expr_6 = new expression::ConstantValueExpression( + val6); + auto constant_expr_7 = new expression::ConstantValueExpression( + val7); + auto constant_expr_8 = new expression::ConstantValueExpression( + val8); + + tuples.push_back(std::vector()); + auto &values = tuples[0]; + values.push_back(ExpressionPtr(constant_expr_0)); + values.push_back(ExpressionPtr(constant_expr_1)); + values.push_back(ExpressionPtr(constant_expr_2)); + values.push_back(ExpressionPtr(constant_expr_3)); + values.push_back(ExpressionPtr(constant_expr_4)); + values.push_back(ExpressionPtr(constant_expr_5)); + values.push_back(ExpressionPtr(constant_expr_6)); + values.push_back(ExpressionPtr(constant_expr_7)); + values.push_back(ExpressionPtr(constant_expr_8)); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool SettingsCatalog::DeleteSetting(const std::string &name, concurrency::TransactionContext *txn) { - oid_t index_offset = 0; - std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); + std::vector column_ids(all_column_ids); - return DeleteWithIndexScan(index_offset, values, txn); + auto *name_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::NAME); + name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::NAME); + + expression::AbstractExpression *name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(name).Copy()); + expression::AbstractExpression *name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, name_expr, name_const_expr); + + return DeleteWithCompiledSeqScan(column_ids, name_equality_expr, txn); } std::string SettingsCatalog::GetSettingValue( From 2d86aff64c638adafa9b0168823257635dfc9761 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 28 Apr 2018 19:19:40 -0400 Subject: [PATCH 73/85] update catalog to use compiled delete plan --- src/catalog/column_stats_catalog.cpp | 182 ++++++++++++------ src/catalog/database_metrics_catalog.cpp | 16 +- src/catalog/language_catalog.cpp | 17 +- src/catalog/query_metrics_catalog.cpp | 37 +++- src/catalog/table_catalog.cpp | 19 +- src/catalog/trigger_catalog.cpp | 38 +++- src/include/catalog/column_stats_catalog.h | 1 + .../catalog/database_metrics_catalog.h | 2 +- 8 files changed, 223 insertions(+), 89 deletions(-) diff --git a/src/catalog/column_stats_catalog.cpp b/src/catalog/column_stats_catalog.cpp index f16d347d7f5..64b12856a0a 100644 --- a/src/catalog/column_stats_catalog.cpp +++ b/src/catalog/column_stats_catalog.cpp @@ -118,27 +118,72 @@ bool ColumnStatsCatalog::InsertColumnStats( 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 column_ids(all_column_ids); + + auto *db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_ID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_ID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_id).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); + + auto *tb_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_ID); + tb_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::TABLE_ID); + expression::AbstractExpression *tb_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_id).Copy()); + expression::AbstractExpression *tb_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, tb_oid_expr, tb_oid_const_expr); + + auto *col_id_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::COLUMN_ID); + col_id_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::COLUMN_ID); + expression::AbstractExpression *col_id_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(column_id).Copy()); + expression::AbstractExpression *col_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, col_id_expr, col_id_const_expr); + + expression::AbstractExpression *db_and_tb = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_oid_equality_expr, + tb_oid_equality_expr); + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_and_tb, col_oid_equality_expr); - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(database_id).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(table_id).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(column_id).Copy()); - return DeleteWithIndexScan(index_offset, values, txn); + + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); } std::unique_ptr> ColumnStatsCatalog::GetColumnStats( oid_t database_id, oid_t table_id, oid_t column_id, concurrency::TransactionContext *txn) { - std::vector column_ids( - {ColumnId::NUM_ROWS, ColumnId::CARDINALITY, ColumnId::FRAC_NULL, - ColumnId::MOST_COMMON_VALS, ColumnId::MOST_COMMON_FREQS, - ColumnId::HISTOGRAM_BOUNDS, ColumnId::COLUMN_NAME, ColumnId::HAS_INDEX}); - expression::AbstractExpression *db_oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + std::vector column_ids(all_column_ids); + + auto *db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, ColumnId::DATABASE_ID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_ID); expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(database_id).Copy()); @@ -146,9 +191,12 @@ std::unique_ptr> ColumnStatsCatalog::GetColumnStats( expression::ExpressionUtil::ComparisonFactory( ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); - expression::AbstractExpression *tb_oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + auto *tb_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, ColumnId::TABLE_ID); + tb_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::TABLE_ID); expression::AbstractExpression *tb_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(table_id).Copy()); @@ -156,9 +204,12 @@ std::unique_ptr> ColumnStatsCatalog::GetColumnStats( expression::ExpressionUtil::ComparisonFactory( ExpressionType::COMPARE_EQUAL, tb_oid_expr, tb_oid_const_expr); - expression::AbstractExpression *col_id_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + auto *col_id_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, ColumnId::COLUMN_ID); + col_id_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::COLUMN_ID); expression::AbstractExpression *col_id_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(column_id).Copy()); @@ -187,14 +238,14 @@ std::unique_ptr> ColumnStatsCatalog::GetColumnStats( type::Value num_rows, cardinality, frac_null, most_common_vals, most_common_freqs, hist_bounds, column_name, has_index; - num_rows = tuple.GetValue(ColumnStatsOffset::NUM_ROWS_OFF); - cardinality = tuple.GetValue(ColumnStatsOffset::CARDINALITY_OFF); - frac_null = tuple.GetValue(ColumnStatsOffset::FRAC_NULL_OFF); - most_common_vals = tuple.GetValue(ColumnStatsOffset::COMMON_VALS_OFF); - most_common_freqs = tuple.GetValue(ColumnStatsOffset::COMMON_FREQS_OFF); - hist_bounds = tuple.GetValue(ColumnStatsOffset::HIST_BOUNDS_OFF); - column_name = tuple.GetValue(ColumnStatsOffset::COLUMN_NAME_OFF); - has_index = tuple.GetValue(ColumnStatsOffset::HAS_INDEX_OFF); + num_rows = tuple.GetValue(ColumnId::NUM_ROWS); + cardinality = tuple.GetValue(ColumnId::CARDINALITY); + frac_null = tuple.GetValue(ColumnId::FRAC_NULL); + most_common_vals = tuple.GetValue(ColumnId::MOST_COMMON_VALS); + most_common_freqs = tuple.GetValue(ColumnId::MOST_COMMON_FREQS); + hist_bounds = tuple.GetValue(ColumnId::HISTOGRAM_BOUNDS); + column_name = tuple.GetValue(ColumnId::COLUMN_NAME); + has_index = tuple.GetValue(ColumnId::HAS_INDEX); std::unique_ptr> column_stats( new std::vector({num_rows, cardinality, frac_null, @@ -209,26 +260,44 @@ size_t ColumnStatsCatalog::GetTableStats( oid_t database_id, oid_t table_id, concurrency::TransactionContext *txn, std::map>> & column_stats_map) { - std::vector column_ids( - {ColumnId::COLUMN_ID, ColumnId::NUM_ROWS, ColumnId::CARDINALITY, - ColumnId::FRAC_NULL, ColumnId::MOST_COMMON_VALS, - ColumnId::MOST_COMMON_FREQS, ColumnId::HISTOGRAM_BOUNDS, - ColumnId::COLUMN_NAME, ColumnId::HAS_INDEX}); - oid_t index_offset = IndexId::SECONDARY_KEY_1; // Secondary key index - - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(database_id).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(table_id).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - - PELOTON_ASSERT(result_tiles->size() <= 1); // unique - if (result_tiles->size() == 0) { - return 0; - } - auto tile = (*result_tiles)[0].get(); - size_t tuple_count = tile->GetTupleCount(); + std::vector column_ids(all_column_ids); + + auto *db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_ID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_ID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_id).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, + db_oid_const_expr); + + auto *tb_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_ID); + tb_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::TABLE_ID); + expression::AbstractExpression *tb_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_id).Copy()); + expression::AbstractExpression *tb_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, tb_oid_expr, tb_oid_const_expr); + + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_oid_equality_expr, + tb_oid_equality_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); + + size_t tuple_count = result_tuples.size(); LOG_DEBUG("Tuple count: %lu", tuple_count); if (tuple_count == 0) { return 0; @@ -236,27 +305,22 @@ size_t ColumnStatsCatalog::GetTableStats( type::Value num_rows, cardinality, frac_null, most_common_vals, most_common_freqs, hist_bounds, column_name, has_index; - for (size_t tuple_id = 0; tuple_id < tuple_count; ++tuple_id) { - num_rows = tile->GetValue(tuple_id, 1 + ColumnStatsOffset::NUM_ROWS_OFF); - cardinality = - tile->GetValue(tuple_id, 1 + ColumnStatsOffset::CARDINALITY_OFF); - frac_null = tile->GetValue(tuple_id, 1 + ColumnStatsOffset::FRAC_NULL_OFF); - most_common_vals = - tile->GetValue(tuple_id, 1 + ColumnStatsOffset::COMMON_VALS_OFF); - most_common_freqs = - tile->GetValue(tuple_id, 1 + ColumnStatsOffset::COMMON_FREQS_OFF); - hist_bounds = - tile->GetValue(tuple_id, 1 + ColumnStatsOffset::HIST_BOUNDS_OFF); - column_name = - tile->GetValue(tuple_id, 1 + ColumnStatsOffset::COLUMN_NAME_OFF); - has_index = tile->GetValue(tuple_id, 1 + ColumnStatsOffset::HAS_INDEX_OFF); + for (auto tuple : result_tuples) { + num_rows = tuple.GetValue(ColumnId::NUM_ROWS); + cardinality = tuple.GetValue(ColumnId::CARDINALITY); + frac_null = tuple.GetValue(ColumnId::FRAC_NULL); + most_common_vals = tuple.GetValue(ColumnId::MOST_COMMON_VALS); + most_common_freqs = tuple.GetValue(ColumnId::MOST_COMMON_FREQS); + hist_bounds = tuple.GetValue(ColumnId::HISTOGRAM_BOUNDS); + column_name = tuple.GetValue(ColumnId::COLUMN_NAME); + has_index = tuple.GetValue(ColumnId::HAS_INDEX); std::unique_ptr> column_stats( new std::vector({num_rows, cardinality, frac_null, most_common_vals, most_common_freqs, hist_bounds, column_name, has_index})); - oid_t column_id = tile->GetValue(tuple_id, 0).GetAs(); + oid_t column_id = tuple.GetValue(ColumnId::COLUMN_ID).GetAs(); column_stats_map[column_id] = std::move(column_stats); } return tuple_count; diff --git a/src/catalog/database_metrics_catalog.cpp b/src/catalog/database_metrics_catalog.cpp index 8f379a2a9b8..0ce91e1968f 100644 --- a/src/catalog/database_metrics_catalog.cpp +++ b/src/catalog/database_metrics_catalog.cpp @@ -72,12 +72,18 @@ bool DatabaseMetricsCatalog::InsertDatabaseMetrics( bool DatabaseMetricsCatalog::DeleteDatabaseMetrics( oid_t database_oid, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index + std::vector column_ids(all_column_ids); - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); - - return DeleteWithIndexScan(index_offset, values, txn); + expression::AbstractExpression *db_oid_expr = + expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); } } // namespace catalog diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index 6b8e1e95f26..41b745a29c8 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -75,13 +75,20 @@ bool LanguageCatalog::InsertLanguage(const std::string &lanname, // delete a language by name bool LanguageCatalog::DeleteLanguage(const std::string &lanname, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::SECONDARY_KEY_0; + std::vector column_ids(all_column_ids); - std::vector values; - values.push_back( - type::ValueFactory::GetVarcharValue(lanname, nullptr).Copy()); + auto *lan_name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, + ColumnId::LANNAME); + expression::AbstractExpression *lan_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(lanname, nullptr).Copy()); + expression::AbstractExpression *lan_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, lan_name_expr, + lan_name_const_expr); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithCompiledSeqScan(column_ids, lan_name_equality_expr, txn); } std::unique_ptr LanguageCatalog::GetLanguageByOid( diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 6b51a85270d..37ee289fc35 100644 --- a/src/catalog/query_metrics_catalog.cpp +++ b/src/catalog/query_metrics_catalog.cpp @@ -126,13 +126,40 @@ bool QueryMetricsCatalog::InsertQueryMetrics( 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 + std::vector column_ids(all_column_ids); + + auto *name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, + ColumnId::NAME); + name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::NAME); + expression::AbstractExpression *name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); + expression::AbstractExpression *name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, name_expr, + name_const_expr); - std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); + auto *db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); - return DeleteWithIndexScan(index_offset, values, txn); + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, name_equality_expr, + db_oid_equality_expr); + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); } stats::QueryMetric::QueryParamBuf QueryMetricsCatalog::GetParamTypes( diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 4463496e729..47e6ca68877 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -516,12 +516,12 @@ std::shared_ptr TableCatalog::GetTableObject( // cache miss, get from pg_table std::vector column_ids(all_column_ids); - // need the predicate for the seq scan (conjunction) - // table_name == table_name and database_oid need to be same - // only need to get the logical tiles that wrap oid, name, db_oid - expression::AbstractExpression *table_name_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + auto *table_name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, ColumnId::TABLE_NAME); + table_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::TABLE_NAME); expression::AbstractExpression *table_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetVarcharValue(table_name, nullptr).Copy()); @@ -530,9 +530,12 @@ std::shared_ptr TableCatalog::GetTableObject( ExpressionType::COMPARE_EQUAL, table_name_expr, table_name_const_expr); - expression::AbstractExpression *db_oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + auto *db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, ColumnId::DATABASE_OID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_OID); expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(database_oid).Copy()); @@ -545,8 +548,6 @@ std::shared_ptr TableCatalog::GetTableObject( ExpressionType::CONJUNCTION_AND, table_name_equality_expr, db_oid_equality_expr); - // LOG_DEBUG("Get table: %s", predicate->GetInfo().c_str()); - // change this to seq plan // ceate predicate refering to seq_scan_test.cpp std::vector result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index 809747a5713..ce721014515 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -192,12 +192,40 @@ oid_t TriggerCatalog::GetTriggerOid(std::string trigger_name, oid_t table_oid, bool TriggerCatalog::DeleteTriggerByName(const std::string &trigger_name, oid_t table_oid, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::NAME_TABLE_KEY_2; - std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue(trigger_name).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); + std::vector column_ids(all_column_ids); + + auto *trigger_name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, + ColumnId::TRIGGER_NAME); + trigger_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::TRIGGER_NAME); + expression::AbstractExpression *trigger_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(trigger_name, nullptr).Copy()); + expression::AbstractExpression *trigger_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, trigger_name_expr, + trigger_name_const_expr); + + auto *table_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + table_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::TABLE_OID); + expression::AbstractExpression *table_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *table_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, table_oid_expr, table_oid_const_expr); - return DeleteWithIndexScan(index_offset, values, txn); + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, trigger_name_equality_expr, + table_oid_equality_expr); + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); } std::unique_ptr TriggerCatalog::GetTriggersByType( diff --git a/src/include/catalog/column_stats_catalog.h b/src/include/catalog/column_stats_catalog.h index d409a9da338..9f2aa57b77b 100644 --- a/src/include/catalog/column_stats_catalog.h +++ b/src/include/catalog/column_stats_catalog.h @@ -107,6 +107,7 @@ class ColumnStatsCatalog : public AbstractCatalog { private: ColumnStatsCatalog(concurrency::TransactionContext *txn); + std::vector all_column_ids = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; enum IndexId { SECONDARY_KEY_0 = 0, diff --git a/src/include/catalog/database_metrics_catalog.h b/src/include/catalog/database_metrics_catalog.h index 1eae00bc325..1bd2246924c 100644 --- a/src/include/catalog/database_metrics_catalog.h +++ b/src/include/catalog/database_metrics_catalog.h @@ -68,7 +68,7 @@ class DatabaseMetricsCatalog : public AbstractCatalog { private: DatabaseMetricsCatalog(concurrency::TransactionContext *txn); - + std::vector all_column_ids = {0, 1, 2, 3}; enum IndexId { PRIMARY_KEY = 0, // Add new indexes here in creation order From 6ecd13800399cbc28d844d94548d5c0e47e3bc7f Mon Sep 17 00:00:00 2001 From: Zeninma Date: Sat, 28 Apr 2018 20:03:52 -0400 Subject: [PATCH 74/85] fixed code review addressed issue --- src/catalog/abstract_catalog.cpp | 5 ++--- src/catalog/database_catalog.cpp | 6 +++--- src/catalog/settings_catalog.cpp | 16 ++++++++-------- src/catalog/zone_map_catalog.cpp | 3 --- src/include/catalog/settings_catalog.h | 2 +- test/codegen/zone_map_scan_test.cpp | 26 +++++++++++++------------- test/optimizer/old_optimizer_test.cpp | 8 +------- 7 files changed, 28 insertions(+), 38 deletions(-) diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 244fa9deb8b..149a4db4c00 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -379,9 +379,8 @@ AbstractCatalog::GetResultWithCompiledSeqScan( // search for query codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); std::unique_ptr compiled_query(nullptr); - cached = (query != nullptr); -// cached = false; - // LOG_DEBUG("cache %d", cached); + cached = (query != nullptr); + // if not cached, compile the query and save it into cache if (!cached) { compiled_query = codegen::QueryCompiler().Compile( diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index e14d12d75cb..3e1b6838760 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -64,13 +64,13 @@ bool DatabaseCatalogObject::InsertTableObject( // check if already in cache if (table_objects_cache.find(table_object->GetTableOid()) != table_objects_cache.end()) { - LOG_DEBUG("Table %u already exists in cache!", table_object->GetTableOid()); + LOG_TRACE("Table %u already exists in cache!", table_object->GetTableOid()); return false; } if (table_name_cache.find(table_object->GetTableName()) != table_name_cache.end()) { - LOG_DEBUG("Table %s already exists in cache!", + LOG_TRACE("Table %s already exists in cache!", table_object->GetTableName().c_str()); return false; } @@ -356,7 +356,7 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( (void)success; return database_object; } else { - LOG_DEBUG("Found %lu database tiles with oid %u", result_tuples.size(), + LOG_TRACE("Found %lu database tiles with oid %u", result_tuples.size(), database_oid); } diff --git a/src/catalog/settings_catalog.cpp b/src/catalog/settings_catalog.cpp index 0f412c17db2..afb18acd23a 100644 --- a/src/catalog/settings_catalog.cpp +++ b/src/catalog/settings_catalog.cpp @@ -113,8 +113,8 @@ bool SettingsCatalog::DeleteSetting(const std::string &name, auto *name_expr = new expression::TupleValueExpression(type::TypeId::INTEGER, 0, - ColumnId::NAME); - name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::NAME); + static_cast(ColumnId::NAME)); + name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), static_cast(ColumnId::NAME)); expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( @@ -132,12 +132,12 @@ std::string SettingsCatalog::GetSettingValue( auto *name_expr = new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, - ColumnId::NAME); + static_cast(ColumnId::NAME)); name_expr->SetBoundOid( catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), - ColumnId::NAME); + static_cast(ColumnId::NAME)); expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( @@ -152,7 +152,7 @@ std::string SettingsCatalog::GetSettingValue( std::string config_value = ""; PELOTON_ASSERT(result_tuples.size() <= 1); if (result_tuples.size() != 0) { - config_value = (result_tuples[0]).GetValue(ColumnId::VALUE).ToString(); + config_value = (result_tuples[0]).GetValue(static_cast(ColumnId::VALUE)).ToString(); } return config_value; } @@ -164,12 +164,12 @@ std::string SettingsCatalog::GetDefaultValue( auto *name_expr = new expression::TupleValueExpression( type::TypeId::VARCHAR, 0, - ColumnId::NAME); + static_cast(ColumnId::NAME)); name_expr->SetBoundOid( catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), - ColumnId::NAME); + static_cast(ColumnId::NAME)); expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( @@ -184,7 +184,7 @@ std::string SettingsCatalog::GetDefaultValue( std::string config_value = ""; PELOTON_ASSERT(result_tuples.size() <= 1); if (result_tuples.size() != 0) { - config_value = result_tuples[0].GetValue(ColumnId::DEFAULT_VALUE).ToString(); + config_value = result_tuples[0].GetValue(static_cast(ColumnId::DEFAULT_VALUE)).ToString(); } return config_value; } diff --git a/src/catalog/zone_map_catalog.cpp b/src/catalog/zone_map_catalog.cpp index 1e839841e81..4f50a67b1d0 100644 --- a/src/catalog/zone_map_catalog.cpp +++ b/src/catalog/zone_map_catalog.cpp @@ -97,9 +97,6 @@ bool ZoneMapCatalog::DeleteColumnStatistics( 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(all_column_ids); diff --git a/src/include/catalog/settings_catalog.h b/src/include/catalog/settings_catalog.h index 236a48a7faa..62cd8b8c063 100644 --- a/src/include/catalog/settings_catalog.h +++ b/src/include/catalog/settings_catalog.h @@ -47,7 +47,7 @@ class SettingsCatalog : public AbstractCatalog { std::string GetDefaultValue(const std::string &name, concurrency::TransactionContext *txn); - enum ColumnId { + enum class ColumnId { NAME = 0, VALUE = 1, VALUE_TYPE = 2, diff --git a/test/codegen/zone_map_scan_test.cpp b/test/codegen/zone_map_scan_test.cpp index 81a93e6002d..1285e5e86b3 100644 --- a/test/codegen/zone_map_scan_test.cpp +++ b/test/codegen/zone_map_scan_test.cpp @@ -67,19 +67,19 @@ class ZoneMapScanTest : public PelotonCodeGenTest { uint32_t num_rows_to_insert = 100; }; -//TEST_F(ZoneMapScanTest, ScanNoPredicates) { -// // SELECT a, b, c FROM table; -// // 1) Setup the scan plan node -// planner::SeqScanPlan scan{&GetTestTable(TestTableId()), nullptr, {0, 1, 2}}; -// // 2) Do binding -// planner::BindingContext context; -// scan.PerformBinding(context); -// codegen::BufferingConsumer buffer{{0, 1, 2}, context}; -// // COMPILE and execute -// CompileAndExecute(scan, buffer); -// const auto &results = buffer.GetOutputTuples(); -// EXPECT_EQ(NumRowsInTestTable(), results.size()); -//} +TEST_F(ZoneMapScanTest, ScanNoPredicates) { + // SELECT a, b, c FROM table; + // 1) Setup the scan plan node + planner::SeqScanPlan scan{&GetTestTable(TestTableId()), nullptr, {0, 1, 2}}; + // 2) Do binding + planner::BindingContext context; + scan.PerformBinding(context); + codegen::BufferingConsumer buffer{{0, 1, 2}, context}; + // COMPILE and execute + CompileAndExecute(scan, buffer); + const auto &results = buffer.GetOutputTuples(); + EXPECT_EQ(NumRowsInTestTable(), results.size()); +} TEST_F(ZoneMapScanTest, SimplePredicate) { // SELECT a, b, c FROM table where a >= 20; diff --git a/test/optimizer/old_optimizer_test.cpp b/test/optimizer/old_optimizer_test.cpp index 09341562f0f..48eb37178dc 100644 --- a/test/optimizer/old_optimizer_test.cpp +++ b/test/optimizer/old_optimizer_test.cpp @@ -171,11 +171,7 @@ TEST_F(OldOptimizerTests, UpdateDelWithIndexScanTest) { auto target_table_ = catalog::Catalog::GetInstance()->GetTableWithName( DEFAULT_DB_NAME, "department_table", txn); // Expected 1 , Primary key index + created index - auto table_obj = catalog::Catalog::GetInstance()->GetTableObject( - DEFAULT_DB_NAME, "department_table", txn); - LOG_WARN("Index count: %lu", table_obj->GetIndexObjects().size()); - auto index_obj = catalog::IndexCatalog::GetInstance()->GetIndexObject(50331753, txn); - LOG_WARN("index: %u", index_obj->GetIndexOid()); + EXPECT_EQ(target_table_->GetIndexCount(), 2); txn_manager.CommitTransaction(txn); @@ -232,12 +228,10 @@ TEST_F(OldOptimizerTests, UpdateDelWithIndexScanTest) { txn_manager.CommitTransaction(txn); EXPECT_EQ(del_scan_plan_seq->GetPlanNodeType(), PlanNodeType::SEQSCAN); - LOG_WARN("here3"); // free the database just created txn = txn_manager.BeginTransaction(); catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn); txn_manager.CommitTransaction(txn); - LOG_WARN("here4"); } } // namespace test From 057256721ea5ef880bc5f9f81977438c6fe0f286 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 20:13:14 -0400 Subject: [PATCH 75/85] trigger catalog bound --- src/catalog/trigger_catalog.cpp | 39 +++++++++++++++++++++++---------- 1 file changed, 28 insertions(+), 11 deletions(-) diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index ce721014515..ee838c762f8 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -147,19 +147,25 @@ oid_t TriggerCatalog::GetTriggerOid(std::string trigger_name, oid_t table_oid, concurrency::TransactionContext *txn) { std::vector column_ids({ColumnId::TRIGGER_OID}); - expression::AbstractExpression *name_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + auto *name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, ColumnId::TRIGGER_NAME); + name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::TRIGGER_NAME); + expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetVarcharValue(trigger_name, nullptr).Copy()); + expression::AbstractExpression *name_equality_expr = expression::ExpressionUtil::ComparisonFactory( ExpressionType::COMPARE_EQUAL, name_expr, name_const_expr); + auto *oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::TABLE_OID); - expression::AbstractExpression *oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, - ColumnId::TABLE_OID); expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(table_oid).Copy()); @@ -214,6 +220,7 @@ bool TriggerCatalog::DeleteTriggerByName(const std::string &trigger_name, table_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TABLE_OID); + expression::AbstractExpression *table_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(table_oid).Copy()); @@ -235,9 +242,12 @@ std::unique_ptr TriggerCatalog::GetTriggersByType( // select trigger_name, fire condition, function_name, function_args std::vector column_ids(all_column_ids); - expression::AbstractExpression *type_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::SMALLINT, 0, + auto *type_expr = + new expression::TupleValueExpression(type::TypeId::SMALLINT, 0, ColumnId::TRIGGER_TYPE); + type_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::TRIGGER_TYPE); + expression::AbstractExpression *type_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetSmallIntValue(trigger_type).Copy()); @@ -245,9 +255,12 @@ std::unique_ptr TriggerCatalog::GetTriggersByType( expression::ExpressionUtil::ComparisonFactory( ExpressionType::COMPARE_EQUAL, type_expr, type_const_expr); - expression::AbstractExpression *oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + auto *oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); + oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::TABLE_OID); + expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(table_oid).Copy()); @@ -288,9 +301,13 @@ std::unique_ptr TriggerCatalog::GetTriggers( LOG_DEBUG("Get triggers for table %d", table_oid); // select trigger_name, fire condition, function_name, function_args std::vector column_ids(all_column_ids); - expression::AbstractExpression *oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + + auto *oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, ColumnId::TABLE_OID); + oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::TABLE_OID); + expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(table_oid).Copy()); From 540f8d587919893e76cc54e68b00f2b1b40f8a2c Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 20:15:48 -0400 Subject: [PATCH 76/85] table catalog bound --- src/catalog/table_catalog.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 47e6ca68877..7b497e26360 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -593,9 +593,12 @@ TableCatalog::GetTableObjects(oid_t database_oid, // cache miss, get from pg_table std::vector column_ids(all_column_ids); - expression::AbstractExpression *db_oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, - ColumnId::DATABASE_OID); + auto *db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(database_oid).Copy()); From 888b8c4b670e436b83daa7e37658bdf9aa11b7b8 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 28 Apr 2018 20:16:57 -0400 Subject: [PATCH 77/85] clean up --- src/catalog/column_catalog.cpp | 40 +++++++++++++++++++----- src/catalog/database_catalog.cpp | 2 +- src/catalog/database_metrics_catalog.cpp | 7 +++-- 3 files changed, 39 insertions(+), 10 deletions(-) diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index 20c8cc27d1e..d73ef0b699f 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -226,19 +226,45 @@ bool ColumnCatalog::InsertColumn(oid_t table_oid, bool ColumnCatalog::DeleteColumn(oid_t table_oid, const std::string &column_name, concurrency::TransactionContext *txn) { - oid_t index_offset = - IndexId::PRIMARY_KEY; // Index of table_oid & column_name - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); - values.push_back( - type::ValueFactory::GetVarcharValue(column_name, nullptr).Copy()); + std::vector column_ids(all_column_ids); + + auto *table_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + table_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TABLE_OID); + + expression::AbstractExpression *table_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *table_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, table_oid_expr, table_oid_const_expr); + + auto *col_name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, + ColumnId::COLUMN_NAME); + col_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::COLUMN_NAME); + expression::AbstractExpression *col_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(column_name, nullptr).Copy()); + expression::AbstractExpression *col_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, col_name_expr, + col_name_const_expr); + + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, table_oid_equality_expr, + col_name_equality_expr); // delete column from cache auto table_object = TableCatalog::GetInstance()->GetTableObject(table_oid, txn); table_object->EvictColumnObject(column_name); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); } /* @brief delete all column records from the same table diff --git a/src/catalog/database_catalog.cpp b/src/catalog/database_catalog.cpp index 3e1b6838760..8bbc6cc43df 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -383,7 +383,7 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( auto *db_name_expr = new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, ColumnId::DATABASE_NAME); - db_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + db_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::DATABASE_NAME); diff --git a/src/catalog/database_metrics_catalog.cpp b/src/catalog/database_metrics_catalog.cpp index 0ce91e1968f..88ad2e15322 100644 --- a/src/catalog/database_metrics_catalog.cpp +++ b/src/catalog/database_metrics_catalog.cpp @@ -74,9 +74,12 @@ bool DatabaseMetricsCatalog::DeleteDatabaseMetrics( oid_t database_oid, concurrency::TransactionContext *txn) { std::vector column_ids(all_column_ids); - expression::AbstractExpression *db_oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, + auto *db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, ColumnId::DATABASE_OID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_OID); expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(database_oid).Copy()); From e542b5838cf94d1def4ac400841a29134616d14e Mon Sep 17 00:00:00 2001 From: Zeninma Date: Sat, 28 Apr 2018 20:17:33 -0400 Subject: [PATCH 78/85] added insert, delete and bouding for zone_map_catalog --- src/catalog/zone_map_catalog.cpp | 140 +++++++++++++++++++++++-------- 1 file changed, 106 insertions(+), 34 deletions(-) diff --git a/src/catalog/zone_map_catalog.cpp b/src/catalog/zone_map_catalog.cpp index 4f50a67b1d0..10a708d2a48 100644 --- a/src/catalog/zone_map_catalog.cpp +++ b/src/catalog/zone_map_catalog.cpp @@ -57,8 +57,9 @@ bool ZoneMapCatalog::InsertColumnStatistics( oid_t database_id, oid_t table_id, oid_t tile_group_id, oid_t column_id, std::string minimum, std::string maximum, std::string type, type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + (void) pool; + // Create the tuple first + std::vector> tuples; auto val_db_id = type::ValueFactory::GetIntegerValue(database_id); auto val_table_id = type::ValueFactory::GetIntegerValue(table_id); @@ -68,30 +69,97 @@ bool ZoneMapCatalog::InsertColumnStatistics( auto val_maximum = type::ValueFactory::GetVarcharValue(maximum); auto val_type = type::ValueFactory::GetVarcharValue(type); - 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::MINIMUM), val_minimum, pool); - tuple->SetValue(static_cast(ColumnId::MAXIMUM), val_maximum, pool); - tuple->SetValue(static_cast(ColumnId::TYPE), val_type, pool); - - bool return_val = InsertTuple(std::move(tuple), txn); - return return_val; + auto constant_db_id_expr = new expression::ConstantValueExpression( + val_db_id); + auto constant_table_id_expr = new expression::ConstantValueExpression( + val_table_id); + auto constant_tile_group_id_expr = new expression::ConstantValueExpression( + val_tile_group_id); + auto constant_column_id_expr = new expression::ConstantValueExpression( + val_column_id); + auto constant_minimum_expr = new expression::ConstantValueExpression( + val_minimum); + auto constant_maximum_expr = new expression::ConstantValueExpression( + val_maximum); + auto constant_type_expr = new expression::ConstantValueExpression( + val_type); + + tuples.push_back(std::vector()); + auto &values = tuples[0]; + + values.push_back(ExpressionPtr(constant_db_id_expr)); + values.push_back(ExpressionPtr(constant_table_id_expr)); + values.push_back(ExpressionPtr(constant_tile_group_id_expr)); + values.push_back(ExpressionPtr(constant_column_id_expr)); + values.push_back(ExpressionPtr(constant_minimum_expr)); + values.push_back(ExpressionPtr(constant_maximum_expr)); + values.push_back(ExpressionPtr(constant_type_expr)); + + return InsertTupleWithCompiledPlan(&tuples, 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)}); - return DeleteWithIndexScan(index_offset, values, txn); + std::vector column_ids(all_column_ids); + + auto db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_ID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::DATABASE_ID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_id).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); + + + auto tb_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_ID); + tb_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TABLE_ID); + expression::AbstractExpression *tb_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_id).Copy()); + expression::AbstractExpression *tb_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, tb_oid_expr, tb_oid_const_expr); + + auto tile_gid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TILE_GROUP_ID); + tile_gid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TILE_GROUP_ID); + expression::AbstractExpression *tile_gid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(tile_group_id).Copy()); + expression::AbstractExpression *tile_gid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, tile_gid_expr, tile_gid_const_expr); + + auto col_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::COLUMN_ID); + col_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::COLUMN_ID); + expression::AbstractExpression *col_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(column_id).Copy()); + expression::AbstractExpression *col_id_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, col_oid_expr, col_oid_const_expr); + + expression::AbstractExpression *db_and_tb = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_oid_equality_expr, + tb_oid_equality_expr); + expression::AbstractExpression *pred_and_tile = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_and_tb, tile_gid_equality_expr); + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, pred_and_tile, col_id_equality_expr); + + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); } std::unique_ptr> ZoneMapCatalog::GetColumnStatistics( @@ -100,9 +168,10 @@ std::unique_ptr> ZoneMapCatalog::GetColumnStatistics( std::vector column_ids(all_column_ids); - expression::AbstractExpression *db_oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, - ColumnId::DATABASE_ID); + auto db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_ID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::DATABASE_ID); expression::AbstractExpression *db_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(database_id).Copy()); @@ -110,9 +179,10 @@ std::unique_ptr> ZoneMapCatalog::GetColumnStatistics( expression::ExpressionUtil::ComparisonFactory( ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); - expression::AbstractExpression *tb_oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, - ColumnId::TABLE_ID); + auto tb_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_ID); + tb_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TABLE_ID); expression::AbstractExpression *tb_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(table_id).Copy()); @@ -120,9 +190,10 @@ std::unique_ptr> ZoneMapCatalog::GetColumnStatistics( expression::ExpressionUtil::ComparisonFactory( ExpressionType::COMPARE_EQUAL, tb_oid_expr, tb_oid_const_expr); - expression::AbstractExpression *tile_gid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, - ColumnId::TILE_GROUP_ID); + auto tile_gid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TILE_GROUP_ID); + tile_gid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TILE_GROUP_ID); expression::AbstractExpression *tile_gid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(tile_group_id).Copy()); @@ -130,10 +201,11 @@ std::unique_ptr> ZoneMapCatalog::GetColumnStatistics( expression::ExpressionUtil::ComparisonFactory( ExpressionType::COMPARE_EQUAL, tile_gid_expr, tile_gid_const_expr); - expression::AbstractExpression *col_oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, - ColumnId::COLUMN_ID); - expression::AbstractExpression *col_oid_const_expr = + auto col_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::COLUMN_ID); + col_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::COLUMN_ID); + expression::AbstractExpression *col_oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(column_id).Copy()); expression::AbstractExpression *col_id_equality_expr = From 9e8d8a9079fa72f9e1f884ac86378837f82096e4 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 20:18:09 -0400 Subject: [PATCH 79/85] language catalog bound --- src/catalog/language_catalog.cpp | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index 41b745a29c8..21d96a97f41 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -95,9 +95,12 @@ std::unique_ptr LanguageCatalog::GetLanguageByOid( oid_t lang_oid, concurrency::TransactionContext *txn) const { std::vector column_ids(all_column_ids); - expression::AbstractExpression *oid_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0, - ColumnId::OID); + auto *oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::OID); + oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::OID); + expression::AbstractExpression *oid_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetIntegerValue(lang_oid).Copy()); @@ -122,9 +125,11 @@ std::unique_ptr LanguageCatalog::GetLanguageByName( const std::string &lang_name, concurrency::TransactionContext *txn) const { std::vector column_ids(all_column_ids); - expression::AbstractExpression *name_expr = - expression::ExpressionUtil::TupleValueFactory(type::TypeId::VARCHAR, 0, + auto *name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, ColumnId::LANNAME); + name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::LANNAME); expression::AbstractExpression *name_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetVarcharValue(lang_name, nullptr).Copy()); From 5d20500d0c2ab63b94e56e8eacaab17c1144b9f6 Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 28 Apr 2018 20:19:26 -0400 Subject: [PATCH 80/85] index cache uncomment --- src/catalog/index_catalog.cpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index 19eabe93135..07ca4c13c01 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -261,10 +261,10 @@ std::shared_ptr IndexCatalog::GetIndexObject( throw CatalogException("Transaction is invalid!"); } // try get from cache - // auto index_object = txn->catalog_cache.GetCachedIndexObject(index_oid); - // if (index_object) { - // return index_object; - //} + auto index_object = txn->catalog_cache.GetCachedIndexObject(index_oid); + if (index_object) { + return index_object; + } // cache miss, get from pg_index std::vector column_ids(all_column_ids); @@ -305,10 +305,10 @@ std::shared_ptr IndexCatalog::GetIndexObject( throw CatalogException("Transaction is invalid!"); } // try get from cache - // auto index_object = txn->catalog_cache.GetCachedIndexObject(index_name); - // if (index_object) { - // return index_object; - // } + auto index_object = txn->catalog_cache.GetCachedIndexObject(index_name); + if (index_object) { + return index_object; + } // cache miss, get from pg_index std::vector column_ids(all_column_ids); @@ -354,8 +354,8 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, auto table_object = TableCatalog::GetInstance()->GetTableObject(table_oid, txn); PELOTON_ASSERT(table_object && table_object->GetTableOid() == table_oid); - // auto index_objects = table_object->GetIndexObjects(true); - // if (index_objects.empty() == false) return index_objects; + auto index_objects = table_object->GetIndexObjects(true); + if (index_objects.empty() == false) return index_objects; // cache miss, get from pg_index std::vector column_ids(all_column_ids); From 671367b5fbe3e16c1736b14560b3c5184a9a08ca Mon Sep 17 00:00:00 2001 From: Zeninma Date: Sat, 28 Apr 2018 20:20:15 -0400 Subject: [PATCH 81/85] deleted redundant comments in index_catalog --- src/catalog/index_catalog.cpp | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/src/catalog/index_catalog.cpp b/src/catalog/index_catalog.cpp index 19eabe93135..e91255fc898 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -260,13 +260,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } - // try get from cache - // auto index_object = txn->catalog_cache.GetCachedIndexObject(index_oid); - // if (index_object) { - // return index_object; - //} - // cache miss, get from pg_index std::vector column_ids(all_column_ids); auto *idx_oid_expr = @@ -304,13 +298,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } - // try get from cache - // auto index_object = txn->catalog_cache.GetCachedIndexObject(index_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 std::vector values; @@ -354,8 +342,6 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, auto table_object = TableCatalog::GetInstance()->GetTableObject(table_oid, txn); PELOTON_ASSERT(table_object && table_object->GetTableOid() == table_oid); - // auto index_objects = table_object->GetIndexObjects(true); - // if (index_objects.empty() == false) return index_objects; // cache miss, get from pg_index std::vector column_ids(all_column_ids); From 7ae1c5a19c3256f5cf40ce401539f89d7a225bfe Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 20:32:01 -0400 Subject: [PATCH 82/85] fix proc catalog --- src/catalog/proc_catalog.cpp | 41 ++++++++++++++++++++++++++++-------- 1 file changed, 32 insertions(+), 9 deletions(-) diff --git a/src/catalog/proc_catalog.cpp b/src/catalog/proc_catalog.cpp index aae73e6b7d1..38785cc184a 100644 --- a/src/catalog/proc_catalog.cpp +++ b/src/catalog/proc_catalog.cpp @@ -119,19 +119,42 @@ bool ProcCatalog::InsertProc(const std::string &proname, std::unique_ptr ProcCatalog::GetProcByOid( oid_t proc_oid, concurrency::TransactionContext *txn) const { +//std::vector column_ids(all_column_ids); +//oid_t index_offset = IndexId::PRIMARY_KEY; +//std::vector values; +//values.push_back(type::ValueFactory::GetIntegerValue(proc_oid).Copy()); +// +//auto result_tiles = +// GetResultWithIndexScan(column_ids, index_offset, values, txn); +//PELOTON_ASSERT(result_tiles->size() <= 1); +// +//std::unique_ptr ret; +//if (result_tiles->size() == 1) { +// PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); +// ret.reset(new ProcCatalogObject((*result_tiles)[0].get(), txn)); +//} std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::PRIMARY_KEY; - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(proc_oid).Copy()); - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - PELOTON_ASSERT(result_tiles->size() <= 1); + auto *oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::OID); + oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::OID); + expression::AbstractExpression *oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(proc_oid).Copy()); + expression::AbstractExpression *oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, oid_expr, oid_const_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, oid_equality_expr, txn); + + PELOTON_ASSERT(result_tuples.size() <= 1); std::unique_ptr ret; - if (result_tiles->size() == 1) { - PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - ret.reset(new ProcCatalogObject((*result_tiles)[0].get(), txn)); + if (result_tuples.size() == 1) { + ret.reset(new ProcCatalogObject(result_tuples[0], txn)); } return ret; From 2f82391d0cbfe6328ff6e4c9411ee67cb5108b65 Mon Sep 17 00:00:00 2001 From: Ruogu Du Date: Sat, 28 Apr 2018 20:32:41 -0400 Subject: [PATCH 83/85] fix proc catalog --- src/catalog/proc_catalog.cpp | 15 +-------------- 1 file changed, 1 insertion(+), 14 deletions(-) diff --git a/src/catalog/proc_catalog.cpp b/src/catalog/proc_catalog.cpp index 38785cc184a..50b5cd31d36 100644 --- a/src/catalog/proc_catalog.cpp +++ b/src/catalog/proc_catalog.cpp @@ -119,20 +119,7 @@ bool ProcCatalog::InsertProc(const std::string &proname, std::unique_ptr ProcCatalog::GetProcByOid( oid_t proc_oid, concurrency::TransactionContext *txn) const { -//std::vector column_ids(all_column_ids); -//oid_t index_offset = IndexId::PRIMARY_KEY; -//std::vector values; -//values.push_back(type::ValueFactory::GetIntegerValue(proc_oid).Copy()); -// -//auto result_tiles = -// GetResultWithIndexScan(column_ids, index_offset, values, txn); -//PELOTON_ASSERT(result_tiles->size() <= 1); -// -//std::unique_ptr ret; -//if (result_tiles->size() == 1) { -// PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); -// ret.reset(new ProcCatalogObject((*result_tiles)[0].get(), txn)); -//} + std::vector column_ids(all_column_ids); auto *oid_expr = From ee68c8d599e4ffc5aa5b7719ca094ebaa1d2dcdb Mon Sep 17 00:00:00 2001 From: Zeninma Date: Sat, 28 Apr 2018 20:52:04 -0400 Subject: [PATCH 84/85] added bind in language_catalog's delete --- src/catalog/language_catalog.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index 21d96a97f41..5b2ef0e2c0b 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -80,7 +80,9 @@ bool LanguageCatalog::DeleteLanguage(const std::string &lanname, auto *lan_name_expr = new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, ColumnId::LANNAME); - expression::AbstractExpression *lan_name_const_expr = + lan_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::LANNAME); + + expression::AbstractExpression *lan_name_const_expr = expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetVarcharValue(lanname, nullptr).Copy()); expression::AbstractExpression *lan_name_equality_expr = From 7dadd745971c8b64862fc1b9e120fe3cdf8580ff Mon Sep 17 00:00:00 2001 From: TianxiongWang Date: Sat, 28 Apr 2018 21:00:50 -0400 Subject: [PATCH 85/85] add comment to zone map manager --- src/storage/zone_map_manager.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/storage/zone_map_manager.cpp b/src/storage/zone_map_manager.cpp index 2e13913bcbc..2fbd7605419 100644 --- a/src/storage/zone_map_manager.cpp +++ b/src/storage/zone_map_manager.cpp @@ -199,9 +199,10 @@ ZoneMapManager::GetResultVectorAsZoneMap( bool ZoneMapManager::ShouldScanTileGroup( storage::PredicateInfo *parsed_predicates, int32_t num_predicates, storage::DataTable *table, int64_t tile_group_idx) { - if (table->GetName() == ZONE_MAP_CATALOG_NAME) { - return true; - } + // always scan the zone_map catalog to avoid chicken and egg problem + if (table->GetName() == ZONE_MAP_CATALOG_NAME) { + return true; + } for (int32_t i = 0; i < num_predicates; i++) { // Extract the col_id, operator and predicate_value int col_id = parsed_predicates[i].col_id;