diff --git a/src/catalog/abstract_catalog.cpp b/src/catalog/abstract_catalog.cpp index 645e9c9d93f..1e20d6c76ff 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" @@ -90,11 +92,6 @@ AbstractCatalog::AbstractCatalog(const std::string &catalog_table_ddl, } } -/*@brief insert tuple(reord) helper function - * @param tuple tuple to be inserted - * @param txn TransactionContext - * @return Whether insertion is Successful - */ bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, concurrency::TransactionContext *txn) { if (txn == nullptr) @@ -129,12 +126,53 @@ bool AbstractCatalog::InsertTuple(std::unique_ptr tuple, return this_p_status.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 - * @param txn TransactionContext - * @return Whether deletion 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); + + // 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; +} + + bool AbstractCatalog::DeleteWithIndexScan( oid_t index_offset, std::vector values, concurrency::TransactionContext *txn) { @@ -178,13 +216,53 @@ bool AbstractCatalog::DeleteWithIndexScan( return status; } -/*@brief Index scan helper function - * @param column_offsets Column ids for search (projection) - * @param index_offset Offset of index for scan - * @param values Values for search - * @param txn TransactionContext - * @return Unique pointer of vector of logical tiles - */ +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; +} + std::unique_ptr>> AbstractCatalog::GetResultWithIndexScan( std::vector column_offsets, oid_t index_offset, @@ -226,15 +304,7 @@ AbstractCatalog::GetResultWithIndexScan( return result_tiles; } -/*@brief Sequential scan helper function - * NOTE: try to use efficient index scan instead of sequential scan, but you - * shouldn't build too many indexes on one catalog table - * @param column_offsets Column ids for search (projection) - * @param predicate predicate for this sequential scan query - * @param txn TransactionContext - * - * @return Unique pointer of vector of logical tiles - */ + std::unique_ptr>> AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, @@ -261,15 +331,48 @@ AbstractCatalog::GetResultWithSeqScan(std::vector column_offsets, return result_tiles; } -/*@brief Add index on catalog table - * @param key_attrs indexed column offset(position) - * @param index_oid index id(global unique) - * @param index_name index name(global unique) - * @param index_constraint index constraints - * @return Unique pointer of vector of logical tiles - * Note: Use catalog::Catalog::CreateIndex() if you can, only ColumnCatalog and - * IndexCatalog should need this - */ + +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(); +} + void AbstractCatalog::AddIndex(const std::vector &key_attrs, oid_t index_oid, const std::string &index_name, IndexConstraintType index_constraint) { @@ -298,13 +401,77 @@ void AbstractCatalog::AddIndex(const std::vector &key_attrs, index_name.c_str(), (int)catalog_table_->GetOid()); } -/*@brief Update specific columns using index scan - * @param update_columns Columns to be updated - * @param update_values Values to be updated - * @param scan_values Value to be scaned (used in index scan) - * @param index_offset Offset of index for scan - * @return true if successfully executes - */ +bool AbstractCatalog::UpdateWithCompiledSeqScan( + std::vector update_columns, std::vector update_values, + std::vector column_offsets, expression::AbstractExpression *predicate, + concurrency::TransactionContext *txn) { + if (txn == nullptr) throw CatalogException("Scan table requires transaction"); + // Construct update executor + TargetList target_list; + DirectMapList direct_map_list; + + size_t column_count = catalog_table_->GetSchema()->GetColumnCount(); + for (size_t col_itr = 0; col_itr < column_count; col_itr++) { + // Skip any column for update + if (std::find(std::begin(update_columns), std::end(update_columns), + col_itr) == std::end(update_columns)) { + direct_map_list.emplace_back(col_itr, std::make_pair(0, col_itr)); + } + } + + PELOTON_ASSERT(update_columns.size() == update_values.size()); + for (size_t i = 0; i < update_values.size(); i++) { + planner::DerivedAttribute update_attribute{ + new expression::ConstantValueExpression(update_values[i])}; + target_list.emplace_back(update_columns[i], update_attribute); + } + + std::unique_ptr project_info( + new planner::ProjectInfo(std::move(target_list), + std::move(direct_map_list))); + + std::shared_ptr update_plan{ + new planner::UpdatePlan(catalog_table_, std::move(project_info)) + }; + + std::unique_ptr scan{new planner::SeqScanPlan( + catalog_table_, predicate, column_offsets)}; + update_plan->AddChild(std::move(scan)); + + // Do binding + planner::BindingContext context; + update_plan->PerformBinding(context); + + codegen::BufferingConsumer buffer{column_offsets, context}; + + bool cached; + + codegen::QueryParameters parameters(*update_plan, {}); + std::unique_ptr executor_context( + new executor::ExecutorContext(txn, std::move(parameters))); + + // search for query + codegen::Query *query = codegen::QueryCache::Instance().Find(update_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( + *update_plan, executor_context->GetParams().GetQueryParametersMap(), + buffer); + query = compiled_query.get(); + codegen::QueryCache::Instance().Add(update_plan, std::move(compiled_query)); + } + + query->Execute(std::move(executor_context), buffer, + [&ret](executor::ExecutionResult result) { ret = result; }); + + return ret.m_result == peloton::ResultType::SUCCESS; +} + + bool AbstractCatalog::UpdateWithIndexScan( std::vector update_columns, std::vector update_values, std::vector scan_values, oid_t index_offset, diff --git a/src/catalog/column_catalog.cpp b/src/catalog/column_catalog.cpp index 8262ffe479c..4548c9ffacd 100644 --- a/src/catalog/column_catalog.cpp +++ b/src/catalog/column_catalog.cpp @@ -15,35 +15,38 @@ #include "catalog/catalog.h" #include "catalog/system_catalogs.h" #include "catalog/table_catalog.h" +#include "codegen/buffering_consumer.h" #include "concurrency/transaction_context.h" #include "storage/data_table.h" #include "storage/database.h" #include "type/value_factory.h" +#include "expression/expression_util.h" namespace peloton { namespace catalog { -ColumnCatalogObject::ColumnCatalogObject(executor::LogicalTile *tile, - int tupleId) - : table_oid(tile->GetValue(tupleId, ColumnCatalog::ColumnId::TABLE_OID) + +ColumnCatalogObject::ColumnCatalogObject(codegen::WrappedTuple wrapped_tuple) + : table_oid(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::TABLE_OID) .GetAs()), - column_name(tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_NAME) + column_name(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_NAME) .ToString()), - column_id(tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_ID) - .GetAs()), + column_id(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_ID) + .GetAs()), column_offset( - tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_OFFSET) - .GetAs()), + wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_OFFSET) + .GetAs()), column_type(StringToTypeId( - tile->GetValue(tupleId, ColumnCatalog::ColumnId::COLUMN_TYPE) + wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_TYPE) .ToString())), - is_inlined(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_INLINED) + is_inlined(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_INLINED) .GetAs()), - is_primary(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_PRIMARY) + is_primary(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_PRIMARY) .GetAs()), - is_not_null(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_NOT_NULL) + is_not_null(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_NOT_NULL) .GetAs()) {} + ColumnCatalog::ColumnCatalog(storage::Database *pg_catalog, type::AbstractPool *pool, concurrency::TransactionContext *txn) @@ -140,11 +143,10 @@ bool ColumnCatalog::InsertColumn(oid_t table_oid, oid_t column_id, oid_t column_offset, type::TypeId column_type, bool is_inlined, const std::vector &constraints, - type::AbstractPool *pool, + UNUSED_ATTRIBUTE type::AbstractPool *pool, concurrency::TransactionContext *txn) { // 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); @@ -165,28 +167,74 @@ 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.emplace_back(); +// tuples.push_back(std::vector()); + auto &values = tuples[0]; + + values.emplace_back(constant_expr_0); + values.emplace_back(constant_expr_1); + values.emplace_back(constant_expr_2); + values.emplace_back(constant_expr_3); + values.emplace_back(constant_expr_4); + values.emplace_back(constant_expr_5); + values.emplace_back(constant_expr_6); + values.emplace_back(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 pg_table = Catalog::GetInstance() @@ -195,7 +243,7 @@ bool ColumnCatalog::DeleteColumn(oid_t table_oid, auto table_object = pg_table->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 @@ -206,18 +254,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 pg_table = Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); - table_object->EvictAllColumnObjects(); - - return DeleteWithIndexScan(index_offset, values, txn); + table_object->EvictAllColumnObjects(); + return result; } const std::unordered_map> @@ -234,19 +294,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 bbe94340cdb..54920061d24 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,10 +63,9 @@ bool ColumnStatsCatalog::InsertColumnStats( oid_t database_id, oid_t table_id, oid_t column_id, int num_rows, double cardinality, double frac_null, std::string most_common_vals, std::string most_common_freqs, std::string histogram_bounds, - std::string column_name, bool has_index, type::AbstractPool *pool, + std::string column_name, bool has_index, UNUSED_ATTRIBUTE type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + std::vector> tuples; auto val_db_id = type::ValueFactory::GetIntegerValue(database_id); auto val_table_id = type::ValueFactory::GetIntegerValue(table_id); @@ -96,74 +97,157 @@ 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.emplace_back(); +// tuples.push_back(std::vector()); + auto &values = tuples[0]; + + values.emplace_back(new expression::ConstantValueExpression(val_db_id)); + values.emplace_back(new expression::ConstantValueExpression(val_table_id)); + values.emplace_back(new expression::ConstantValueExpression(val_column_id)); + values.emplace_back(new expression::ConstantValueExpression(val_num_row)); + values.emplace_back(new expression::ConstantValueExpression(val_cardinality)); + values.emplace_back(new expression::ConstantValueExpression(val_frac_null)); + values.emplace_back(new expression::ConstantValueExpression(val_common_val)); + values.emplace_back(new expression::ConstantValueExpression(val_common_freq)); + values.emplace_back(new expression::ConstantValueExpression(val_hist_bounds)); + values.emplace_back(new expression::ConstantValueExpression(val_column_name)); + values.emplace_back(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); + 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.empty()) { 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, @@ -176,56 +260,69 @@ 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(); - LOG_DEBUG("Tuple count: %lu", tuple_count); + 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(); + if (tuple_count == 0) { return 0; } 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 fc0b81c64d0..326ea198ba6 100644 --- a/src/catalog/database_catalog.cpp +++ b/src/catalog/database_catalog.cpp @@ -17,6 +17,8 @@ #include "catalog/catalog.h" #include "catalog/system_catalogs.h" #include "concurrency/transaction_context.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" @@ -26,11 +28,13 @@ namespace peloton { namespace catalog { 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) - .ToString()), + 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), @@ -49,14 +53,14 @@ 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; } std::string key = table_object->GetSchemaName() + "." + table_object->GetTableName(); if (table_name_cache.find(key) != table_name_cache.end()) { - LOG_DEBUG("Table %s already exists in cache!", + LOG_TRACE("Table %s already exists in cache!", table_object->GetTableName().c_str()); return false; } @@ -292,31 +296,52 @@ std::unique_ptr DatabaseCatalog::InitializeSchema() { bool DatabaseCatalog::InsertDatabase(oid_t database_oid, const std::string &database_name, - type::AbstractPool *pool, + UNUSED_ATTRIBUTE type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); - + std::vector> tuples; auto val0 = type::ValueFactory::GetIntegerValue(database_oid); auto val1 = type::ValueFactory::GetVarcharValue(database_name, nullptr); - tuple->SetValue(ColumnId::DATABASE_OID, val0, pool); - tuple->SetValue(ColumnId::DATABASE_NAME, val1, pool); + auto constant_expr_0 = new expression::ConstantValueExpression( + val0); + auto constant_expr_1 = new expression::ConstantValueExpression( + val1); + + tuples.emplace_back(); + auto &values = tuples[0]; + values.emplace_back(ExpressionPtr(constant_expr_0)); + values.emplace_back(ExpressionPtr(constant_expr_1)); - // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool DatabaseCatalog::DeleteDatabase(oid_t database_oid, 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( @@ -330,23 +355,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); + + 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); - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { + 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); } @@ -367,29 +404,36 @@ std::shared_ptr DatabaseCatalog::GetDatabaseObject( auto database_object = txn->catalog_cache.GetDatabaseObject(database_name); if (database_object) return database_object; - // cache miss, get from pg_database std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::SKEY_DATABASE_NAME; // Index of database_name - std::vector values; - values.push_back( - type::ValueFactory::GetVarcharValue(database_name, nullptr).Copy()); - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + 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; } - // return empty object if not found + // return empty object if not found return nullptr; } diff --git a/src/catalog/database_metrics_catalog.cpp b/src/catalog/database_metrics_catalog.cpp index 4fb04fbbb88..378987d1925 100644 --- a/src/catalog/database_metrics_catalog.cpp +++ b/src/catalog/database_metrics_catalog.cpp @@ -14,6 +14,8 @@ #include "executor/logical_tile.h" #include "storage/data_table.h" +#include "expression/abstract_expression.h" +#include "expression/expression_util.h" #include "type/value_factory.h" namespace peloton { @@ -44,31 +46,47 @@ bool DatabaseMetricsCatalog::InsertDatabaseMetrics( oid_t database_oid, oid_t txn_committed, oid_t txn_aborted, oid_t time_stamp, type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + (void) pool; + std::vector> tuples; + tuples.emplace_back(); + 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.emplace_back(new expression::ConstantValueExpression( + val0)); + values.emplace_back(new expression::ConstantValueExpression( + val1)); + values.emplace_back(new expression::ConstantValueExpression( + val2)); + values.emplace_back(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 da666f36f60..34d4a6d9352 100644 --- a/src/catalog/index_catalog.cpp +++ b/src/catalog/index_catalog.cpp @@ -17,6 +17,8 @@ #include "catalog/catalog.h" #include "catalog/system_catalogs.h" #include "concurrency/transaction_context.h" +#include "codegen/buffering_consumer.h" +#include "expression/expression_util.h" #include "executor/logical_tile.h" #include "storage/data_table.h" #include "storage/database.h" @@ -26,24 +28,24 @@ namespace peloton { namespace catalog { -IndexCatalogObject::IndexCatalogObject(executor::LogicalTile *tile, int tupleId) - : index_oid(tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEX_OID) +IndexCatalogObject::IndexCatalogObject(codegen::WrappedTuple &wrapped_tuple) + : index_oid(wrapped_tuple.GetValue(IndexCatalog::ColumnId::INDEX_OID) .GetAs()), - index_name(tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEX_NAME) + index_name(wrapped_tuple.GetValue(IndexCatalog::ColumnId::INDEX_NAME) .ToString()), - table_oid(tile->GetValue(tupleId, IndexCatalog::ColumnId::TABLE_OID) + table_oid(wrapped_tuple.GetValue(IndexCatalog::ColumnId::TABLE_OID) .GetAs()), - schema_name(tile->GetValue(tupleId, IndexCatalog::ColumnId::SCHEMA_NAME) + schema_name(wrapped_tuple.GetValue(IndexCatalog::ColumnId::SCHEMA_NAME) .ToString()), - index_type(tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEX_TYPE) + index_type(wrapped_tuple.GetValue(IndexCatalog::ColumnId::INDEX_TYPE) .GetAs()), index_constraint( - tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEX_CONSTRAINT) + wrapped_tuple.GetValue(IndexCatalog::ColumnId::INDEX_CONSTRAINT) .GetAs()), - unique_keys(tile->GetValue(tupleId, IndexCatalog::ColumnId::UNIQUE_KEYS) + unique_keys(wrapped_tuple.GetValue(IndexCatalog::ColumnId::UNIQUE_KEYS) .GetAs()) { std::string attr_str = - tile->GetValue(tupleId, IndexCatalog::ColumnId::INDEXED_ATTRIBUTES) + wrapped_tuple.GetValue(IndexCatalog::ColumnId::INDEXED_ATTRIBUTES) .ToString(); std::stringstream ss(attr_str.c_str()); // Turn the string into a stream. std::string tok; @@ -135,11 +137,10 @@ bool IndexCatalog::InsertIndex(oid_t index_oid, const std::string &index_name, IndexType index_type, IndexConstraintType index_constraint, bool unique_keys, std::vector indekeys, - type::AbstractPool *pool, + UNUSED_ATTRIBUTE type::AbstractPool *pool, concurrency::TransactionContext *txn) { // 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); @@ -154,33 +155,71 @@ bool IndexCatalog::InsertIndex(oid_t index_oid, const std::string &index_name, for (oid_t indkey : indekeys) os << std::to_string(indkey) << " "; auto val7 = type::ValueFactory::GetVarcharValue(os.str(), nullptr); - tuple->SetValue(IndexCatalog::ColumnId::INDEX_OID, val0, pool); - tuple->SetValue(IndexCatalog::ColumnId::INDEX_NAME, val1, pool); - tuple->SetValue(IndexCatalog::ColumnId::TABLE_OID, val2, pool); - tuple->SetValue(IndexCatalog::ColumnId::SCHEMA_NAME, val3, pool); - tuple->SetValue(IndexCatalog::ColumnId::INDEX_TYPE, val4, pool); - tuple->SetValue(IndexCatalog::ColumnId::INDEX_CONSTRAINT, val5, pool); - tuple->SetValue(IndexCatalog::ColumnId::UNIQUE_KEYS, val6, pool); - tuple->SetValue(IndexCatalog::ColumnId::INDEXED_ATTRIBUTES, val7, pool); + 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.emplace_back(); + auto &values = tuples[0]; + values.emplace_back(constant_expr_0); + values.emplace_back(constant_expr_1); + values.emplace_back(constant_expr_2); + values.emplace_back(constant_expr_3); + values.emplace_back(constant_expr_4); + values.emplace_back(constant_expr_5); + values.emplace_back(constant_expr_6); + values.emplace_back(constant_expr_7); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool IndexCatalog::DeleteIndex(oid_t index_oid, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Index of index_oid + std::vector column_ids(all_column_ids); + + std::vector values; values.push_back(type::ValueFactory::GetIntegerValue(index_oid).Copy()); - auto index_object = txn->catalog_cache.GetCachedIndexObject(index_oid); - if (index_object) { - auto table_object = + auto index_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::INDEX_OID); + index_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), ColumnId::TABLE_OID); + + + expression::AbstractExpression *index_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(index_oid).Copy()); + expression::AbstractExpression *index_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, index_oid_expr, index_oid_const_expr); + + bool result = DeleteWithCompiledSeqScan(column_ids, index_oid_equality_expr, txn); + + if(result){ + auto index_object = txn->catalog_cache.GetCachedIndexObject(index_oid); + if (index_object) { + auto table_object = txn->catalog_cache.GetCachedTableObject(index_object->GetTableOid()); - table_object->EvictAllIndexObjects(); + table_object->EvictAllIndexObjects(); + } } - - return DeleteWithIndexScan(index_offset, values, txn); + return result; } std::shared_ptr IndexCatalog::GetIndexObject( @@ -189,23 +228,30 @@ 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 pg_table = Catalog::GetInstance() ->GetSystemCatalogs(database_oid) @@ -213,10 +259,10 @@ std::shared_ptr IndexCatalog::GetIndexObject( auto table_object = pg_table->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 @@ -232,26 +278,50 @@ std::shared_ptr IndexCatalog::GetIndexObject( // try get from cache auto index_object = txn->catalog_cache.GetCachedIndexObject(index_name, schema_name); - if (index_object) { - return index_object; - } + 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 & schema_name - std::vector values; - values.push_back( + + auto index_name_expr = new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, + ColumnId::INDEX_NAME); + + index_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), + ColumnId::INDEX_NAME); + + expression::AbstractExpression *index_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetVarcharValue(index_name, nullptr).Copy()); - values.push_back( + expression::AbstractExpression *index_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, index_name_expr, index_name_const_expr); + + auto *schema_name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, + ColumnId::SCHEMA_NAME); + schema_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::SCHEMA_NAME); + expression::AbstractExpression *schema_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); + expression::AbstractExpression *schema_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, schema_name_expr, schema_name_const_expr); + + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, index_name_equality_expr, + schema_name_equality_expr); - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { + if (result_tuples.size() == 1) { auto index_object = - std::make_shared((*result_tiles)[0].get()); + std::make_shared(result_tuples[0]); // fetch all indexes into table object (cannot use the above index object) auto pg_table = Catalog::GetInstance() ->GetSystemCatalogs(database_oid) @@ -262,7 +332,7 @@ std::shared_ptr IndexCatalog::GetIndexObject( table_object->GetTableOid() == index_object->GetTableOid()); return table_object->GetIndexObject(index_name); } else { - LOG_DEBUG("Found %lu index with name %s", result_tiles->size(), + LOG_DEBUG("Found %lu index with name %s", result_tuples.size(), index_name.c_str()); } @@ -282,32 +352,41 @@ IndexCatalog::GetIndexObjects(oid_t table_oid, if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } + // try get from cache auto pg_table = Catalog::GetInstance() ->GetSystemCatalogs(database_oid) ->GetTableCatalog(); auto table_object = pg_table->GetTableObject(table_oid, txn); 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 e744765ef96..11edad20221 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" @@ -40,8 +41,10 @@ bool IndexMetricsCatalog::InsertIndexMetrics( oid_t table_oid, oid_t index_oid, int64_t reads, int64_t deletes, int64_t inserts, int64_t time_stamp, type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + + (void) pool; + // Create the tuple first + std::vector> tuples; auto val1 = type::ValueFactory::GetIntegerValue(table_oid); auto val2 = type::ValueFactory::GetIntegerValue(index_oid); @@ -50,25 +53,57 @@ bool IndexMetricsCatalog::InsertIndexMetrics( auto val5 = type::ValueFactory::GetIntegerValue(inserts); auto val6 = type::ValueFactory::GetIntegerValue(time_stamp); - 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); - // Insert the tuple - return InsertTuple(std::move(tuple), txn); + 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.emplace_back(); + auto &values = tuples[0]; + values.emplace_back(constant_expr_1); + values.emplace_back(constant_expr_2); + values.emplace_back(constant_expr_3); + values.emplace_back(constant_expr_4); + values.emplace_back(constant_expr_5); + values.emplace_back(constant_expr_6); + + return InsertTupleWithCompiledPlan(&tuples, txn); } bool IndexMetricsCatalog::DeleteIndexMetrics( oid_t index_oid, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(index_oid).Copy()); + // cache miss, get from pg_database + std::vector column_ids(all_column_ids); + + auto *oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::INDEX_OID); + + oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::INDEX_OID); + + expression::AbstractExpression *oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(index_oid).Copy()); + expression::AbstractExpression *oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, oid_expr, oid_const_expr); + + expression::AbstractExpression *predicate = oid_equality_expr; + + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); - return DeleteWithIndexScan(index_offset, values, txn); } } // namespace catalog diff --git a/src/catalog/language_catalog.cpp b/src/catalog/language_catalog.cpp index ddcceb6d89d..b7d24cbfd0d 100644 --- a/src/catalog/language_catalog.cpp +++ b/src/catalog/language_catalog.cpp @@ -16,13 +16,15 @@ #include "executor/logical_tile.h" #include "storage/data_table.h" #include "type/value_factory.h" +#include "codegen/buffering_consumer.h" +#include "expression/expression_util.h" namespace peloton { namespace catalog { -LanguageCatalogObject::LanguageCatalogObject(executor::LogicalTile *tuple) - : lang_oid_(tuple->GetValue(0, 0).GetAs()), - lang_name_(tuple->GetValue(0, 1).GetAs()) {} +LanguageCatalogObject::LanguageCatalogObject(codegen::WrappedTuple &tuple) + : lang_oid_(tuple.GetValue(0).GetAs()), + lang_name_(tuple.GetValue(1).GetAs()) {} LanguageCatalog &LanguageCatalog::GetInstance( concurrency::TransactionContext *txn) { @@ -46,49 +48,73 @@ LanguageCatalog::LanguageCatalog(concurrency::TransactionContext *txn) // insert a new language by name bool LanguageCatalog::InsertLanguage(const std::string &lanname, - type::AbstractPool *pool, + UNUSED_ATTRIBUTE type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + std::vector> tuples; + tuples.emplace_back(); + 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.emplace_back(new expression::ConstantValueExpression( + val0)); + values.emplace_back(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.empty()) { + ret.reset(new LanguageCatalogObject(result_tuples[0])); } return ret; @@ -96,19 +122,29 @@ 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.empty()) { + ret.reset(new LanguageCatalogObject(result_tuples[0])); } return ret; diff --git a/src/catalog/proc_catalog.cpp b/src/catalog/proc_catalog.cpp index 6da75db67fc..3876fa8b126 100644 --- a/src/catalog/proc_catalog.cpp +++ b/src/catalog/proc_catalog.cpp @@ -17,20 +17,23 @@ #include "executor/logical_tile.h" #include "storage/data_table.h" #include "type/value_factory.h" +#include "expression/expression_util.h" +#include "codegen/buffering_consumer.h" namespace peloton { namespace catalog { #define PROC_CATALOG_NAME "pg_proc" -ProcCatalogObject::ProcCatalogObject(executor::LogicalTile *tile, +ProcCatalogObject::ProcCatalogObject(codegen::WrappedTuple &wrapped_tuple, concurrency::TransactionContext *txn) - : oid_(tile->GetValue(0, 0).GetAs()), - name_(tile->GetValue(0, 1).GetAs()), - ret_type_(tile->GetValue(0, 2).GetAs()), - arg_types_(StringToTypeArray(tile->GetValue(0, 3).GetAs())), - lang_oid_(tile->GetValue(0, 4).GetAs()), - src_(tile->GetValue(0, 5).GetAs()), + : 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 { @@ -64,10 +67,10 @@ bool ProcCatalog::InsertProc(const std::string &proname, type::TypeId prorettype, const std::vector &proargtypes, oid_t prolang, const std::string &prosrc, - type::AbstractPool *pool, + UNUSED_ATTRIBUTE type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + // Create the tuple first + std::vector> tuples; oid_t proc_oid = GetNextOid(); auto val0 = type::ValueFactory::GetIntegerValue(proc_oid); @@ -78,32 +81,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.emplace_back(); + auto &values = tuples[0]; + values.emplace_back(constant_expr_0); + values.emplace_back(constant_expr_1); + values.emplace_back(constant_expr_2); + values.emplace_back(constant_expr_3); + values.emplace_back(constant_expr_4); + values.emplace_back(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.empty()) { + ret.reset(new ProcCatalogObject(result_tuples[0], txn)); } return ret; @@ -114,21 +141,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); // unique 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.empty()) { + 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 4433197ba28..cd32f28b6dd 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.emplace_back(); + auto &values = tuples[0]; + values.emplace_back(constant_expr_0); + values.emplace_back(constant_expr_1); + values.emplace_back(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 0fd6b7c44d7..812967bb027 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" @@ -52,8 +54,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.emplace_back(); + auto &values = tuples[0]; auto val0 = type::ValueFactory::GetVarcharValue(name, pool); auto val1 = type::ValueFactory::GetIntegerValue(database_oid); @@ -80,56 +84,126 @@ 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.emplace_back(new expression::ConstantValueExpression( + val0)); + values.emplace_back(new expression::ConstantValueExpression( + val1)); + values.emplace_back(new expression::ConstantValueExpression( + val2)); + values.emplace_back(new expression::ConstantValueExpression( + val3)); + values.emplace_back(new expression::ConstantValueExpression( + val4)); + values.emplace_back(new expression::ConstantValueExpression( + val5)); + values.emplace_back(new expression::ConstantValueExpression( + val6)); + values.emplace_back(new expression::ConstantValueExpression( + val7)); + values.emplace_back(new expression::ConstantValueExpression( + val8)); + values.emplace_back(new expression::ConstantValueExpression( + val9)); + values.emplace_back(new expression::ConstantValueExpression( + val10)); + values.emplace_back(new expression::ConstantValueExpression( + val11)); + values.emplace_back(new expression::ConstantValueExpression( + val12)); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool QueryMetricsCatalog::DeleteQueryMetrics( const std::string &name, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index - std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); - values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy()); + 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); - 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, concurrency::TransactionContext *txn) { - std::vector column_ids({ColumnId::PARAM_TYPES}); // param_types - oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index - std::vector values; - 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.empty()) { + 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; @@ -137,23 +211,52 @@ stats::QueryMetric::QueryParamBuf QueryMetricsCatalog::GetParamTypes( int64_t QueryMetricsCatalog::GetNumParams( const std::string &name, concurrency::TransactionContext *txn) { - std::vector column_ids({ColumnId::NUM_PARAMS}); // num_params - oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index - std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + std::vector column_ids(all_column_ids); + + auto *name_expr = + new expression::TupleValueExpression( + type::TypeId::VARCHAR, 0, + ColumnId::NAME); + + name_expr->SetBoundOid( + catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::NAME); + + expression::AbstractExpression *name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); + expression::AbstractExpression *name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, name_expr, name_const_expr); + + auto *db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_OID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::DATABASE_OID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_oid).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); + + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, name_equality_expr, + db_oid_equality_expr); + + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, txn); int64_t num_params = 0; - PELOTON_ASSERT(result_tiles->size() <= 1); // unique - if (result_tiles->size() != 0) { - PELOTON_ASSERT((*result_tiles)[0]->GetTupleCount() <= 1); - if ((*result_tiles)[0]->GetTupleCount() != 0) { - num_params = (*result_tiles)[0] - ->GetValue(0, 0) - .GetAs(); // After projection left 1 column - } + PELOTON_ASSERT(result_tuples.size() <= 1); // unique + if (!result_tuples.empty()) { + 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 ab38f8c8501..e970cdc40e5 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/schema_catalog.cpp b/src/catalog/schema_catalog.cpp index 4761bb0e776..4228dac6a94 100644 --- a/src/catalog/schema_catalog.cpp +++ b/src/catalog/schema_catalog.cpp @@ -20,16 +20,18 @@ #include "storage/database.h" #include "storage/tuple.h" #include "type/value_factory.h" +#include "codegen/buffering_consumer.h" +#include "expression/expression_util.h" namespace peloton { namespace catalog { -SchemaCatalogObject::SchemaCatalogObject(executor::LogicalTile *tile, +SchemaCatalogObject::SchemaCatalogObject(codegen::WrappedTuple &wrapped_tuple, concurrency::TransactionContext *txn) - : schema_oid(tile->GetValue(0, SchemaCatalog::ColumnId::SCHEMA_OID) + : schema_oid(wrapped_tuple.GetValue(SchemaCatalog::ColumnId::SCHEMA_OID) .GetAs()), schema_name( - tile->GetValue(0, SchemaCatalog::ColumnId::SCHEMA_NAME).ToString()), + wrapped_tuple.GetValue(SchemaCatalog::ColumnId::SCHEMA_NAME).ToString()), txn(txn) {} SchemaCatalog::SchemaCatalog( @@ -73,30 +75,41 @@ std::unique_ptr SchemaCatalog::InitializeSchema() { bool SchemaCatalog::InsertSchema(oid_t schema_oid, const std::string &schema_name, - type::AbstractPool *pool, + UNUSED_ATTRIBUTE type::AbstractPool *pool, concurrency::TransactionContext *txn) { // Create the tuple first - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + std::vector> tuples; auto val0 = type::ValueFactory::GetIntegerValue(schema_oid); auto val1 = type::ValueFactory::GetVarcharValue(schema_name, nullptr); - tuple->SetValue(SchemaCatalog::ColumnId::SCHEMA_OID, val0, pool); - tuple->SetValue(SchemaCatalog::ColumnId::SCHEMA_NAME, val1, pool); + tuples.emplace_back(); + auto &values = tuples[0]; + values.emplace_back(new expression::ConstantValueExpression(val0)); + values.emplace_back(new expression::ConstantValueExpression(val1)); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool SchemaCatalog::DeleteSchema(const std::string &schema_name, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::SKEY_SCHEMA_NAME; // Index of schema_name - std::vector values; - values.push_back( - type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); + std::vector column_ids(all_column_ids); + + auto *schema_name_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::SCHEMA_NAME); + schema_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::SCHEMA_NAME); + + + expression::AbstractExpression *schema_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); + expression::AbstractExpression *schema_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, schema_name_expr, schema_name_const_expr); - return DeleteWithIndexScan(index_offset, values, txn); + return DeleteWithCompiledSeqScan(column_ids, schema_name_equality_expr, txn); } std::shared_ptr SchemaCatalog::GetSchemaObject( @@ -106,17 +119,26 @@ std::shared_ptr SchemaCatalog::GetSchemaObject( } // get from pg_namespace, index scan std::vector column_ids(all_column_ids); - oid_t index_offset = IndexId::SKEY_SCHEMA_NAME; // Index of database_name - std::vector values; - values.push_back( - type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); + auto *schema_name_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::SCHEMA_NAME); + schema_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::SCHEMA_NAME); + + + expression::AbstractExpression *schema_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); + expression::AbstractExpression *schema_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, schema_name_expr, schema_name_const_expr); + + + auto result_tuples = GetResultWithCompiledSeqScan(column_ids, schema_name_equality_expr, txn); - if (result_tiles->size() == 1 && (*result_tiles)[0]->GetTupleCount() == 1) { + if (result_tuples.size() == 1) { auto schema_object = - std::make_shared((*result_tiles)[0].get(), txn); + std::make_shared(result_tuples[0], txn); // TODO: we don't have cache for schema object right now return schema_object; } diff --git a/src/catalog/settings_catalog.cpp b/src/catalog/settings_catalog.cpp index bcdc518af24..f5f7e8815db 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" @@ -55,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); @@ -70,67 +72,120 @@ bool SettingsCatalog::InsertSetting( auto val7 = type::ValueFactory::GetBooleanValue(is_mutable); auto val8 = type::ValueFactory::GetBooleanValue(is_persistent); - tuple->SetValue(static_cast(ColumnId::NAME), val0, pool); - tuple->SetValue(static_cast(ColumnId::VALUE), val1, pool); - tuple->SetValue(static_cast(ColumnId::VALUE_TYPE), val2, pool); - tuple->SetValue(static_cast(ColumnId::DESCRIPTION), val3, pool); - tuple->SetValue(static_cast(ColumnId::MIN_VALUE), val4, pool); - tuple->SetValue(static_cast(ColumnId::MAX_VALUE), val5, pool); - tuple->SetValue(static_cast(ColumnId::DEFAULT_VALUE), val6, pool); - tuple->SetValue(static_cast(ColumnId::IS_MUTABLE), val7, pool); - tuple->SetValue(static_cast(ColumnId::IS_PERSISTENT), val8, pool); + auto constant_expr_0 = new expression::ConstantValueExpression( + val0); + auto constant_expr_1 = new expression::ConstantValueExpression( + val1); + auto constant_expr_2 = new expression::ConstantValueExpression( + val2); + auto constant_expr_3 = new expression::ConstantValueExpression( + val3); + auto constant_expr_4 = new expression::ConstantValueExpression( + val4); + auto constant_expr_5 = new expression::ConstantValueExpression( + val5); + auto constant_expr_6 = new expression::ConstantValueExpression( + val6); + auto constant_expr_7 = new expression::ConstantValueExpression( + val7); + auto constant_expr_8 = new expression::ConstantValueExpression( + val8); + + tuples.push_back(std::vector()); + auto &values = tuples[0]; + values.push_back(ExpressionPtr(constant_expr_0)); + values.push_back(ExpressionPtr(constant_expr_1)); + values.push_back(ExpressionPtr(constant_expr_2)); + values.push_back(ExpressionPtr(constant_expr_3)); + values.push_back(ExpressionPtr(constant_expr_4)); + values.push_back(ExpressionPtr(constant_expr_5)); + values.push_back(ExpressionPtr(constant_expr_6)); + values.push_back(ExpressionPtr(constant_expr_7)); + values.push_back(ExpressionPtr(constant_expr_8)); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } bool SettingsCatalog::DeleteSetting(const std::string &name, concurrency::TransactionContext *txn) { - oid_t index_offset = 0; - std::vector values; - values.push_back(type::ValueFactory::GetVarcharValue(name, nullptr).Copy()); + std::vector column_ids(all_column_ids); - return DeleteWithIndexScan(index_offset, values, txn); + auto *name_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + 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 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::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.empty()) { + 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::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.empty()) { + 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 9f181d4c0dc..48cbca869e7 100644 --- a/src/catalog/table_catalog.cpp +++ b/src/catalog/table_catalog.cpp @@ -23,23 +23,27 @@ #include "concurrency/transaction_context.h" #include "storage/data_table.h" #include "storage/database.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 { -TableCatalogObject::TableCatalogObject(executor::LogicalTile *tile, - concurrency::TransactionContext *txn, - int tupleId) - : table_oid(tile->GetValue(tupleId, TableCatalog::ColumnId::TABLE_OID) +TableCatalogObject::TableCatalogObject(codegen::WrappedTuple &wrapped_tuple, + concurrency::TransactionContext *txn) + : table_oid(wrapped_tuple.GetValue(TableCatalog::ColumnId::TABLE_OID) .GetAs()), - table_name(tile->GetValue(tupleId, TableCatalog::ColumnId::TABLE_NAME) + table_name(wrapped_tuple.GetValue(TableCatalog::ColumnId::TABLE_NAME) .ToString()), - schema_name(tile->GetValue(tupleId, TableCatalog::ColumnId::SCHEMA_NAME) + schema_name(wrapped_tuple.GetValue(TableCatalog::ColumnId::SCHEMA_NAME) .ToString()), - database_oid(tile->GetValue(tupleId, TableCatalog::ColumnId::DATABASE_OID) + database_oid(wrapped_tuple.GetValue(TableCatalog::ColumnId::DATABASE_OID) .GetAs()), - version_id(tile->GetValue(tupleId, TableCatalog::ColumnId::VERSION_ID) + version_id(wrapped_tuple.GetValue(TableCatalog::ColumnId::VERSION_ID) .GetAs()), index_objects(), index_names(), @@ -467,11 +471,10 @@ std::unique_ptr TableCatalog::InitializeSchema() { */ bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, const std::string &schema_name, - oid_t database_oid, type::AbstractPool *pool, + oid_t database_oid, UNUSED_ATTRIBUTE type::AbstractPool *pool, concurrency::TransactionContext *txn) { // 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); @@ -479,14 +482,28 @@ bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, auto val3 = type::ValueFactory::GetIntegerValue(database_oid); auto val4 = type::ValueFactory::GetIntegerValue(0); - tuple->SetValue(TableCatalog::ColumnId::TABLE_OID, val0, pool); - tuple->SetValue(TableCatalog::ColumnId::TABLE_NAME, val1, pool); - tuple->SetValue(TableCatalog::ColumnId::SCHEMA_NAME, val2, pool); - tuple->SetValue(TableCatalog::ColumnId::DATABASE_OID, val3, pool); - tuple->SetValue(TableCatalog::ColumnId::VERSION_ID, val4, pool); - - // Insert the tuple - return InsertTuple(std::move(tuple), txn); + 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); + + +// tuples.push_back(std::vector()); + tuples.emplace_back(); + auto &values = tuples[0]; + values.emplace_back(constant_expr_0); + values.emplace_back(constant_expr_1); + values.emplace_back(constant_expr_2); + values.emplace_back(constant_expr_3); + values.emplace_back(constant_expr_4); + + return InsertTupleWithCompiledPlan(&tuples, txn); } /*@brief delete a tuple about table info from pg_table(using index scan) @@ -496,19 +513,35 @@ bool TableCatalog::InsertTable(oid_t table_oid, const std::string &table_name, */ bool TableCatalog::DeleteTable(oid_t table_oid, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Index of table_oid - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); - // evict from cache - auto table_object = txn->catalog_cache.GetCachedTableObject(table_oid); - if (table_object) { + 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); + + if(result) { + // evict from cache + auto table_object = txn->catalog_cache.GetCachedTableObject(table_oid); + if (table_object) { auto database_object = DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn); - database_object->EvictTableObject(table_oid); + database_object->EvictTableObject(table_oid); + } } - - return DeleteWithIndexScan(index_offset, values, txn); + return result; } /*@brief read table catalog object from pg_table using table oid @@ -527,16 +560,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(database_oid, txn); @@ -544,9 +586,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 @@ -567,7 +610,8 @@ std::shared_ptr TableCatalog::GetTableObject( if (txn == nullptr) { throw CatalogException("Transaction is invalid!"); } - // try get from cache + + //try get from cache auto database_object = txn->catalog_cache.GetDatabaseObject(database_oid); if (database_object) { auto table_object = @@ -577,19 +621,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 - std::vector values; - values.push_back( - type::ValueFactory::GetVarcharValue(table_name, nullptr).Copy()); - values.push_back( - type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); - - auto result_tiles = - GetResultWithIndexScan(column_ids, index_offset, values, txn); - 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 *schema_name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, + ColumnId::SCHEMA_NAME); + schema_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::SCHEMA_NAME); + expression::AbstractExpression *schema_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(schema_name, nullptr).Copy()); + expression::AbstractExpression *schema_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, schema_name_expr, schema_name_const_expr); + + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, table_name_equality_expr, + schema_name_equality_expr); + + // ceate predicate refering to seq_scan_test.cpp + std::vector result_tuples = + GetResultWithCompiledSeqScan(column_ids, predicate, 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(database_oid, txn); @@ -597,9 +669,9 @@ std::shared_ptr TableCatalog::GetTableObject( bool success = database_object->InsertTableObject(table_object); PELOTON_ASSERT(success == true); (void)success; + return table_object; } - // return empty object if not found return nullptr; } @@ -624,19 +696,27 @@ TableCatalog::GetTableObjects(concurrency::TransactionContext *txn) { // 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); @@ -652,14 +732,23 @@ TableCatalog::GetTableObjects(concurrency::TransactionContext *txn) { bool TableCatalog::UpdateVersionId(oid_t update_val, oid_t table_oid, concurrency::TransactionContext *txn) { std::vector update_columns({ColumnId::VERSION_ID}); // version_id - oid_t index_offset = IndexId::PRIMARY_KEY; // Index of table_oid - // values to execute index scan - std::vector scan_values; - scan_values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); // values to update std::vector update_values; update_values.push_back( - type::ValueFactory::GetIntegerValue(update_val).Copy()); + type::ValueFactory::GetIntegerValue(update_val).Copy()); + // cache miss, get from pg_table + 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); // get table object, then evict table object auto table_object = txn->catalog_cache.GetCachedTableObject(table_oid); @@ -669,8 +758,8 @@ bool TableCatalog::UpdateVersionId(oid_t update_val, oid_t table_oid, database_object->EvictTableObject(table_oid); } - return UpdateWithIndexScan(update_columns, update_values, scan_values, - index_offset, txn); + return UpdateWithCompiledSeqScan(update_columns, update_values, column_ids, + table_oid_equality_expr, txn); } } // namespace catalog diff --git a/src/catalog/table_metrics_catalog.cpp b/src/catalog/table_metrics_catalog.cpp index f1f91f46474..d60e0499cb4 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" @@ -40,8 +41,10 @@ bool TableMetricsCatalog::InsertTableMetrics( oid_t table_oid, int64_t reads, int64_t updates, int64_t deletes, int64_t inserts, int64_t time_stamp, type::AbstractPool *pool, concurrency::TransactionContext *txn) { - std::unique_ptr tuple( - new storage::Tuple(catalog_table_->GetSchema(), true)); + + (void) pool; + // Create the tuple first + std::vector> tuples; auto val1 = type::ValueFactory::GetIntegerValue(table_oid); auto val2 = type::ValueFactory::GetIntegerValue(reads); @@ -50,25 +53,55 @@ bool TableMetricsCatalog::InsertTableMetrics( auto val5 = type::ValueFactory::GetIntegerValue(inserts); auto val6 = type::ValueFactory::GetIntegerValue(time_stamp); - 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); - // Insert the tuple - return InsertTuple(std::move(tuple), txn); + 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.emplace_back(); + auto &values = tuples[0]; + values.emplace_back(constant_expr_1); + values.emplace_back(constant_expr_2); + values.emplace_back(constant_expr_3); + values.emplace_back(constant_expr_4); + values.emplace_back(constant_expr_5); + values.emplace_back(constant_expr_6); + + return InsertTupleWithCompiledPlan(&tuples, txn); } bool TableMetricsCatalog::DeleteTableMetrics( oid_t table_oid, concurrency::TransactionContext *txn) { - oid_t index_offset = IndexId::PRIMARY_KEY; // Primary key index - std::vector values; - values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy()); + std::vector column_ids(all_column_ids); + + 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 = 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 1474dd20d4c..3344bc6c566 100644 --- a/src/catalog/trigger_catalog.cpp +++ b/src/catalog/trigger_catalog.cpp @@ -10,6 +10,8 @@ // //===----------------------------------------------------------------------===// +#include "expression/expression_util.h" +#include "codegen/buffering_consumer.h" #include "catalog/trigger_catalog.h" #include "catalog/catalog.h" @@ -30,7 +32,7 @@ TriggerCatalog::TriggerCatalog(const std::string &database_name, "oid INT NOT NULL PRIMARY KEY, " "tgrelid INT NOT NULL, " "tgname VARCHAR NOT NULL, " - "tgfoid VARCHAR, " + "tgfname VARCHAR, " "tgtype INT NOT NULL, " "tgargs VARCHAR, " "tgqual VARBINARY, " @@ -56,37 +58,48 @@ TriggerCatalog::TriggerCatalog(const std::string &database_name, 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.emplace_back(); + 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.emplace_back(new expression::ConstantValueExpression( + val0)); + values.emplace_back(new expression::ConstantValueExpression( + val1)); + values.emplace_back(new expression::ConstantValueExpression( + val2)); + values.emplace_back(new expression::ConstantValueExpression( + val3)); + values.emplace_back(new expression::ConstantValueExpression( + val4)); + values.emplace_back(new expression::ConstantValueExpression( + val5)); + values.emplace_back(new expression::ConstantValueExpression( + val6)); + values.emplace_back(new expression::ConstantValueExpression( + val7)); // Insert the tuple - return InsertTuple(std::move(tuple), txn); + return InsertTupleWithCompiledPlan(&tuples, txn); } ResultType TriggerCatalog::DropTrigger(const oid_t database_oid, @@ -109,122 +122,190 @@ ResultType TriggerCatalog::DropTrigger(const oid_t database_oid, 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) { - // LOG_INFO("trigger %s doesn't exist", trigger_name.c_str()); + if (result_tuples.empty()) { + 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(); - } + PELOTON_ASSERT(result_tuples.size() == 1); // unique + 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); - return DeleteWithIndexScan(index_offset, values, txn); + auto *trigger_name_expr = + new expression::TupleValueExpression(type::TypeId::VARCHAR, 0, + ColumnId::TRIGGER_NAME); + trigger_name_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::TRIGGER_NAME); + expression::AbstractExpression *trigger_name_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetVarcharValue(trigger_name, nullptr).Copy()); + expression::AbstractExpression *trigger_name_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, trigger_name_expr, + trigger_name_const_expr); + + auto *table_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_OID); + table_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), + catalog_table_->GetOid(), + ColumnId::TABLE_OID); + + expression::AbstractExpression *table_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_oid).Copy()); + expression::AbstractExpression *table_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, table_oid_expr, table_oid_const_expr); + + 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) { 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 (auto &tuple : result_tuples) { + // create a new trigger instance + trigger::Trigger new_trigger(tuple.GetValue(ColumnId::TRIGGER_NAME).ToString(), + trigger_type, + tuple.GetValue(ColumnId::FUNCTION_NAME).ToString(), + tuple.GetValue(ColumnId::FUNCTION_ARGS).ToString(), + tuple.GetValue(ColumnId::FIRE_CONDITION).GetData()); + new_trigger_list->AddTrigger(std::move(new_trigger)); } + return new_trigger_list; } 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()); - // } // 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 (auto &tuple : result_tuples) { + // create a new trigger instance + trigger::Trigger new_trigger(tuple.GetValue(ColumnId::TRIGGER_NAME).ToString(), + tuple.GetValue(ColumnId::TRIGGER_TYPE).GetAs(), + tuple.GetValue(ColumnId::FUNCTION_NAME).ToString(), + tuple.GetValue(ColumnId::FUNCTION_ARGS).ToString(), + tuple.GetValue(ColumnId::FIRE_CONDITION).GetData()); + new_trigger_list->AddTrigger(std::move(new_trigger)); } return new_trigger_list; diff --git a/src/catalog/zone_map_catalog.cpp b/src/catalog/zone_map_catalog.cpp index ec59dd24d82..f2a81c050a5 100644 --- a/src/catalog/zone_map_catalog.cpp +++ b/src/catalog/zone_map_catalog.cpp @@ -18,6 +18,8 @@ #include "storage/data_table.h" #include "storage/tuple.h" #include "type/value_factory.h" +#include "expression/expression_util.h" +#include "codegen/buffering_consumer.h" namespace peloton { namespace catalog { @@ -56,8 +58,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); @@ -67,66 +70,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.emplace_back(); + auto &values = tuples[0]; + + values.emplace_back(constant_db_id_expr); + values.emplace_back(constant_table_id_expr); + values.emplace_back(constant_tile_group_id_expr); + values.emplace_back(constant_column_id_expr); + values.emplace_back(constant_minimum_expr); + values.emplace_back(constant_maximum_expr); + values.emplace_back(constant_type_expr); + + return InsertTupleWithCompiledPlan(&tuples, txn); } bool ZoneMapCatalog::DeleteColumnStatistics( oid_t database_id, oid_t table_id, oid_t tile_group_id, oid_t column_id, concurrency::TransactionContext *txn) { - oid_t index_offset = static_cast(IndexId::SECONDARY_KEY_0); - std::vector values( - {type::ValueFactory::GetIntegerValue(database_id), - type::ValueFactory::GetIntegerValue(table_id), - type::ValueFactory::GetIntegerValue(tile_group_id), - type::ValueFactory::GetIntegerValue(column_id)}); - return DeleteWithIndexScan(index_offset, values, txn); + std::vector column_ids(all_column_ids); + + auto db_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::DATABASE_ID); + db_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::DATABASE_ID); + expression::AbstractExpression *db_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(database_id).Copy()); + expression::AbstractExpression *db_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, db_oid_expr, db_oid_const_expr); + + + auto tb_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TABLE_ID); + tb_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TABLE_ID); + expression::AbstractExpression *tb_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(table_id).Copy()); + expression::AbstractExpression *tb_oid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, tb_oid_expr, tb_oid_const_expr); + + auto tile_gid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::TILE_GROUP_ID); + tile_gid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::TILE_GROUP_ID); + expression::AbstractExpression *tile_gid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(tile_group_id).Copy()); + expression::AbstractExpression *tile_gid_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, tile_gid_expr, tile_gid_const_expr); + + auto col_oid_expr = + new expression::TupleValueExpression(type::TypeId::INTEGER, 0, + ColumnId::COLUMN_ID); + col_oid_expr->SetBoundOid(catalog_table_->GetDatabaseOid(), catalog_table_->GetOid(), ColumnId::COLUMN_ID); + expression::AbstractExpression *col_oid_const_expr = + expression::ExpressionUtil::ConstantValueFactory( + type::ValueFactory::GetIntegerValue(column_id).Copy()); + expression::AbstractExpression *col_id_equality_expr = + expression::ExpressionUtil::ComparisonFactory( + ExpressionType::COMPARE_EQUAL, col_oid_expr, col_oid_const_expr); + + expression::AbstractExpression *db_and_tb = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_oid_equality_expr, + tb_oid_equality_expr); + expression::AbstractExpression *pred_and_tile = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, db_and_tb, tile_gid_equality_expr); + expression::AbstractExpression *predicate = + expression::ExpressionUtil::ConjunctionFactory( + ExpressionType::CONJUNCTION_AND, pred_and_tile, col_id_equality_expr); + + return DeleteWithCompiledSeqScan(column_ids, predicate, txn); } std::unique_ptr> ZoneMapCatalog::GetColumnStatistics( 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.empty()) { 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/codegen/operator/table_scan_translator.cpp b/src/codegen/operator/table_scan_translator.cpp index f9a793c2be7..dde8e493fde 100644 --- a/src/codegen/operator/table_scan_translator.cpp +++ b/src/codegen/operator/table_scan_translator.cpp @@ -37,7 +37,7 @@ TableScanTranslator::TableScanTranslator(const planner::SeqScanPlan &scan, : OperatorTranslator(context, pipeline), scan_(scan), table_(*scan_.GetTable()) { - LOG_DEBUG("Constructing TableScanTranslator ..."); +// LOG_DEBUG("Constructing TableScanTranslator ..."); // The restriction, if one exists const auto *predicate = GetScanPlan().GetPredicate(); @@ -210,7 +210,7 @@ void TableScanTranslator::ScanConsumer::FilterRowsByPredicate( // First, check if the predicate is SIMDable const auto *predicate = GetPredicate(); - LOG_DEBUG("Is Predicate SIMDable : %d", predicate->IsSIMDable()); +// LOG_DEBUG("Is Predicate SIMDable : %d", predicate->IsSIMDable()); // Determine the attributes the predicate needs std::unordered_set used_attributes; predicate->GetUsedAttributes(used_attributes); diff --git a/src/codegen/runtime_functions.cpp b/src/codegen/runtime_functions.cpp index 40562516f75..b2b72c10f8e 100644 --- a/src/codegen/runtime_functions.cpp +++ b/src/codegen/runtime_functions.cpp @@ -24,6 +24,8 @@ #include "storage/tile_group.h" #include "storage/zone_map_manager.h" #include "type/value_factory.h" +#include "storage/zone_map_manager.h" + namespace peloton { namespace codegen { diff --git a/src/codegen/table.cpp b/src/codegen/table.cpp index 335789db388..64d7b8537cd 100644 --- a/src/codegen/table.cpp +++ b/src/codegen/table.cpp @@ -77,16 +77,6 @@ void Table::GenerateScan(CodeGen &codegen, llvm::Value *table_ptr, llvm::Value *column_layouts = codegen.AllocateBuffer( ColumnLayoutInfoProxy::GetType(codegen), num_columns, "columnLayout"); - // Allocate some space for the parsed predicates (if need be!) - llvm::Value *predicate_array = - codegen.NullPtr(PredicateInfoProxy::GetType(codegen)->getPointerTo()); - if (num_predicates != 0) { - predicate_array = codegen.AllocateBuffer( - PredicateInfoProxy::GetType(codegen), num_predicates, "predicateInfo"); - codegen.Call(RuntimeFunctionsProxy::FillPredicateArray, - {predicate_ptr, predicate_array}); - } - // Get the number of tile groups in the given table llvm::Value *tile_group_idx = codegen.Const64(0); llvm::Value *num_tile_groups = GetTileGroupCount(codegen, table_ptr); @@ -105,7 +95,7 @@ void Table::GenerateScan(CodeGen &codegen, llvm::Value *table_ptr, // Check zone map llvm::Value *cond = codegen.Call( ZoneMapManagerProxy::ShouldScanTileGroup, - {GetZoneMapManager(codegen), predicate_array, + {GetZoneMapManager(codegen), predicate_ptr, codegen.Const32(num_predicates), table_ptr, tile_group_idx}); codegen::lang::If should_scan_tilegroup{codegen, cond}; diff --git a/src/include/catalog/abstract_catalog.h b/src/include/catalog/abstract_catalog.h index e0c8d81df53..10d85f50bd3 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() {} @@ -56,28 +64,118 @@ class AbstractCatalog { //===--------------------------------------------------------------------===// // Helper Functions //===--------------------------------------------------------------------===// + + /*@brief insert tuple(reord) helper function + * @param tuple tuple to be inserted + * @param txn TransactionContext + * @return Whether insertion is Successful + */ bool InsertTuple(std::unique_ptr tuple, concurrency::TransactionContext *txn); + /*@brief insert tuple(reord) using compiled plan + * @param insert_values tuples to be inserted + * @param txn TransactionContext + * @return Whether insertion is Successful + */ + bool InsertTupleWithCompiledPlan(const std::vector>> *insert_values, + concurrency::TransactionContext *txn); + + /*@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 DeleteWithIndexScan(oid_t index_offset, std::vector values, concurrency::TransactionContext *txn); + /*@brief Delete a tuple using sequential scan + * @param column_offsets Offset of seq scan + * @param predicate Predicate used in the seq scan + * @param txn TransactionContext + * @return Whether deletion is Successful + */ + bool DeleteWithCompiledSeqScan( + std::vector column_offsets, + expression::AbstractExpression *predicate, + concurrency::TransactionContext *txn); + + /*@brief Index scan helper function + * @param column_offsets Column ids for search (projection) + * @param index_offset Offset of index for scan + * @param values Values for search + * @param txn TransactionContext + * @return Unique pointer of vector of logical tiles + */ std::unique_ptr>> GetResultWithIndexScan(std::vector column_offsets, oid_t index_offset, std::vector values, concurrency::TransactionContext *txn) const; + /*@brief Sequential scan helper function + * NOTE: try to use efficient index scan instead of sequential scan, but you + * shouldn't build too many indexes on one catalog table + * @param column_offsets Column ids for search (projection) + * @param predicate predicate for this sequential scan query + * @param txn TransactionContext + * + * @return Unique pointer of vector of logical tiles + */ std::unique_ptr>> GetResultWithSeqScan(std::vector column_offsets, expression::AbstractExpression *predicate, concurrency::TransactionContext *txn); + /*@brief Complied Sequential scan helper function + * This is faster than the index scan as long as the query plan is cached + * @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 GetResultWithCompiledSeqScan( + std::vector column_offsets, + expression::AbstractExpression *predicate, + concurrency::TransactionContext *txn) const; + + /*@brief Update specific columns using compiled sequential scan + * @param update_columns Columns to be updated + * @param update_values Values to be updated + * @param column_offsets columns used for seq scan + * @param predicate Predicate used in the seq scan + * @return true if successfully executes + */ bool UpdateWithIndexScan(std::vector update_columns, std::vector update_values, std::vector scan_values, oid_t index_offset, concurrency::TransactionContext *txn); + /*@brief Update specific columns using index scan + * @param update_columns Columns to be updated + * @param update_values Values to be updated + * @param scan_values Value to be scaned (used in index scan) + * @param index_offset Offset of index for scan + * @return true if successfully executes + */ + bool UpdateWithCompiledSeqScan( std::vector update_columns, + std::vector update_values, + std::vector column_offsets, + expression::AbstractExpression *predicate, + concurrency::TransactionContext *txn); + + /*@brief Add index on catalog table + * @param key_attrs indexed column offset(position) + * @param index_oid index id(global unique) + * @param index_name index name(global unique) + * @param index_constraint index constraints + * @return Unique pointer of vector of logical tiles + * Note: Use catalog::Catalog::CreateIndex() if you can, only ColumnCatalog and + * IndexCatalog should need this + */ 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 7dcdf96e4a5..af27f39b9c9 100644 --- a/src/include/catalog/column_catalog.h +++ b/src/include/catalog/column_catalog.h @@ -40,7 +40,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; } 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 cc097414931..163e5af4dba 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; @@ -42,7 +41,7 @@ class DatabaseCatalogObject { friend class CatalogCache; public: - DatabaseCatalogObject(executor::LogicalTile *tile, + DatabaseCatalogObject(codegen::WrappedTuple &wrapped_tuple, concurrency::TransactionContext *txn); void EvictAllTableObjects(); 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 3ece01952b9..3dd7780ccbb 100644 --- a/src/include/catalog/index_catalog.h +++ b/src/include/catalog/index_catalog.h @@ -44,7 +44,7 @@ class IndexCatalogObject { friend class TableCatalogObject; 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; } @@ -94,7 +94,6 @@ class IndexCatalog : public AbstractCatalog { const std::string &index_name, const std::string &schema_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 7b806623565..71f92155664 100644 --- a/src/include/catalog/index_metrics_catalog.h +++ b/src/include/catalog/index_metrics_catalog.h @@ -52,6 +52,7 @@ class IndexMetricsCatalog : public AbstractCatalog { bool DeleteIndexMetrics(oid_t index_oid, concurrency::TransactionContext *txn); + //===--------------------------------------------------------------------===// // Read-only Related API //===--------------------------------------------------------------------===// @@ -68,6 +69,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..c55211c004e 100644 --- a/src/include/catalog/language_catalog.h +++ b/src/include/catalog/language_catalog.h @@ -38,7 +38,7 @@ namespace catalog { class LanguageCatalogObject { public: - LanguageCatalogObject(executor::LogicalTile *tuple); + LanguageCatalogObject(codegen::WrappedTuple &tuple); oid_t GetOid() const { return lang_oid_; } @@ -54,7 +54,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..7ea7bc4f214 100644 --- a/src/include/catalog/proc_catalog.h +++ b/src/include/catalog/proc_catalog.h @@ -41,8 +41,8 @@ class LanguageCatalogObject; //===----------------------------------------------------------------------===// class ProcCatalogObject { public: - ProcCatalogObject(executor::LogicalTile *tile, concurrency::TransactionContext *txn); - + ProcCatalogObject(codegen::WrappedTuple &wrapped_tuple, + concurrency::TransactionContext *txn); // Accessors oid_t GetOid() const { return oid_; } @@ -80,7 +80,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 a8045fd94e1..a57837dae68 100644 --- a/src/include/catalog/query_metrics_catalog.h +++ b/src/include/catalog/query_metrics_catalog.h @@ -88,7 +88,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: enum IndexId { PRIMARY_KEY = 0, // Add new indexes here in creation order diff --git a/src/include/catalog/schema.h b/src/include/catalog/schema.h index 43a62d6444f..2b3e3b820f7 100644 --- a/src/include/catalog/schema.h +++ b/src/include/catalog/schema.h @@ -194,7 +194,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/schema_catalog.h b/src/include/catalog/schema_catalog.h index 2d9e06693d7..2a49112a766 100644 --- a/src/include/catalog/schema_catalog.h +++ b/src/include/catalog/schema_catalog.h @@ -35,7 +35,7 @@ class SchemaCatalogObject { friend class DatabaseCatalogObject; public: - SchemaCatalogObject(executor::LogicalTile *tile, + SchemaCatalogObject(codegen::WrappedTuple &wrapped_tuple, concurrency::TransactionContext *txn); inline oid_t GetSchemaOid() { return schema_oid; } 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 9a01ee6e07f..7620ec459b9 100644 --- a/src/include/catalog/table_catalog.h +++ b/src/include/catalog/table_catalog.h @@ -53,8 +53,8 @@ class TableCatalogObject { friend class LayoutCatalog; public: - TableCatalogObject(executor::LogicalTile *tile, - concurrency::TransactionContext *txn, int tupleId = 0); + TableCatalogObject(codegen::WrappedTuple &wrapped_tuple, + concurrency::TransactionContext *txn); public: // Get indexes @@ -153,6 +153,7 @@ class TableCatalog : public AbstractCatalog { ~TableCatalog(); + 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 38c59a76857..5c7a93d0d16 100644 --- a/src/include/catalog/table_metrics_catalog.h +++ b/src/include/catalog/table_metrics_catalog.h @@ -52,6 +52,7 @@ class TableMetricsCatalog : public AbstractCatalog { bool DeleteTableMetrics(oid_t table_oid, concurrency::TransactionContext *txn); + //===--------------------------------------------------------------------===// // Read-only Related API //===--------------------------------------------------------------------===// @@ -68,6 +69,8 @@ class TableMetricsCatalog : public AbstractCatalog { // Add new columns here in creation order }; + std::vector all_column_ids = {0, 1, 2, 3, 4, 5}; + 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 6b71792e42c..fd45a94c7bb 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_oid // 2: tgname : trigger_name -// 3: tgfoid : function_oid +// 3: tgfname : function_name // 4: tgtype : trigger_type // 5: tgargs : function_arguemnts // 6: tgqual : fire_condition @@ -51,6 +51,7 @@ class TriggerCatalog : public AbstractCatalog { concurrency::TransactionContext *txn); ~TriggerCatalog(); + //===--------------------------------------------------------------------===// // write Related API //===--------------------------------------------------------------------===// @@ -88,7 +89,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, @@ -98,6 +99,8 @@ class TriggerCatalog : public AbstractCatalog { private: 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/include/codegen/proxy/zone_map_proxy.h b/src/include/codegen/proxy/zone_map_proxy.h index 7d3ebb36749..147dc6c42bb 100644 --- a/src/include/codegen/proxy/zone_map_proxy.h +++ b/src/include/codegen/proxy/zone_map_proxy.h @@ -19,7 +19,9 @@ #include "concurrency/transaction_context.h" #include "codegen/proxy/value_proxy.h" #include "codegen/proxy/transaction_context_proxy.h" +#include "codegen/proxy/runtime_functions_proxy.h" #include "codegen/proxy/data_table_proxy.h" +#include "expression/abstract_expression.h" #include "type/value.h" namespace peloton { diff --git a/src/include/expression/abstract_expression.h b/src/include/expression/abstract_expression.h index ff65f21244d..a3aefa35b25 100644 --- a/src/include/expression/abstract_expression.h +++ b/src/include/expression/abstract_expression.h @@ -82,6 +82,12 @@ class AbstractExpression : public Printable { virtual type::Value Evaluate(const AbstractTuple *tuple1, const AbstractTuple *tuple2, executor::ExecutorContext *context) const = 0; + /* + * Upon deletion, specifically clears the parsed_predicates + */ +// ~AbstractExpression(){ +// parsed_predicates.clear(); +// } /** * Return true if this expression or any descendent has a value that should be diff --git a/src/include/storage/zone_map_manager.h b/src/include/storage/zone_map_manager.h index 50b436087ee..bfe6c441cfe 100644 --- a/src/include/storage/zone_map_manager.h +++ b/src/include/storage/zone_map_manager.h @@ -62,7 +62,7 @@ class ZoneMapManager { std::unique_ptr GetZoneMapFromCatalog( oid_t database_id, oid_t table_id, oid_t tile_group_id, oid_t col_itr); - bool ShouldScanTileGroup(storage::PredicateInfo *parsed_predicates, + bool ShouldScanTileGroup(expression::AbstractExpression * predicate_ptr, int32_t num_predicates, storage::DataTable *table, int64_t tile_group_id); diff --git a/src/include/type/value.h b/src/include/type/value.h index 235fb76fa3d..311de2e7843 100644 --- a/src/include/type/value.h +++ b/src/include/type/value.h @@ -87,7 +87,7 @@ class Value : public Printable { std::swap(first.type_id_, second.type_id_); } - Value &operator=(Value other); + Value &operator=( Value other); // Get the type of this value inline TypeId GetTypeId() const { return type_id_; } diff --git a/src/storage/zone_map_manager.cpp b/src/storage/zone_map_manager.cpp index 81765df3094..01f494b7d5d 100644 --- a/src/storage/zone_map_manager.cpp +++ b/src/storage/zone_map_manager.cpp @@ -197,13 +197,18 @@ ZoneMapManager::GetResultVectorAsZoneMap( * False if tile group can be skipped. */ bool ZoneMapManager::ShouldScanTileGroup( - storage::PredicateInfo *parsed_predicates, int32_t num_predicates, + expression::AbstractExpression * predicate_ptr, 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; - int comparison_operator = parsed_predicates[i].comparison_operator; - type::Value predicate_value = parsed_predicates[i].predicate_value; + auto parsed_predicates = predicate_ptr->GetParsedPredicates(); + int col_id = (*parsed_predicates)[i].col_id; + int comparison_operator = (*parsed_predicates)[i].comparison_operator; + type::Value predicate_value = (*parsed_predicates)[i].predicate_value; oid_t database_id = table->GetDatabaseOid(); oid_t table_id = table->GetOid(); diff --git a/test/catalog/catalog_test.cpp b/test/catalog/catalog_test.cpp index 36af866b958..e29bd039db1 100644 --- a/test/catalog/catalog_test.cpp +++ b/test/catalog/catalog_test.cpp @@ -25,6 +25,7 @@ #include "sql/testing_sql_util.h" #include "storage/storage_manager.h" #include "type/ephemeral_pool.h" +#include "common/timer.h" namespace peloton { namespace test { @@ -51,7 +52,7 @@ TEST_F(CatalogTests, BootstrappingCatalog) { EXPECT_NE(nullptr, database); EXPECT_NE(nullptr, db_metric_table); } -// + TEST_F(CatalogTests, CreatingDatabase) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); @@ -62,6 +63,39 @@ TEST_F(CatalogTests, CreatingDatabase) { txn_manager.CommitTransaction(txn); } +/** + * Create and drop the same table in the same transaction + */ +TEST_F(CatalogTests, CreateThenDropTable) { + auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); + auto txn = txn_manager.BeginTransaction(); + auto id_column = catalog::Column( + type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER), + "id", true); + id_column.AddConstraint( + catalog::Constraint(ConstraintType::PRIMARY, "primary_key")); + auto name_column = catalog::Column(type::TypeId::VARCHAR, 32, "name", true); + + std::unique_ptr table_schema( + new catalog::Schema({id_column, name_column})); + + catalog::Catalog::GetInstance()->CreateTable( + "emp_db", DEFAULT_SCHEMA_NAME, "emp_table", std::move(table_schema), txn); + + auto table_object = catalog::Catalog::GetInstance()->GetTableObject( + "emp_db", DEFAULT_SCHEMA_NAME, "emp_table", txn); + + EXPECT_NE(table_object, nullptr); + EXPECT_EQ(table_object->GetTableName(), "emp_table"); + + catalog::Catalog::GetInstance()->DropTable("emp_db", DEFAULT_SCHEMA_NAME, + "emp_table", txn); + EXPECT_THROW(catalog::Catalog::GetInstance()->DropTable( + "emp_db", DEFAULT_SCHEMA_NAME, "department_table", txn), + CatalogException); + txn_manager.CommitTransaction(txn); +} + TEST_F(CatalogTests, CreatingTable) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); @@ -128,6 +162,7 @@ TEST_F(CatalogTests, TableObject) { "emp_db", DEFAULT_SCHEMA_NAME, "department_table", txn); auto index_objects = table_object->GetIndexObjects(); + 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 125517dc9fe..747e7d0fc73 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 = @@ -207,6 +230,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) { int CACHE_USED_BY_CATALOG = codegen::QueryCache::Instance().GetCount(); diff --git a/test/codegen/testing_codegen_util.cpp b/test/codegen/testing_codegen_util.cpp index ff05144978b..1351a15390e 100644 --- a/test/codegen/testing_codegen_util.cpp +++ b/test/codegen/testing_codegen_util.cpp @@ -346,6 +346,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 8234dfb0d2b..2fc5e5a5b20 100644 --- a/test/include/codegen/testing_codegen_util.h +++ b/test/include/codegen/testing_codegen_util.h @@ -111,6 +111,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 92949cc8521..b7606143ff6 100644 --- a/test/optimizer/old_optimizer_test.cpp +++ b/test/optimizer/old_optimizer_test.cpp @@ -12,6 +12,8 @@ #include "binder/bind_node_visitor.h" #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" @@ -173,6 +175,7 @@ TEST_F(OldOptimizerTests, UpdateDelWithIndexScanTest) { auto target_table_ = catalog::Catalog::GetInstance()->GetTableWithName( DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, "department_table", txn); // Expected 1 , Primary key index + created index + EXPECT_EQ(target_table_->GetIndexCount(), 2); txn_manager.CommitTransaction(txn); diff --git a/test/storage/zone_map_test.cpp b/test/storage/zone_map_test.cpp index f075eda2f5a..fc11550047b 100644 --- a/test/storage/zone_map_test.cpp +++ b/test/storage/zone_map_test.cpp @@ -221,10 +221,9 @@ TEST_F(ZoneMapTests, ZoneMapIntegerEqualityPredicateTest) { storage::ZoneMapManager *zone_map_manager = storage::ZoneMapManager::GetInstance(); oid_t num_tile_groups = (data_table.get())->GetTileGroupCount(); - auto temp = (std::vector *)parsed_predicates; for (oid_t i = 0; i < num_tile_groups - 1; i++) { bool result = zone_map_manager->ShouldScanTileGroup( - temp->data(), 1, data_table.get(), i); + pred, 1, data_table.get(), i); if (i == 0) { EXPECT_EQ(result, true); } else { @@ -249,10 +248,9 @@ TEST_F(ZoneMapTests, ZoneMapIntegerLessThanPredicateTest) { storage::ZoneMapManager *zone_map_manager = storage::ZoneMapManager::GetInstance(); oid_t num_tile_groups = (data_table.get())->GetTileGroupCount(); - auto temp = (std::vector *)parsed_predicates; for (oid_t i = 0; i < num_tile_groups - 1; i++) { bool result = zone_map_manager->ShouldScanTileGroup( - temp->data(), 1, data_table.get(), i); + pred, 1, data_table.get(), i); if (i <= 1) { EXPECT_EQ(result, true); } else { @@ -277,10 +275,9 @@ TEST_F(ZoneMapTests, ZoneMapIntegerGreaterThanPredicateTest) { storage::ZoneMapManager *zone_map_manager = storage::ZoneMapManager::GetInstance(); oid_t num_tile_groups = (data_table.get())->GetTileGroupCount(); - auto temp = (std::vector *)parsed_predicates; for (oid_t i = 0; i < num_tile_groups - 1; i++) { bool result = zone_map_manager->ShouldScanTileGroup( - temp->data(), 1, data_table.get(), i); + pred, 1, data_table.get(), i); if (i <= 2) { EXPECT_EQ(result, false); } else { @@ -313,10 +310,9 @@ TEST_F(ZoneMapTests, ZoneMapIntegerConjunctionPredicateTest) { storage::ZoneMapManager *zone_map_manager = storage::ZoneMapManager::GetInstance(); oid_t num_tile_groups = (data_table.get())->GetTileGroupCount(); - auto temp = (std::vector *)parsed_predicates; for (oid_t i = 0; i < num_tile_groups - 1; i++) { bool result = zone_map_manager->ShouldScanTileGroup( - temp->data(), 2, data_table.get(), i); + conj_pred, 2, data_table.get(), i); if (i == 0 || i == 3) { EXPECT_EQ(result, false); } else { @@ -351,10 +347,9 @@ TEST_F(ZoneMapTests, ZoneMapDecimalConjunctionPredicateTest) { storage::ZoneMapManager *zone_map_manager = storage::ZoneMapManager::GetInstance(); oid_t num_tile_groups = (data_table.get())->GetTileGroupCount(); - auto temp = (std::vector *)parsed_predicates; for (oid_t i = 0; i < num_tile_groups - 1; i++) { bool result = zone_map_manager->ShouldScanTileGroup( - temp->data(), 2, data_table.get(), i); + conj_pred, 2, data_table.get(), i); if (i < 3) { EXPECT_EQ(result, false); } else { @@ -399,10 +394,9 @@ TEST_F(ZoneMapTests, ZoneMapMultiColumnConjunctionPredicateTest) { storage::ZoneMapManager *zone_map_manager = storage::ZoneMapManager::GetInstance(); oid_t num_tile_groups = (data_table.get())->GetTileGroupCount(); - auto temp = (std::vector *)parsed_predicates; for (oid_t i = 0; i < num_tile_groups - 1; i++) { bool result = zone_map_manager->ShouldScanTileGroup( - temp->data(), 4, data_table.get(), i); + conj_pred, 4, data_table.get(), i); if (i == 2) { EXPECT_EQ(result, true); } else { diff --git a/test/trigger/trigger_test.cpp b/test/trigger/trigger_test.cpp index c9c5b238ca3..41908746de4 100644 --- a/test/trigger/trigger_test.cpp +++ b/test/trigger/trigger_test.cpp @@ -151,7 +151,7 @@ class TriggerTests : public PelotonTest { DEFAULT_DB_NAME, DEFAULT_SCHEMA_NAME, 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()); } };