IndexScanDesc and IndexScanPlan Refactoring (#1301)

* Refactor some member variable and function names.

* Fixes for the changed API.

* HybridScanExecutor and tpcc_payment fix.

* Fix the rest of the tpcc benchmark.

* Fix the ycsb IndexScanDesc construction.

* Fix the sdbench. It does not run though.

* Delete unused code.

Author: linmagit

src/catalog/abstract_catalog.cpp

@@ -134,7 +134,7 @@ bool AbstractCatalog::DeleteWithIndexScan(
   std::vector<expression::AbstractExpression *> runtime_keys;
 
   planner::IndexScanPlan::IndexScanDesc index_scan_desc(
-      index, key_column_offsets, expr_types, values, runtime_keys);
+      index->GetOid(), key_column_offsets, expr_types, values, runtime_keys);
 
   std::unique_ptr<planner::IndexScanPlan> index_scan_node(
       new planner::IndexScanPlan(catalog_table_, nullptr, column_offsets,
@@ -179,7 +179,7 @@ AbstractCatalog::GetResultWithIndexScan(
   std::vector<expression::AbstractExpression *> runtime_keys;
 
   planner::IndexScanPlan::IndexScanDesc index_scan_desc(
-      index, key_column_offsets, expr_types, values, runtime_keys);
+      index->GetOid(), key_column_offsets, expr_types, values, runtime_keys);
 
   planner::IndexScanPlan index_scan_node(catalog_table_, nullptr,
                                          column_offsets, index_scan_desc);

src/executor/hybrid_scan_executor.cpp

@@ -10,18 +10,18 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "executor/hybrid_scan_executor.h"
 #include "common/container_tuple.h"
+#include "common/internal_types.h"
 #include "common/logger.h"
 #include "concurrency/transaction_manager_factory.h"
 #include "executor/executor_context.h"
-#include "executor/hybrid_scan_executor.h"
 #include "executor/logical_tile.h"
 #include "executor/logical_tile_factory.h"
 #include "planner/hybrid_scan_plan.h"
 #include "storage/data_table.h"
 #include "storage/tile.h"
 #include "storage/tile_group_header.h"
-#include "common/internal_types.h"
 
 namespace peloton {
 namespace executor {
@@ -39,10 +39,15 @@ bool HybridScanExecutor::DInit() {
   const planner::HybridScanPlan &node = GetPlanNode<planner::HybridScanPlan>();
 
   table_ = node.GetTable();
-  index_ = node.GetDataIndex();
   type_ = node.GetHybridType();
   PELOTON_ASSERT(table_ != nullptr);
 
+  // Get the index object from the index id
+  oid_t index_id = node.GetIndexId();
+  if (index_id != INVALID_OID) {
+    index_ = table_->GetIndexWithOid(index_id);
+  }
+
   // SEQUENTIAL SCAN
   if (type_ == HybridScanType::SEQUENTIAL) {
     LOG_TRACE("Sequential Scan");
@@ -57,7 +62,6 @@ bool HybridScanExecutor::DInit() {
   // INDEX SCAN
   else if (type_ == HybridScanType::INDEX) {
     LOG_TRACE("Index Scan");
-    index_ = node.GetIndex();
 
     result_itr_ = START_OID;
     index_done_ = false;
@@ -72,6 +76,9 @@ bool HybridScanExecutor::DInit() {
     predicate_ = node.GetPredicate();
     key_ready_ = false;
 
+    index_predicate_.AddConjunctionScanPredicate(index_.get(), values_,
+                                                 key_column_ids_, expr_types_);
+
     if (runtime_keys_.size() != 0) {
       assert(runtime_keys_.size() == values_.size());
 
@@ -146,14 +153,18 @@ bool HybridScanExecutor::DInit() {
       }
     }
 
+    index_predicate_.AddConjunctionScanPredicate(index_.get(), values_,
+                                                 key_column_ids_, expr_types_);
+
     if (table_ != nullptr) {
       full_column_ids_.resize(table_->GetSchema()->GetColumnCount());
       std::iota(full_column_ids_.begin(), full_column_ids_.end(), 0);
     }
   }
   // FALLBACK
   else {
-    throw Exception("Invalid hybrid scan type : " + HybridScanTypeToString(type_));
+    throw Exception("Invalid hybrid scan type : " +
+                    HybridScanTypeToString(type_));
   }
 
   return true;
@@ -313,7 +324,8 @@ bool HybridScanExecutor::DExecute() {
   }
   // FALLBACK
   else {
-    throw Exception("Invalid hybrid scan type : " + HybridScanTypeToString(type_));
+    throw Exception("Invalid hybrid scan type : " +
+                    HybridScanTypeToString(type_));
   }
 }
 
@@ -337,7 +349,7 @@ bool HybridScanExecutor::ExecPrimaryIndexLookup() {
     LOG_TRACE("Scan");
     index_->Scan(values_, key_column_ids_, expr_type_,
                  ScanDirectionType::FORWARD, tuple_location_ptrs,
-                 &node.GetIndexPredicate().GetConjunctionList()[0]);
+                 &index_predicate_.GetConjunctionList()[0]);
   }
 
   LOG_TRACE("Result tuple count: %lu", tuple_location_ptrs.size());

src/executor/index_scan_executor.cpp

@@ -12,8 +12,10 @@
 
 #include "executor/index_scan_executor.h"
 
+#include "catalog/catalog.h"
 #include "catalog/manager.h"
 #include "common/container_tuple.h"
+#include "common/internal_types.h"
 #include "common/logger.h"
 #include "concurrency/transaction_manager_factory.h"
 #include "executor/executor_context.h"
@@ -26,7 +28,6 @@
 #include "storage/masked_tuple.h"
 #include "storage/tile_group.h"
 #include "storage/tile_group_header.h"
-#include "common/internal_types.h"
 #include "type/value.h"
 
 namespace peloton {
@@ -58,11 +59,6 @@ bool IndexScanExecutor::DInit() {
   // Grab info from plan node and check it
   const planner::IndexScanPlan &node = GetPlanNode<planner::IndexScanPlan>();
 
-  index_ = node.GetIndex();
-  PELOTON_ASSERT(index_ != nullptr);
-
-  index_predicate_ = node.GetIndexPredicate();
-
   result_itr_ = START_OID;
   result_.clear();
   done_ = false;
@@ -107,6 +103,18 @@ bool IndexScanExecutor::DInit() {
     std::iota(full_column_ids_.begin(), full_column_ids_.end(), 0);
   }
 
+  oid_t index_id = node.GetIndexId();
+  index_ = table_->GetIndexWithOid(index_id);
+  PELOTON_ASSERT(index_ != nullptr);
+
+  // Then add the only conjunction predicate into the index predicate list
+  // (at least for now we only supports single conjunction)
+  //
+  // Values that are left blank will be recorded for future binding
+  // and their offset inside the value array will be remembered
+  index_predicate_.AddConjunctionScanPredicate(index_.get(), values_,
+                                               key_column_ids_, expr_types_);
+
   return true;
 }
 
@@ -371,7 +379,6 @@ bool IndexScanExecutor::ExecPrimaryIndexLookup() {
     result_.push_back(logical_tile.release());
   }
 
-
   done_ = true;
 
   LOG_TRACE("Result tiles : %lu", result_.size());
@@ -486,8 +493,8 @@ bool IndexScanExecutor::ExecSecondaryIndexLookup() {
                   tuple_location.offset);
 
         // Further check if the version has the secondary key
-        ContainerTuple<storage::TileGroup> candidate_tuple(tile_group.get(),
-            tuple_location.offset);
+        ContainerTuple<storage::TileGroup> candidate_tuple(
+            tile_group.get(), tuple_location.offset);
 
         LOG_TRACE("candidate_tuple size: %s",
                   candidate_tuple.GetInfo().c_str());
@@ -506,8 +513,9 @@ bool IndexScanExecutor::ExecSecondaryIndexLookup() {
         bool eval = true;
         // if having predicate, then perform evaluation.
         if (predicate_ != nullptr) {
-          eval = predicate_->Evaluate(&candidate_tuple, nullptr,
-                                      executor_context_).IsTrue();
+          eval =
+              predicate_->Evaluate(&candidate_tuple, nullptr, executor_context_)
+                  .IsTrue();
         }
         // if passed evaluation, then perform write.
         if (eval == true) {
@@ -845,8 +853,8 @@ void IndexScanExecutor::UpdatePredicate(
   }
 
   // Update the new value
-  index_predicate_.GetConjunctionListToSetup()[0]
-      .SetTupleColumnValue(index_.get(), key_column_ids, values);
+  index_predicate_.GetConjunctionListToSetup()[0].SetTupleColumnValue(
+      index_.get(), key_column_ids, values);
 }
 
 void IndexScanExecutor::ResetState() {

src/include/executor/hybrid_scan_executor.h

@@ -12,10 +12,10 @@
 
 #pragma once
 
-#include "storage/data_table.h"
-#include "index/index.h"
 #include "executor/abstract_scan_executor.h"
+#include "index/index.h"
 #include "planner/hybrid_scan_plan.h"
+#include "storage/data_table.h"
 
 #include <set>
 
@@ -92,6 +92,9 @@ class HybridScanExecutor : public AbstractScanExecutor {
   std::set<ItemPointer> item_pointers_;
 
   oid_t block_threshold = 0;
+
+  // The predicate used for scanning the index
+  index::IndexScanPredicate index_predicate_;
 };
 
 }  // namespace executor

src/include/executor/index_scan_executor.h

@@ -93,7 +93,7 @@ class IndexScanExecutor : public AbstractScanExecutor {
   std::shared_ptr<index::Index> index_;
 
   // the underlying table that the index is for
-  const storage::AbstractTable *table_ = nullptr;
+  storage::DataTable *table_ = nullptr;
 
   // columns to be returned as results
   std::vector<oid_t> column_ids_;

src/include/planner/hybrid_scan_plan.h

@@ -38,15 +38,13 @@ class HybridScanPlan : public AbstractScan {
 
   ~HybridScanPlan() {}
 
-  std::shared_ptr<index::Index> GetDataIndex() const { return index_; }
-
   std::unique_ptr<AbstractPlan> Copy() const {
     return std::unique_ptr<AbstractPlan>(nullptr);
   }
 
   PlanNodeType GetPlanNodeType() const { return PlanNodeType::SEQSCAN; }
 
-  std::shared_ptr<index::Index> GetIndex() const { return index_; }
+  oid_t GetIndexId() const { return index_id_; }
 
   const std::vector<oid_t> &GetColumnIds() const { return column_ids_; }
 
@@ -81,7 +79,7 @@ class HybridScanPlan : public AbstractScan {
 
   const std::vector<expression::AbstractExpression *> runtime_keys_;
 
-  std::shared_ptr<index::Index> index_;
+  oid_t index_id_;
 
   index::IndexScanPredicate index_predicate_;
 
@@ -90,4 +88,4 @@ class HybridScanPlan : public AbstractScan {
 };
 
 }  // namespace planner
-}  // namespace peloton
+}  // namespace peloton

src/include/planner/index_scan_plan.h

@@ -46,7 +46,7 @@ class IndexScanPlan : public AbstractScan {
      * We need to do this since this might be created even when an index
      * is not required, e.g. inside hybrid scan
      */
-    IndexScanDesc() : index_obj{nullptr} {}
+    IndexScanDesc() : index_id{INVALID_OID} {}
 
     /*
      * Constructor
@@ -56,12 +56,12 @@ class IndexScanPlan : public AbstractScan {
      * be called to notify later procedures of the absense of an index
      */
     IndexScanDesc(
-        std::shared_ptr<index::Index> p_index_obj,
+        oid_t p_index_id,
         const std::vector<oid_t> &p_tuple_column_id_list,
         const std::vector<ExpressionType> &expr_list_p,
         const std::vector<type::Value> &p_value_list,
         const std::vector<expression::AbstractExpression *> &p_runtime_key_list)
-        : index_obj(p_index_obj),
+        : index_id(p_index_id),
           tuple_column_id_list(p_tuple_column_id_list),
           expr_list(expr_list_p),
           value_list(p_value_list),
@@ -79,8 +79,8 @@ class IndexScanPlan : public AbstractScan {
     // argument. This is a bad design but currently we have to live with it
     // In order to prevent the scan predicate optimizer from trying to
     // optimizing the index scan while the index pointer is not valid
-    // this should be set to 0 for an empty initialization
-    std::shared_ptr<index::Index> index_obj;
+    // this should be set to INVALID_OID for an empty initialization
+    oid_t index_id;
 
     // A list of columns id in the base table that has a scan predicate
     // (only for indexed column in the base table)
@@ -113,7 +113,7 @@ class IndexScanPlan : public AbstractScan {
     LOG_TRACE("Destroyed a index scan plan!");
   }
 
-  std::shared_ptr<index::Index> GetIndex() const { return index_; }
+  oid_t GetIndexId() const { return index_id_; }
 
   const std::vector<oid_t> &GetColumnIds() const { return column_ids_; }
 
@@ -167,7 +167,7 @@ class IndexScanPlan : public AbstractScan {
       new_runtime_keys.push_back(key->Copy());
     }
 
-    IndexScanDesc desc(index_, key_column_ids_, expr_types_, values_,
+    IndexScanDesc desc(index_id_, key_column_ids_, expr_types_, values_,
                        new_runtime_keys);
     IndexScanPlan *new_plan = new IndexScanPlan(
         GetTable(), GetPredicate()->Copy(), GetColumnIds(), desc, false);
@@ -176,7 +176,7 @@ class IndexScanPlan : public AbstractScan {
 
  private:
   /** @brief index associated with index scan. */
-  std::shared_ptr<index::Index> index_;
+  oid_t index_id_;
 
   // A list of column IDs involved in the index scan no matter whether
   // it is indexed or not (i.e. select statement)
@@ -233,4 +233,4 @@ class IndexScanPlan : public AbstractScan {
 };
 
 }  // namespace planner
-}  // namespace peloton
+}  // namespace peloton