Peloton Brain Recommended Indexes (#1274)

* need to work on 'SELECT' statements

* tests passed for UPDATE, INSERT, DELETE & still need work on SELECT

* SELECT half-way & code optimization

* finished SELECT, but only works on 1 table & need to implement triplet and priority stuff

* predicates in scanning node handled, need priority sorting & triplet

* triplet added

* priority sorting finished

* added comments & code improvement

* modified as suggested in PR review

* added binder, now passing tests

* fixed include validation error

* fixed pointer issue

* try to fix memory leak issue

Author: Blade-Lee

src/include/planner/plan_util.h

@@ -14,6 +14,7 @@
 
 #include <set>
 #include <string>
+#include <tuple>
 
 #include "planner/abstract_plan.h"
 #include "planner/abstract_scan_plan.h"
@@ -35,6 +36,7 @@ class SQLStatement;
 }  // namespace parser
 
 namespace planner {
+typedef std::tuple<oid_t, oid_t, oid_t> col_triplet;
 
 class PlanUtil {
  public:
@@ -63,6 +65,18 @@ class PlanUtil {
       catalog::CatalogCache &catalog_cache,
       const parser::SQLStatement &sql_stmt);
 
+  /**
+  * @brief Get the columns affected by a given query
+  * @param CatalogCache
+  * @param SQLStatementList
+  * @param DBName
+  * @return vector of affected column ids with triplet format
+  */
+  static const std::vector<col_triplet> GetIndexableColumns(
+      catalog::CatalogCache &catalog_cache,
+      std::unique_ptr<parser::SQLStatementList> sql_stmt_list,
+      const std::string &db_name);
+
  private:
   ///
   /// Helpers for GetInfo() and GetTablesReferenced()

src/planner/plan_util.cpp

@@ -10,19 +10,24 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "planner/plan_util.h"
 #include <set>
 #include <string>
-
 #include "catalog/catalog_cache.h"
 #include "catalog/column_catalog.h"
 #include "catalog/database_catalog.h"
 #include "catalog/index_catalog.h"
 #include "catalog/table_catalog.h"
+#include "common/statement.h"
+#include "concurrency/transaction_manager_factory.h"
+#include "expression/abstract_expression.h"
+#include "expression/expression_util.h"
+#include "optimizer/abstract_optimizer.h"
+#include "optimizer/optimizer.h"
 #include "parser/delete_statement.h"
 #include "parser/insert_statement.h"
 #include "parser/sql_statement.h"
 #include "parser/update_statement.h"
-#include "planner/plan_util.h"
 #include "util/set_util.h"
 
 namespace peloton {
@@ -96,5 +101,98 @@ const std::set<oid_t> PlanUtil::GetAffectedIndexes(
   return (index_oids);
 }
 
+const std::vector<col_triplet> PlanUtil::GetIndexableColumns(
+    catalog::CatalogCache &catalog_cache,
+    std::unique_ptr<parser::SQLStatementList> sql_stmt_list,
+    const std::string &db_name) {
+  std::vector<col_triplet> column_oids;
+  std::string table_name;
+  oid_t database_id, table_id;
+
+  // Assume that there is only one SQLStatement in the list
+  auto sql_stmt = sql_stmt_list->GetStatement(0);
+  switch (sql_stmt->GetType()) {
+    // 1) use optimizer to get the plan tree
+    // 2) aggregate results from all the leaf scan nodes
+    case StatementType::UPDATE:
+      PELOTON_FALLTHROUGH;
+    case StatementType::DELETE:
+      PELOTON_FALLTHROUGH;
+    case StatementType::SELECT: {
+      std::unique_ptr<optimizer::AbstractOptimizer> optimizer =
+          std::unique_ptr<optimizer::AbstractOptimizer>(
+              new optimizer::Optimizer());
+
+      auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
+      auto txn = txn_manager.BeginTransaction();
+
+      try {
+        auto plan = optimizer->BuildPelotonPlanTree(sql_stmt_list, txn);
+
+        auto db_object = catalog_cache.GetDatabaseObject(db_name);
+        database_id = db_object->GetDatabaseOid();
+
+        // Perform a breadth first search on plan tree
+        std::queue<const AbstractPlan *> scan_queue;
+        const AbstractPlan *temp_ptr;
+        scan_queue.emplace(plan.get());
+
+        while (!scan_queue.empty()) {
+          temp_ptr = scan_queue.front();
+          scan_queue.pop();
+
+          // Leaf scanning node
+          if (PlanNodeType::SEQSCAN == temp_ptr->GetPlanNodeType() ||
+              PlanNodeType::INDEXSCAN == temp_ptr->GetPlanNodeType()) {
+            auto temp_scan_ptr = static_cast<const AbstractScan *>(temp_ptr);
+
+            table_id = temp_scan_ptr->GetTable()->GetOid();
+
+            // Aggregate columns scanned in predicates
+            ExprSet expr_set;
+            auto predicate_ptr = temp_scan_ptr->GetPredicate();
+            std::unique_ptr<expression::AbstractExpression> copied_predicate;
+            if (nullptr == predicate_ptr) {
+              copied_predicate = nullptr;
+            } else {
+              copied_predicate =
+                  std::unique_ptr<expression::AbstractExpression>(
+                      predicate_ptr->Copy());
+            }
+            expression::ExpressionUtil::GetTupleValueExprs(
+                expr_set, copied_predicate.get());
+
+            for (const auto expr : expr_set) {
+              auto tuple_value_expr =
+                  static_cast<const expression::TupleValueExpression *>(expr);
+
+              table_id =
+                  db_object->GetTableObject(tuple_value_expr->GetTableName())
+                      ->GetTableOid();
+              column_oids.emplace_back(database_id, table_id,
+                                       (oid_t)tuple_value_expr->GetColumnId());
+            }
+
+          } else {
+            for (uint32_t idx = 0; idx < temp_ptr->GetChildrenSize(); ++idx) {
+              scan_queue.emplace(temp_ptr->GetChild(idx));
+            }
+          }
+        }
+
+      } catch (Exception &e) {
+        LOG_ERROR("Error in BuildPelotonPlanTree: %s", e.what());
+      }
+
+      // TODO: should transaction commit or not?
+      txn_manager.AbortTransaction(txn);
+    } break;
+    default:
+      LOG_TRACE("Return nothing for query type: %d",
+                static_cast<int>(sql_stmt->GetType()));
+  }
+  return (column_oids);
+}
+
 }  // namespace planner
 }  // namespace peloton