diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 98879a0d36c..149a4db4c00 100644 --- a/src/catalog/abstract_catalog.cpp +++ b/src/catalog/abstract_catalog.cpp @@ -11,7 +11,9 @@ //===----------------------------------------------------------------------===// #include "catalog/abstract_catalog.h" - +#include "executor/plan_executor.h" +#include "codegen/buffering_consumer.h" +#include "common/internal_types.h" #include "common/statement.h" #include "catalog/catalog.h" @@ -103,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 @@ -152,6 +206,63 @@ 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); + + // 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 @@ -235,6 +346,56 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, 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) const { + 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; + + codegen::QueryParameters parameters(*plan_ptr, {}); + std::unique_ptr executor_context( + new executor::ExecutorContext(txn, std::move(parameters))); + + // search for query + codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr); + std::unique_ptr compiled_query(nullptr); + cached = (query != nullptr); + + // 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->Execute(std::move(executor_context), buffer, + [](executor::ExecutionResult result) { return result; }); + + return buffer.GetOutputTuples(); +} + /*@brief Add index on catalog table * @param key_attrs indexed column offset(position) * @param index_oid index id(global unique) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 3ed19e68dc1..8e3f066c425 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); } @@ -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_TRACE("Dropping table %d from database %d", database_oid, table_oid); auto storage_manager = storage::StorageManager::GetInstance(); auto database = storage_manager->GetDatabaseWithOid(database_oid); auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); auto table_object = database_object->GetTableObject(table_oid); auto index_objects = table_object->GetIndexObjects(); - LOG_TRACE("dropping #%d indexes", (int)index_objects.size()); for (auto it : index_objects) DropIndex(it.second->GetIndexOid(), txn); ColumnCatalog::GetInstance()->DeleteColumns(table_oid, txn); @@ -614,18 +612,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 +1062,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 +1103,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 d5cbc3c2c10..d73ef0b699f 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -11,11 +11,13 @@ //===----------------------------------------------------------------------===// #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" namespace peloton { namespace catalog { @@ -41,9 +43,29 @@ ColumnCatalogObject::ColumnCatalogObject(executor::LogicalTile *tile, is_not_null(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_NOT_NULL) .GetAs()) {} -ColumnCatalog *ColumnCatalog::GetInstance(storage::Database *pg_catalog, - type::AbstractPool *pool, - concurrency::TransactionContext *txn) { +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) { static ColumnCatalog column_catalog{pg_catalog, pool, txn}; return &column_catalog; } @@ -146,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); @@ -169,35 +191,80 @@ 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, 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 @@ -208,16 +275,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> @@ -232,19 +313,27 @@ 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()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - - 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); - } + + 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()); + 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); + 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 b44c64a1a7f..64b12856a0a 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 { @@ -61,8 +63,8 @@ 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; auto val_db_id = type::ValueFactory::GetIntegerValue(database_id); auto val_table_id = type::ValueFactory::GetIntegerValue(table_id); @@ -94,74 +96,156 @@ 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))); // Insert the tuple into catalog table - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, 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; - 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); +bool ColumnStatsCatalog::DeleteColumnStats( + oid_t database_id, oid_t table_id, oid_t column_id, + concurrency::TransactionContext *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 *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); + + + + 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}); - 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); - - PELOTON_ASSERT(result_tiles->size() <= 1); // unique - if (result_tiles->size() == 0) { - return nullptr; - } - auto tile = (*result_tiles)[0].get(); - PELOTON_ASSERT(tile->GetTupleCount() <= 1); - if (tile->GetTupleCount() == 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()); + 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 result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); + + PELOTON_ASSERT(result_tuples.size() <= 1); // unique + if (result_tuples.size() == 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(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, @@ -174,28 +258,46 @@ 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::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::map>> & + column_stats_map) { + 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; @@ -203,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_catalog.cpp b/src/catalog/database_catalog.cpp index 8786743973a..8bbc6cc43df 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -17,6 +17,8 @@ #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" @@ -25,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) @@ -36,6 +38,19 @@ 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 @@ -49,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; } @@ -196,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; } @@ -253,29 +268,53 @@ 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)); + (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); - // Insert the tuple - return InsertTuple(std::move(tuple), txn); + tuples.push_back(std::vector()); + auto &values = tuples[0]; + values.push_back(ExpressionPtr(constant_expr_0)); + values.push_back(ExpressionPtr(constant_expr_1)); + + return InsertTupleWithCompiledPlan(&tuples, txn); } 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( @@ -289,23 +328,35 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( // 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); + 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); - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { + 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; + auto result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); + + if (result_tuples.size() == 1) { auto database_object = - std::make_shared((*result_tiles)[0].get(), txn); + std::make_shared(result_tuples[0], txn); // insert into cache bool success = txn->catalog_cache.InsertDatabaseObject(database_object); PELOTON_ASSERT(success == true); (void)success; return database_object; } else { - LOG_DEBUG("Found %lu database tiles with oid %u", result_tiles->size(), + LOG_TRACE("Found %lu database tiles with oid %u", result_tuples.size(), database_oid); } @@ -328,23 +379,31 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( // 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); + 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 = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_name_expr, db_name_const_expr); - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, db_name_equality_expr, txn); + + if (result_tuples.size() == 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); - PELOTON_ASSERT(success == true); - (void)success; - } + std::make_shared(result_tuples[0], txn); + // insert into cache + bool success = txn->catalog_cache.InsertDatabaseObject(database_object); + PELOTON_ASSERT(success == true); + (void)success; return database_object; } diff --git a/src/catalog/database_metrics_catalog.cpp b/src/catalog/database_metrics_catalog.cpp index ff670639764..88ad2e15322 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 { @@ -25,7 +27,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,32 +44,49 @@ 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) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + oid_t time_stamp, type::AbstractPool *pool, + concurrency::TransactionContext *txn) { + (void) pool; + std::vector> tuples; + tuples.push_back(std::vector()); + auto &values = tuples[0]; 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))); + // Insert the tuple into catalog table - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool DatabaseMetricsCatalog::DeleteDatabaseMetrics( oid_t database_oid, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index - - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); + std::vector column_ids(all_column_ids); - return DeleteWithIndexScan(index_offset, values, txn); + 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 *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/index_catalog.cpp b/src/catalog/index_catalog.cpp index 6c32be70a3e..500f1b2eff0 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -17,6 +17,8 @@ #include "concurrency/transaction_context.h" #include "catalog/table_catalog.h" #include "catalog/column_catalog.h" +#include "codegen/buffering_consumer.h" +#include "expression/expression_util.h" #include "executor/logical_tile.h" #include "storage/data_table.h" #include "storage/tuple.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) { @@ -147,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); @@ -163,31 +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 +bool IndexCatalog::DeleteIndex(oid_t index_oid, + concurrency::TransactionContext *txn) { + 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( @@ -196,31 +261,37 @@ 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) { + 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); - 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()); + 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()); + 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); 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_tiles->size(), index_oid); + LOG_DEBUG("Found %lu index with oid %u", result_tuples.size(), index_oid); } // return empty object if not found @@ -233,12 +304,11 @@ 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; @@ -273,7 +343,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!"); } @@ -281,24 +352,30 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, concurrency::TransactionContext * 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); - 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); + 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); - 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); - } + 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/catalog/index_metrics_catalog.cpp b/src/catalog/index_metrics_catalog.cpp index 3ca114e8c98..ec6d5fa8ec7 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,26 +60,59 @@ 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( + 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 IndexMetricsCatalog::DeleteIndexMetrics(oid_t index_oid, - concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index +bool IndexMetricsCatalog::DeleteIndexMetrics( + oid_t index_oid, concurrency::TransactionContext *txn) { + + // 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; - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(index_oid).Copy()); + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); - return DeleteWithIndexScan(index_offset, values, txn); } } // namespace catalog diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index ba6e0c360f4..5b2ef0e2c0b 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -13,6 +13,8 @@ #include "catalog/language_catalog.h" #include "catalog/catalog.h" +#include "codegen/buffering_consumer.h" +#include "expression/expression_util.h" #include "executor/logical_tile.h" #include "storage/data_table.h" #include "type/value_factory.h" @@ -24,7 +26,12 @@ LanguageCatalogObject::LanguageCatalogObject(executor::LogicalTile *tuple) : lang_oid_(tuple->GetValue(0, 0).GetAs()), lang_name_(tuple->GetValue(0, 1).GetAs()) {} -LanguageCatalog &LanguageCatalog::GetInstance(concurrency::TransactionContext *txn) { +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; } @@ -47,47 +54,70 @@ 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 InsertTupleWithCompiledPlan(&tuples, txn); } // 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 values; - values.push_back( - type::ValueFactory::GetVarcharValue(lanname, nullptr).Copy()); + std::vector column_ids(all_column_ids); - return DeleteWithIndexScan(index_offset, values, txn); + auto *lan_name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, + ColumnId::LANNAME); + 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 = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, lan_name_expr, + lan_name_const_expr); + + return DeleteWithCompiledSeqScan(column_ids, lan_name_equality_expr, txn); } 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); - 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(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); + + 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 LanguageCatalogObject((*result_tiles)[0].get())); + if (result_tuples.size() == 1) { + ret.reset(new LanguageCatalogObject(result_tuples[0])); } return ret; @@ -96,18 +126,27 @@ 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); - PELOTON_ASSERT(result_tiles->size() <= 1); + 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()); + 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); + + 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 LanguageCatalogObject((*result_tiles)[0].get())); + if (result_tuples.size() == 1) { + ret.reset(new LanguageCatalogObject(result_tuples[0])); } return ret; diff --git a/src/catalog/proc_catalog.cpp b/src/catalog/proc_catalog.cpp index 217c8b7fedb..50b5cd31d36 100644 --- a/src/catalog/proc_catalog.cpp +++ b/src/catalog/proc_catalog.cpp @@ -14,9 +14,11 @@ #include "catalog/catalog.h" #include "catalog/language_catalog.h" +#include "codegen/buffering_consumer.h" #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_); } @@ -66,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); @@ -78,32 +92,56 @@ 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( 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); + 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; @@ -114,20 +152,46 @@ 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); - PELOTON_ASSERT(result_tiles->size() <= 1); + 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()); + expression::AbstractExpression *proc_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, proc_name_expr, proc_name_const_expr); + + 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( + 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); + + 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; 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 diff --git a/src/catalog/query_metrics_catalog.cpp b/src/catalog/query_metrics_catalog.cpp index 0f3f98320df..37ee289fc35 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" @@ -60,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); @@ -88,84 +92,181 @@ 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 InsertTupleWithCompiledPlan(&tuples, txn); } -bool QueryMetricsCatalog::DeleteQueryMetrics(const std::string &name, - oid_t database_oid, - concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::SECONDARY_KEY_0; // Secondary key index +bool QueryMetricsCatalog::DeleteQueryMetrics( + const std::string &name, oid_t database_oid, + concurrency::TransactionContext *txn) { + std::vector column_ids(all_column_ids); - std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); + 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); - return DeleteWithIndexScan(index_offset, values, txn); + 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); + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); } 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; } -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()); +int64_t QueryMetricsCatalog::GetNumParams( + const std::string &name, oid_t database_oid, + concurrency::TransactionContext *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); - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + 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/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 508dea6d278..afb18acd23a 100644 --- a/src/catalog/settings_catalog.cpp +++ b/src/catalog/settings_catalog.cpp @@ -10,6 +10,8 @@ // //===----------------------------------------------------------------------===// +#include "expression/expression_util.h" +#include "codegen/buffering_consumer.h" #include "catalog/settings_catalog.h" #include "catalog/catalog.h" #include "executor/logical_tile.h" @@ -21,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; } @@ -54,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); @@ -69,67 +72,119 @@ 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); + + auto *name_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + 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( + type::ValueFactory::GetVarcharValue(name).Copy()); + expression::AbstractExpression *name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, name_expr, name_const_expr); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithCompiledSeqScan(column_ids, name_equality_expr, txn); } -std::string SettingsCatalog::GetSettingValue(const std::string &name, - concurrency::TransactionContext *txn) { - std::vector column_ids({static_cast(ColumnId::VALUE)}); - oid_t index_offset = static_cast(IndexId::SECONDARY_KEY_0); - std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); +std::string SettingsCatalog::GetSettingValue( + const std::string &name, concurrency::TransactionContext *txn) { + std::vector column_ids(all_column_ids); + + auto *name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, + static_cast(ColumnId::NAME)); + + name_expr->SetBoundOid( + catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + static_cast(ColumnId::NAME)); - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + 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 = ""; - PELOTON_ASSERT(result_tiles->size() <= 1); - if (result_tiles->size() != 0) { - PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - if ((*result_tiles)[0]->GetTupleCount() != 0) { - config_value = (*result_tiles)[0]->GetValue(0, 0).ToString(); - } + PELOTON_ASSERT(result_tuples.size() <= 1); + if (result_tuples.size() != 0) { + config_value = (result_tuples[0]).GetValue(static_cast(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)}); - oid_t index_offset = static_cast(IndexId::SECONDARY_KEY_0); - std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); +std::string SettingsCatalog::GetDefaultValue( + const std::string &name, concurrency::TransactionContext *txn) { + std::vector column_ids(all_column_ids); + + auto *name_expr = + new expression::TupleValueExpression( + type::TypeId::VARCHAR, 0, + 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( + type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); + expression::AbstractExpression *name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, name_expr, name_const_expr); - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, name_equality_expr, txn); std::string config_value = ""; - PELOTON_ASSERT(result_tiles->size() <= 1); - if (result_tiles->size() != 0) { - PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - if ((*result_tiles)[0]->GetTupleCount() != 0) { - config_value = (*result_tiles)[0]->GetValue(0, 0).ToString(); - } + PELOTON_ASSERT(result_tuples.size() <= 1); + if (result_tuples.size() != 0) { + config_value = result_tuples[0].GetValue(static_cast(ColumnId::DEFAULT_VALUE)).ToString(); } return config_value; } diff --git a/src/catalog/table_catalog.cpp b/src/catalog/table_catalog.cpp index 0a83607e439..7b497e26360 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -19,8 +19,13 @@ #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" +#include "expression/abstract_expression.h" +#include "expression/expression_util.h" + namespace peloton { namespace catalog { @@ -41,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 @@ -357,20 +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; // 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(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)); - // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } /*@brief delete a tuple about table info from pg_table(using index scan) @@ -378,20 +408,37 @@ 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) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Index of table_oid - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); +bool TableCatalog::DeleteTable(oid_t table_oid, + concurrency::TransactionContext *txn) { + + 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); - // 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 DeleteWithIndexScan(index_offset, values, txn); + 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; } /*@brief read table catalog object from pg_table using table oid @@ -410,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); - - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { + 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_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); @@ -427,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 @@ -458,19 +515,47 @@ 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()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { + 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()); + expression::AbstractExpression *table_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, table_name_expr, + table_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, table_name_equality_expr, + db_oid_equality_expr); + + // 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()); + 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); @@ -478,6 +563,7 @@ std::shared_ptr TableCatalog::GetTableObject( bool success = database_object->InsertTableObject(table_object); PELOTON_ASSERT(success == true); (void)success; + return table_object; } @@ -506,19 +592,27 @@ 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()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, 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); - } + + 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; + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); + + for (auto tuple : result_tuples) { + 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..428f92d0fb1 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,26 +60,57 @@ 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(oid_t table_oid, - concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index +bool TableMetricsCatalog::DeleteTableMetrics( + oid_t table_oid, concurrency::TransactionContext *txn) { + + 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(table_oid).Copy()); + expression::AbstractExpression *oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, oid_expr, oid_const_expr); - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *predicate = oid_equality_expr; - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); } } // namespace catalog diff --git a/src/catalog/trigger_catalog.cpp b/src/catalog/trigger_catalog.cpp index e04fbe3d906..ee838c762f8 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -15,13 +15,16 @@ #include "catalog/catalog.h" #include "catalog/database_catalog.h" #include "catalog/table_catalog.h" +#include "expression/expression_util.h" +#include "codegen/buffering_consumer.h" #include "storage/data_table.h" #include "type/value_factory.h" namespace peloton { namespace catalog { -TriggerCatalog &TriggerCatalog::GetInstance(concurrency::TransactionContext *txn) { +TriggerCatalog &TriggerCatalog::GetInstance( + concurrency::TransactionContext *txn) { static TriggerCatalog trigger_catalog{txn}; return trigger_catalog; } @@ -58,37 +61,48 @@ 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, 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); - 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; 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_OID, 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 InsertTupleWithCompiledPlan(&tuples, txn); } ResultType TriggerCatalog::DropTrigger(const std::string &database_name, @@ -132,77 +146,153 @@ 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); + 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_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_tiles->size() == 0) { + 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_tiles->size()); - PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - if ((*result_tiles)[0]->GetTupleCount() != 0) { - trigger_oid = (*result_tiles)[0]->GetValue(0, 0).GetAs(); + LOG_INFO("size of the result tiles = %lu", result_tuples.size()); + PELOTON_ASSERT(result_tuples.size() <= 1); + if (result_tuples.size() != 0) { + trigger_oid = result_tuples[0].GetValue(0).GetAs(); } } + return trigger_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); - return DeleteWithIndexScan(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); + + 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( - 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}); - 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()); - } + std::vector column_ids(all_column_ids); + + 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()); + expression::AbstractExpression *type_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, type_expr, type_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_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 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()}; - 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); - } - } + + for (unsigned int i = 0; i < result_tuples.size(); i++) { + // create a new trigger instance + trigger::Trigger new_trigger(result_tuples[i].GetValue(ColumnId::TRIGGER_NAME).ToString(), + trigger_type, + 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); } + return new_trigger_list; } @@ -210,42 +300,39 @@ 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); + std::vector column_ids(all_column_ids); + + 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()); + 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! - 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()); - } + LOG_INFO("size of the result tiles = %lu", result_tuples.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); - } - } + + for (unsigned int i = 0; i < result_tuples.size(); i++) { + // create a new trigger instance + 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); } return new_trigger_list; diff --git a/src/catalog/zone_map_catalog.cpp b/src/catalog/zone_map_catalog.cpp index c4535268c3d..10a708d2a48 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" @@ -19,6 +18,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 { @@ -27,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; } @@ -55,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); @@ -66,68 +69,172 @@ 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); +bool ZoneMapCatalog::DeleteColumnStatistics( + oid_t database_id, oid_t table_id, oid_t tile_group_id, oid_t column_id, + concurrency::TransactionContext *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( 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)}); - - 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); - - PELOTON_ASSERT(result_tiles->size() <= 1); // unique - if (result_tiles->size() == 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()); + 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); + + auto result_tuples = GetResultWithCompiledSeqScan(column_ids, predicate, txn); + + PELOTON_ASSERT(result_tuples.size() <= 1); // unique + if (result_tuples.size() == 0) { LOG_DEBUG("Result Tiles = 0"); return nullptr; } - - auto tile = (*result_tiles)[0].get(); - PELOTON_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(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/codegen/expression/comparison_translator.cpp b/src/codegen/expression/comparison_translator.cpp index 92d996996c1..230a46e32e7 100644 --- a/src/codegen/expression/comparison_translator.cpp +++ b/src/codegen/expression/comparison_translator.cpp @@ -34,6 +34,7 @@ codegen::Value ComparisonTranslator::DeriveValue(CodeGen &codegen, codegen::Value left = row.DeriveValue(codegen, *comparison.GetChild(0)); codegen::Value right = row.DeriveValue(codegen, *comparison.GetChild(1)); + switch (comparison.GetExpressionType()) { case ExpressionType::COMPARE_EQUAL: return left.CompareEq(codegen, right); diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index 9acf67773b9..a3f5197476e 100644 --- a/src/include/catalog/abstract_catalog.h +++ b/src/include/catalog/abstract_catalog.h @@ -16,6 +16,8 @@ #include "catalog/catalog_defaults.h" #include "catalog/schema.h" +#include "codegen/query_cache.h" +#include "codegen/query.h" namespace peloton { @@ -31,6 +33,10 @@ namespace expression { class AbstractExpression; } +namespace codegen { +class WrappedTuple; +} + namespace storage { class Database; class DataTable; @@ -39,6 +45,8 @@ class Tuple; namespace catalog { +using ExpressionPtr = std::unique_ptr; + class AbstractCatalog { public: virtual ~AbstractCatalog() {} @@ -59,9 +67,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, @@ -72,6 +89,11 @@ class AbstractCatalog { expression::AbstractExpression *predicate, 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); 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 56d8bf5c6b7..3daa9fbe6ab 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); inline oid_t GetTableOid() { return table_oid; } inline const std::string &GetColumnName() { return column_name; } @@ -70,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(); @@ -86,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/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/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 2c432ed191b..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; @@ -44,6 +43,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, @@ -98,9 +99,10 @@ class DatabaseCatalog : public AbstractCatalog { ~DatabaseCatalog(); // Global Singleton, only the first call requires passing parameters. - static DatabaseCatalog *GetInstance(storage::Database *pg_catalog = nullptr, - type::AbstractPool *pool = nullptr, - concurrency::TransactionContext *txn = nullptr); + static DatabaseCatalog *GetInstance( + storage::Database *pg_catalog = nullptr, + type::AbstractPool *pool = nullptr, + concurrency::TransactionContext *txn = nullptr); inline oid_t GetNextOid() { return oid_++ | DATABASE_OID_MASK; } @@ -108,7 +110,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..1bd2246924c 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 @@ -67,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 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_catalog.h b/src/include/catalog/index_catalog.h index 3e49cf68e91..e1b6e453ba9 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; } @@ -92,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/src/include/catalog/index_metrics_catalog.h b/src/include/catalog/index_metrics_catalog.h index ca64280457b..0e654bd245b 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 @@ -73,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 diff --git a/src/include/catalog/language_catalog.h b/src/include/catalog/language_catalog.h index 139f51eda21..ce5f5b49197 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_; } @@ -54,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 0445daecc9d..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(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/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/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 a3c8b1bf6df..62cd8b8c063 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 @@ -58,6 +60,8 @@ class SettingsCatalog : public AbstractCatalog { // 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); diff --git a/src/include/catalog/table_catalog.h b/src/include/catalog/table_catalog.h index 3ef4668d5ca..c50cda51ce3 100644 --- a/src/include/catalog/table_catalog.h +++ b/src/include/catalog/table_catalog.h @@ -45,8 +45,10 @@ class TableCatalogObject { friend class ColumnCatalog; public: - TableCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn, - int tupleId = 0); + TableCatalogObject(executor::LogicalTile *tile, + concurrency::TransactionContext *txn, int tupleId = 0); + TableCatalogObject(codegen::WrappedTuple wrapped_tuple, + concurrency::TransactionContext *txn); public: // Get indexes @@ -119,9 +121,10 @@ class TableCatalog : public AbstractCatalog { ~TableCatalog(); // Global Singleton, only the first call requires passing parameters. - static TableCatalog *GetInstance(storage::Database *pg_catalog = nullptr, - type::AbstractPool *pool = nullptr, - concurrency::TransactionContext *txn = nullptr); + static TableCatalog *GetInstance( + storage::Database *pg_catalog = nullptr, + type::AbstractPool *pool = nullptr, + concurrency::TransactionContext *txn = nullptr); inline oid_t GetNextOid() { return oid_++ | TABLE_OID_MASK; } diff --git a/src/include/catalog/table_metrics_catalog.h b/src/include/catalog/table_metrics_catalog.h index 9f23a15cf17..2be217f8057 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 @@ -73,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 diff --git a/src/include/catalog/trigger_catalog.h b/src/include/catalog/trigger_catalog.h index 14c9acbf888..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 @@ -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 @@ -89,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, @@ -101,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, diff --git a/src/include/catalog/zone_map_catalog.h b/src/include/catalog/zone_map_catalog.h index a38d26d0597..d275ac01045 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 @@ -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,11 +64,9 @@ class ZoneMapCatalog : public AbstractCatalog { TYPE = 6 }; - enum class ZoneMapOffset { - MINIMUM_OFF = 0, - MAXIMUM_OFF = 1, - TYPE_OFF = 2 - }; + 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..2fbd7605419 100644 --- a/src/storage/zone_map_manager.cpp +++ b/src/storage/zone_map_manager.cpp @@ -199,6 +199,10 @@ ZoneMapManager::GetResultVectorAsZoneMap( bool ZoneMapManager::ShouldScanTileGroup( storage::PredicateInfo *parsed_predicates, int32_t num_predicates, storage::DataTable *table, int64_t tile_group_idx) { + // 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; diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index f9e8ec00c8c..e7fdeec8169 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 { @@ -150,6 +151,26 @@ 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(); + 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(); @@ -159,6 +180,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/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()); 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..1285e5e86b3 100644 --- a/test/codegen/zone_map_scan_test.cpp +++ b/test/codegen/zone_map_scan_test.cpp @@ -84,10 +84,11 @@ TEST_F(ZoneMapScanTest, ScanNoPredicates) { 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, diff --git a/test/optimizer/old_optimizer_test.cpp b/test/optimizer/old_optimizer_test.cpp index 6de7891516a..48eb37178dc 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,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 + EXPECT_EQ(target_table_->GetIndexCount(), 2); txn_manager.CommitTransaction(txn); 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()); } };