[15721] Pre-compiled catalog access

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"
@@ -235,6 +237,57 @@ AbstractCatalog::GetResultWithSeqScan(std::vector<oid_t> column_offsets,
   return result_tiles;
 }
 
+/*@brief   Complied Sequential scan helper function
+* NOTE: try to use efficient index scan instead of sequential scan, but you
+* shouldn't build too many indexes on one catalog table
+* @param   column_offsets    Column ids for search (projection)
+* @param   predicate         predicate for this sequential scan query
+* @param   txn               TransactionContext
+*
+* @return  Unique pointer of vector of logical tiles
+*/
+std::vector<codegen::WrappedTuple>
+AbstractCatalog::GetResultWithCompiledSeqScan(
+    std::vector<oid_t> 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<planner::SeqScanPlan>(
+      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::ExecutorContext> executor_context(
+      new executor::ExecutorContext(txn, std::move(parameters)));
+
+  // search for query
+  codegen::Query *query = codegen::QueryCache::Instance().Find(plan_ptr);
+  std::unique_ptr<codegen::Query> compiled_query(nullptr);
+  // cached = (query != nullptr);
+  cached = false;
+  // LOG_DEBUG("cache %d", cached);
+  // if not cached, compile the query and save it into cache
+  if (!cached) {
+    compiled_query = codegen::QueryCompiler().Compile(
+        *plan_ptr, executor_context->GetParams().GetQueryParametersMap(),
+        buffer);
+    query = compiled_query.get();
+    codegen::QueryCache::Instance().Add(plan_ptr, std::move(compiled_query));
+  }
+
+  query->Execute(std::move(executor_context), buffer,
+                 [](executor::ExecutionResult result) { return result; });
+
+  return buffer.GetOutputTuples();
+}
+
 /*@brief   Add index on catalog table
 * @param   key_attrs    indexed column offset(position)
 * @param   index_oid    index id(global unique)

src/catalog/catalog.cpp

@@ -148,12 +148,12 @@ void Catalog::Bootstrap() {
   DatabaseMetricsCatalog::GetInstance(txn);
   TableMetricsCatalog::GetInstance(txn);
   IndexMetricsCatalog::GetInstance(txn);
-  QueryMetricsCatalog::GetInstance(txn);  
+  QueryMetricsCatalog::GetInstance(txn);
   SettingsCatalog::GetInstance(txn);
   TriggerCatalog::GetInstance(txn);
   LanguageCatalog::GetInstance(txn);
   ProcCatalog::GetInstance(txn);
-  
+
   if (settings::SettingsManager::GetBool(settings::SettingId::brain)) {
     QueryHistoryCatalog::GetInstance(txn);
   }
@@ -552,14 +552,14 @@ ResultType Catalog::DropTable(const std::string &database_name,
  */
 ResultType Catalog::DropTable(oid_t database_oid, oid_t table_oid,
                               concurrency::TransactionContext *txn) {
-  LOG_TRACE("Dropping table %d from database %d", database_oid, table_oid);
+  LOG_WARN("Dropping table %d from database %d", database_oid, table_oid);
   auto storage_manager = storage::StorageManager::GetInstance();
   auto database = storage_manager->GetDatabaseWithOid(database_oid);
   auto database_object =
       DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn);
   auto table_object = database_object->GetTableObject(table_oid);
   auto index_objects = table_object->GetIndexObjects();
-  LOG_TRACE("dropping #%d indexes", (int)index_objects.size());
+  LOG_WARN("dropping #%d indexes", (int)index_objects.size());
 
   for (auto it : index_objects) DropIndex(it.second->GetIndexOid(), txn);
   ColumnCatalog::GetInstance()->DeleteColumns(table_oid, txn);
@@ -614,18 +614,18 @@ ResultType Catalog::DropIndex(oid_t index_oid,
 
 ResultType Catalog::DropIndex(const std::string &index_name,
                               concurrency::TransactionContext *txn) {
-    if(txn == nullptr) {
-        throw CatalogException("Do not have transaction to drop index " +
-                               index_name);
-    }
-    auto index_object = catalog::IndexCatalog::GetInstance()->GetIndexObject(
-                index_name, txn);
-    if(index_object == nullptr) {
-        throw CatalogException("Index name " + index_name + " cannot be found");
-    }
-    ResultType result = DropIndex(index_object->GetIndexOid(), txn);
+  if (txn == nullptr) {
+    throw CatalogException("Do not have transaction to drop index " +
+                           index_name);
+  }
+  auto index_object =
+      catalog::IndexCatalog::GetInstance()->GetIndexObject(index_name, txn);
+  if (index_object == nullptr) {
+    throw CatalogException("Index name " + index_name + " cannot be found");
+  }
+  ResultType result = DropIndex(index_object->GetIndexOid(), txn);
 
-    return result;
+  return result;
 }
 
 //===--------------------------------------------------------------------===//
@@ -1064,11 +1064,11 @@ void Catalog::InitializeFunctions() {
       /**
        * decimal functions
        */
-      AddBuiltinFunction(
-          "abs", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang,
-          "Abs", function::BuiltInFuncType{OperatorId::Abs,
-                                            function::DecimalFunctions::_Abs},
-          txn);
+      AddBuiltinFunction("abs", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL,
+                         internal_lang, "Abs",
+                         function::BuiltInFuncType{
+                             OperatorId::Abs, function::DecimalFunctions::_Abs},
+                         txn);
       AddBuiltinFunction(
           "sqrt", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang,
           "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt,
@@ -1105,33 +1105,29 @@ void Catalog::InitializeFunctions() {
       /**
        * integer functions
        */
-      AddBuiltinFunction(
-          "abs", {type::TypeId::TINYINT}, type::TypeId::TINYINT, 
-          internal_lang, "Abs",
-          function::BuiltInFuncType{OperatorId::Abs,
-                                    function::DecimalFunctions::_Abs},
-          txn);
+      AddBuiltinFunction("abs", {type::TypeId::TINYINT}, type::TypeId::TINYINT,
+                         internal_lang, "Abs",
+                         function::BuiltInFuncType{
+                             OperatorId::Abs, function::DecimalFunctions::_Abs},
+                         txn);
 
-      AddBuiltinFunction(
-          "abs", {type::TypeId::SMALLINT}, type::TypeId::SMALLINT, 
-          internal_lang, "Abs",
-          function::BuiltInFuncType{OperatorId::Abs,
-                                    function::DecimalFunctions::_Abs},
-          txn);
+      AddBuiltinFunction("abs", {type::TypeId::SMALLINT},
+                         type::TypeId::SMALLINT, internal_lang, "Abs",
+                         function::BuiltInFuncType{
+                             OperatorId::Abs, function::DecimalFunctions::_Abs},
+                         txn);
 
-      AddBuiltinFunction(
-          "abs", {type::TypeId::INTEGER}, type::TypeId::INTEGER, 
-          internal_lang, "Abs",
-          function::BuiltInFuncType{OperatorId::Abs,
-                                    function::DecimalFunctions::_Abs},
-          txn);
+      AddBuiltinFunction("abs", {type::TypeId::INTEGER}, type::TypeId::INTEGER,
+                         internal_lang, "Abs",
+                         function::BuiltInFuncType{
+                             OperatorId::Abs, function::DecimalFunctions::_Abs},
+                         txn);
 
-      AddBuiltinFunction(
-          "abs", {type::TypeId::BIGINT}, type::TypeId::BIGINT, 
-          internal_lang, "Abs",
-          function::BuiltInFuncType{OperatorId::Abs,
-                                    function::DecimalFunctions::_Abs},
-          txn);
+      AddBuiltinFunction("abs", {type::TypeId::BIGINT}, type::TypeId::BIGINT,
+                         internal_lang, "Abs",
+                         function::BuiltInFuncType{
+                             OperatorId::Abs, function::DecimalFunctions::_Abs},
+                         txn);
 
       AddBuiltinFunction(
           "floor", {type::TypeId::INTEGER}, type::TypeId::DECIMAL,

src/catalog/column_catalog.cpp

@@ -11,11 +11,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "catalog/column_catalog.h"
-#include "concurrency/transaction_context.h"
 
 #include "catalog/table_catalog.h"
+#include "codegen/buffering_consumer.h"
+#include "concurrency/transaction_context.h"
 #include "storage/data_table.h"
 #include "type/value_factory.h"
+#include "expression/expression_util.h"
 
 namespace peloton {
 namespace catalog {
@@ -41,9 +43,29 @@ ColumnCatalogObject::ColumnCatalogObject(executor::LogicalTile *tile,
       is_not_null(tile->GetValue(tupleId, ColumnCatalog::ColumnId::IS_NOT_NULL)
                       .GetAs<bool>()) {}
 
-ColumnCatalog *ColumnCatalog::GetInstance(storage::Database *pg_catalog,
-                                          type::AbstractPool *pool,
-                                          concurrency::TransactionContext *txn) {
+ColumnCatalogObject::ColumnCatalogObject(codegen::WrappedTuple wrapped_tuple)
+    : table_oid(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::TABLE_OID)
+                    .GetAs<oid_t>()),
+      column_name(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_NAME)
+                      .ToString()),
+      column_id(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_ID)
+                    .GetAs<oid_t>()),
+      column_offset(
+          wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_OFFSET)
+              .GetAs<oid_t>()),
+      column_type(StringToTypeId(
+          wrapped_tuple.GetValue(ColumnCatalog::ColumnId::COLUMN_TYPE)
+              .ToString())),
+      is_inlined(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_INLINED)
+                     .GetAs<bool>()),
+      is_primary(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_PRIMARY)
+                     .GetAs<bool>()),
+      is_not_null(wrapped_tuple.GetValue(ColumnCatalog::ColumnId::IS_NOT_NULL)
+                      .GetAs<bool>()) {}
+
+ColumnCatalog *ColumnCatalog::GetInstance(
+    storage::Database *pg_catalog, type::AbstractPool *pool,
+    concurrency::TransactionContext *txn) {
   static ColumnCatalog column_catalog{pg_catalog, pool, txn};
   return &column_catalog;
 }
@@ -232,19 +254,24 @@ ColumnCatalog::GetColumnObjects(oid_t table_oid,
 
   // cache miss, get from pg_attribute
   std::vector<oid_t> column_ids(all_column_ids);
-  oid_t index_offset = IndexId::SKEY_TABLE_OID;  // Index of table_oid
-  std::vector<type::Value> 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<ColumnCatalogObject>(tile.get(), tuple_id);
-      table_object->InsertColumnObject(column_object);
-    }
+  expression::AbstractExpression *tb_oid_expr =
+      expression::ExpressionUtil::TupleValueFactory(type::TypeId::INTEGER, 0,
+                                                    ColumnId::TABLE_OID);
+  expression::AbstractExpression *tb_oid_const_expr =
+      expression::ExpressionUtil::ConstantValueFactory(
+          type::ValueFactory::GetIntegerValue(table_oid).Copy());
+  expression::AbstractExpression *col_oid_equality_expr =
+      expression::ExpressionUtil::ComparisonFactory(
+          ExpressionType::COMPARE_EQUAL, tb_oid_expr, tb_oid_const_expr);
+
+  expression::AbstractExpression *predicate = col_oid_equality_expr;
+  std::vector<codegen::WrappedTuple> result_tuples =
+      GetResultWithCompiledSeqScan(column_ids, predicate, txn);
+
+  for (auto tuple : result_tuples) {
+    auto column_object = std::make_shared<ColumnCatalogObject>(tuple);
+    table_object->InsertColumnObject(column_object);
   }
 
   return table_object->GetColumnObjects();