Merge pull request #1105 from pranavk/queryplan_gh

Information about indexes affected by a given query

Author: linmagit

src/include/catalog/catalog_cache.h

@@ -18,6 +18,11 @@
 #include "common/internal_types.h"
 
 namespace peloton {
+
+namespace planner {
+class PlanUtil;
+}  // namespace planner
+
 namespace catalog {
 
 class DatabaseCatalogObject;
@@ -32,6 +37,7 @@ class CatalogCache {
   friend class DatabaseCatalogObject;
   friend class TableCatalogObject;
   friend class IndexCatalogObject;
+  friend class planner::PlanUtil;
 
  public:
   CatalogCache() {}

src/include/parser/insert_statement.h

@@ -24,7 +24,7 @@ namespace parser {
  * @brief Represents "INSERT INTO students VALUES ('Max', 1112233,
  * 'Musterhausen', 2.3)"
  */
-class InsertStatement : SQLStatement {
+class InsertStatement : public SQLStatement {
  public:
   InsertStatement(InsertType type)
       : SQLStatement(StatementType::INSERT), type(type), select(nullptr) {}

src/include/parser/sql_statement.h

@@ -19,10 +19,10 @@
 
 #include <vector>
 
+#include "common/internal_types.h"
 #include "common/macros.h"
 #include "common/printable.h"
 #include "common/sql_node_visitor.h"
-#include "common/internal_types.h"
 
 namespace peloton {
 
@@ -43,7 +43,7 @@ class SQLStatement : public Printable {
 
   virtual ~SQLStatement() {}
 
-  virtual StatementType GetType() { return stmt_type; }
+  virtual StatementType GetType() const { return stmt_type; }
 
   // Get a string representation for debugging
   virtual const std::string GetInfo(int num_indent) const;

src/include/parser/update_statement.h

@@ -14,8 +14,8 @@
 
 #include <cstring>
 
-#include "expression/abstract_expression.h"
 #include "common/sql_node_visitor.h"
+#include "expression/abstract_expression.h"
 #include "parser/sql_statement.h"
 #include "parser/table_ref.h"
 

src/include/planner/plan_util.h

@@ -19,12 +19,21 @@
 #include "planner/abstract_scan_plan.h"
 #include "planner/delete_plan.h"
 #include "planner/insert_plan.h"
-#include "planner/update_plan.h"
 #include "planner/populate_index_plan.h"
+#include "planner/update_plan.h"
 #include "storage/data_table.h"
 #include "util/string_util.h"
 
 namespace peloton {
+
+namespace catalog {
+class CatalogCache;
+}  // namespace catalog
+
+namespace parser {
+class SQLStatement;
+}  // namespace parser
+
 namespace planner {
 
 class PlanUtil {
@@ -44,6 +53,16 @@ class PlanUtil {
   static const std::set<oid_t> GetTablesReferenced(
       const planner::AbstractPlan *plan);
 
+  /**
+  * @brief Get the indexes affected by a given query
+  * @param CatalogCache
+  * @param SQLStatement
+  * @return set of affected index object ids
+  */
+  static const std::set<oid_t> GetAffectedIndexes(
+      catalog::CatalogCache &catalog_cache,
+      const parser::SQLStatement &sql_stmt);
+
  private:
   ///
   /// Helpers for GetInfo() and GetTablesReferenced()

src/include/util/set_util.h

@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// set_util.h
+//
+// Identification: src/include/util/set_util.h
+//
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <set>
+
+namespace peloton {
+
+class SetUtil {
+ public:
+  template <typename T>
+  static bool IsDisjoint(const std::set<T> &setA, const std::set<T> &setB);
+};
+
+template <typename T>
+inline bool SetUtil::IsDisjoint(const std::set<T> &setA,
+                                const std::set<T> &setB) {
+  bool disjoint = true;
+  if (setA.empty() || setB.empty()) return disjoint;
+
+  auto setA_it = setA.begin();
+  auto setB_it = setB.begin();
+  while (setA_it != setA.end() && setB_it != setB.end() && disjoint) {
+    if (*setA_it == *setB_it) {
+      disjoint = false;
+    } else if (*setA_it < *setB_it) {
+      setA_it++;
+    } else {
+      setB_it++;
+    }
+  }
+
+  return disjoint;
+}
+
+}  // namespace peloton

src/planner/plan_util.cpp

@@ -0,0 +1,100 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// plan_util.cpp
+//
+// Identification: src/planner/plan_util.cpp
+//
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#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 "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 {
+namespace planner {
+
+const std::set<oid_t> PlanUtil::GetAffectedIndexes(
+    catalog::CatalogCache &catalog_cache,
+    const parser::SQLStatement &sql_stmt) {
+  std::set<oid_t> index_oids;
+  std::string db_name, table_name;
+  switch (sql_stmt.GetType()) {
+    // For INSERT, DELETE, all indexes are affected
+    case StatementType::INSERT: {
+      auto &insert_stmt =
+          static_cast<const parser::InsertStatement &>(sql_stmt);
+      db_name = insert_stmt.GetDatabaseName();
+      table_name = insert_stmt.GetTableName();
+    }
+      PELOTON_FALLTHROUGH;
+    case StatementType::DELETE: {
+      if (table_name.empty() || db_name.empty()) {
+        auto &delete_stmt =
+            static_cast<const parser::DeleteStatement &>(sql_stmt);
+        db_name = delete_stmt.GetDatabaseName();
+        table_name = delete_stmt.GetTableName();
+      }
+      auto indexes_map = catalog_cache.GetDatabaseObject(db_name)
+                             ->GetTableObject(table_name)
+                             ->GetIndexObjects();
+      for (auto &index : indexes_map) {
+        index_oids.insert(index.first);
+      }
+    } break;
+    case StatementType::UPDATE: {
+      auto &update_stmt =
+          static_cast<const parser::UpdateStatement &>(sql_stmt);
+      db_name = update_stmt.table->GetDatabaseName();
+      table_name = update_stmt.table->GetTableName();
+      auto db_object = catalog_cache.GetDatabaseObject(db_name);
+      auto table_object = db_object->GetTableObject(table_name);
+
+      auto &update_clauses = update_stmt.updates;
+      std::set<oid_t> update_oids;
+      for (const auto &update_clause : update_clauses) {
+        LOG_TRACE("Affected column name for table(%s) in UPDATE query: %s",
+                  table_name.c_str(), update_clause->column.c_str());
+        auto col_object = table_object->GetColumnObject(update_clause->column);
+        update_oids.insert(col_object->GetColumnId());
+      }
+
+      auto indexes_map = table_object->GetIndexObjects();
+      for (auto &index : indexes_map) {
+        LOG_TRACE("Checking if UPDATE query affects index: %s",
+                  index.second->GetIndexName().c_str());
+        const std::vector<oid_t> &key_attrs =
+            index.second->GetKeyAttrs();  // why it's a vector, and not set?
+        const std::set<oid_t> key_attrs_set(key_attrs.begin(), key_attrs.end());
+        if (!SetUtil::IsDisjoint(key_attrs_set, update_oids)) {
+          LOG_TRACE("Index (%s) is affected",
+                    index.second->GetIndexName().c_str());
+          index_oids.insert(index.first);
+        }
+      }
+    } break;
+    case StatementType::SELECT:
+      break;
+    default:
+      LOG_TRACE("Does not support finding affected indexes for query type: %d",
+                static_cast<int>(sql_stmt.GetType()));
+  }
+  return (index_oids);
+}
+
+}  // namespace planner
+}  // namespace peloton