feat(optimizer): plan order by as index scan, support create index (#388)

Signed-off-by: Alex Chi <[email protected]>

Author: skyzh

.clang-tidy

@@ -47,6 +47,7 @@ Checks:     '
             -readability-make-member-function-const,
             -readability-qualified-auto,
             -readability-redundant-access-specifiers,
+            -bugprone-exception-escape,
             '
 CheckOptions:
   - { key: readability-identifier-naming.ClassCase,           value: CamelCase  }
@@ -92,3 +93,5 @@ AnalyzeTemporaryDtors: true
 # -readability-qualified-auto, -readability-redundant-access-specifiers
 #     These were previously disabled for not being available in clang-tidy-8. They are now available on our clang-tidy-12, 
 #     and potentially worth investigating/fixing.
+# -bugprone-exception-escape
+#     Weird. No idea how to resolve.

src/binder/bind_insert.cpp

@@ -22,16 +22,15 @@ auto Binder::BindInsert(duckdb_libpgquery::PGInsertStmt *pg_stmt) -> std::unique
     throw NotImplementedException("insert only supports all columns, don't specify columns");
   }
 
-  auto table_name = std::string(pg_stmt->relation->relname);
+  auto table = BindRangeVar(pg_stmt->relation);
 
-  auto table_info = catalog_.GetTable(table_name);
-  if (table_info == nullptr || StringUtil::StartsWith(table_name, "__")) {
-    throw bustub::Exception(fmt::format("invalid table for insert: {}", table_name));
+  if (StringUtil::StartsWith(table->table_, "__")) {
+    throw bustub::Exception(fmt::format("invalid table for insert: {}", table->table_));
   }
 
   auto select_statement = BindSelect(reinterpret_cast<duckdb_libpgquery::PGSelectStmt *>(pg_stmt->selectStmt));
 
-  return std::make_unique<InsertStatement>(table_name, std::move(select_statement));
+  return std::make_unique<InsertStatement>(std::move(table), std::move(select_statement));
 }
 
 auto Binder::BindDelete(duckdb_libpgquery::PGDeleteStmt *stmt) -> std::unique_ptr<DeleteStatement> {

src/binder/bind_select.cpp

@@ -25,6 +25,7 @@
 #include "binder/tokens.h"
 #include "catalog/catalog.h"
 #include "common/exception.h"
+#include "common/macros.h"
 #include "common/util/string_util.h"
 #include "fmt/core.h"
 #include "fmt/format.h"
@@ -265,7 +266,8 @@ auto Binder::BindBaseTableRef(std::string table_name, std::optional<std::string>
   if (table_info == nullptr) {
     throw bustub::Exception(fmt::format("invalid table {}", table_name));
   }
-  return std::make_unique<BoundBaseTableRef>(std::move(table_name), std::move(alias), table_info->schema_);
+  return std::make_unique<BoundBaseTableRef>(std::move(table_name), table_info->oid_, std::move(alias),
+                                             table_info->schema_);
 }
 
 auto Binder::BindRangeVar(duckdb_libpgquery::PGRangeVar *table_ref) -> std::unique_ptr<BoundBaseTableRef> {
@@ -384,7 +386,7 @@ auto Binder::BindConstant(duckdb_libpgquery::PGAConst *node) -> std::unique_ptr<
   const auto &val = node->val;
   switch (val.type) {
     case duckdb_libpgquery::T_PGInteger: {
-      BUSTUB_ASSERT(val.val.ival <= BUSTUB_INT32_MAX, "value out of range");
+      BUSTUB_ENSURE(val.val.ival <= BUSTUB_INT32_MAX, "value out of range");
       return std::make_unique<BoundConstant>(ValueFactory::GetIntegerValue(static_cast<int32_t>(val.val.ival)));
     }
     case duckdb_libpgquery::T_PGString: {

src/binder/statement/insert_statement.cpp

@@ -9,11 +9,11 @@
 
 namespace bustub {
 
-InsertStatement::InsertStatement(std::string table, std::unique_ptr<SelectStatement> select)
+InsertStatement::InsertStatement(std::unique_ptr<BoundBaseTableRef> table, std::unique_ptr<SelectStatement> select)
     : BoundStatement(StatementType::INSERT_STATEMENT), table_(std::move(table)), select_(std::move(select)) {}
 
 auto InsertStatement::ToString() const -> std::string {
-  return fmt::format("BoundInsert {{\n  table={},\n  select={}\n}}", table_,
+  return fmt::format("BoundInsert {{\n  table={},\n  select={}\n}}", *table_,
                      StringUtil::IndentAllLines(select_->ToString(), 2));
 }
 

src/common/bustub_instance.cpp

@@ -4,6 +4,7 @@
 #include "binder/bound_statement.h"
 #include "binder/statement/create_statement.h"
 #include "binder/statement/explain_statement.h"
+#include "binder/statement/index_statement.h"
 #include "binder/statement/select_statement.h"
 #include "buffer/buffer_pool_manager_instance.h"
 #include "catalog/schema.h"
@@ -57,7 +58,7 @@ BustubInstance::BustubInstance(const std::string &db_file_name) {
   checkpoint_manager_ = new CheckpointManager(transaction_manager_, log_manager_, buffer_pool_manager_);
 
   // Catalog.
-  catalog_ = new Catalog(buffer_pool_manager_, nullptr, nullptr);
+  catalog_ = new Catalog(buffer_pool_manager_, lock_manager_, log_manager_);
 
   // Execution engine.
   execution_engine_ = new ExecutionEngine(buffer_pool_manager_, transaction_manager_, catalog_);
@@ -97,29 +98,60 @@ auto BustubInstance::ExecuteSql(const std::string &sql) -> std::vector<std::stri
       case StatementType::CREATE_STATEMENT: {
         const auto &create_stmt = dynamic_cast<const CreateStatement &>(*statement);
         auto txn = transaction_manager_->Begin();
-        catalog_->CreateTable(txn, create_stmt.table_, Schema(create_stmt.columns_));
+        auto info = catalog_->CreateTable(txn, create_stmt.table_, Schema(create_stmt.columns_));
         transaction_manager_->Commit(txn);
         delete txn;
+        if (info == nullptr) {
+          throw bustub::Exception("Failed to create table");
+        }
+        std::cout << "Table created with id = " << info->oid_ << std::endl;
+        continue;
+      }
+      case StatementType::INDEX_STATEMENT: {
+        const auto &index_stmt = dynamic_cast<const IndexStatement &>(*statement);
+        auto txn = transaction_manager_->Begin();
+
+        std::vector<uint32_t> col_ids;
+        for (const auto &col : index_stmt.cols_) {
+          auto idx = index_stmt.table_->schema_.GetColIdx(col->col_name_.back());
+          col_ids.push_back(idx);
+          if (index_stmt.table_->schema_.GetColumn(idx).GetType() != TypeId::INTEGER) {
+            throw NotImplementedException("only support creating index on integer column");
+          }
+        }
+        if (col_ids.size() != 1) {
+          throw NotImplementedException("only support creating index with exactly one column");
+        }
+        auto key_schema = Schema::CopySchema(&index_stmt.table_->schema_, col_ids);
+        auto info = catalog_->CreateIndex<IntegerKeyType, IntegerValueType, IntegerComparatorType>(
+            txn, index_stmt.index_name_, index_stmt.table_->table_, index_stmt.table_->schema_, key_schema, col_ids,
+            INTEGER_SIZE, IntegerHashFunctionType{});
+        transaction_manager_->Commit(txn);
+        delete txn;
+        if (info == nullptr) {
+          throw bustub::Exception("Failed to create index");
+        }
+        std::cout << "Index created with id = " << info->index_oid_ << std::endl;
         continue;
       }
       case StatementType::EXPLAIN_STATEMENT: {
         const auto &explain_stmt = dynamic_cast<const ExplainStatement &>(*statement);
 
         // Print binder result.
-        std::cerr << "=== BINDER ===" << std::endl;
-        std::cerr << statement->ToString() << std::endl;
+        std::cout << "=== BINDER ===" << std::endl;
+        std::cout << statement->ToString() << std::endl;
 
         // Print planner result.
         bustub::Planner planner(*catalog_);
         planner.PlanQuery(*explain_stmt.statement_);
-        std::cerr << "=== PLANNER ===" << std::endl;
-        std::cerr << planner.plan_->ToString() << std::endl;
+        std::cout << "=== PLANNER ===" << std::endl;
+        std::cout << planner.plan_->ToString() << std::endl;
 
         // Print optimizer result.
         bustub::Optimizer optimizer(*catalog_);
         auto optimized_plan = optimizer.Optimize(planner.plan_);
-        std::cerr << "=== OPTIMIZER ===" << std::endl;
-        std::cerr << optimized_plan->ToString() << std::endl;
+        std::cout << "=== OPTIMIZER ===" << std::endl;
+        std::cout << optimized_plan->ToString() << std::endl;
         continue;
       }
       default:

src/include/binder/statement/insert_statement.h

@@ -12,6 +12,7 @@
 #include <vector>
 
 #include "binder/bound_statement.h"
+#include "binder/table_ref/bound_base_table_ref.h"
 #include "catalog/column.h"
 #include "type/value.h"
 
@@ -25,9 +26,10 @@ class SelectStatement;
 
 class InsertStatement : public BoundStatement {
  public:
-  explicit InsertStatement(std::string table, std::unique_ptr<SelectStatement> select);
+  explicit InsertStatement(std::unique_ptr<BoundBaseTableRef> table, std::unique_ptr<SelectStatement> select);
+
+  std::unique_ptr<BoundBaseTableRef> table_;
 
-  std::string table_;
   std::unique_ptr<SelectStatement> select_;
 
   auto ToString() const -> std::string override;

src/include/binder/table_ref/bound_base_table_ref.h

@@ -5,6 +5,7 @@
 #include <utility>
 #include "binder/bound_table_ref.h"
 #include "catalog/schema.h"
+#include "concurrency/transaction.h"
 #include "fmt/core.h"
 
 namespace bustub {
@@ -14,17 +15,18 @@ namespace bustub {
  */
 class BoundBaseTableRef : public BoundTableRef {
  public:
-  explicit BoundBaseTableRef(std::string table, std::optional<std::string> alias, Schema schema)
+  explicit BoundBaseTableRef(std::string table, table_oid_t oid, std::optional<std::string> alias, Schema schema)
       : BoundTableRef(TableReferenceType::BASE_TABLE),
         table_(std::move(table)),
+        oid_(oid),
         alias_(std::move(alias)),
         schema_(std::move(schema)) {}
 
   auto ToString() const -> std::string override {
     if (alias_ == std::nullopt) {
-      return fmt::format("BoundBaseTableRef {{ table={} }}", table_);
+      return fmt::format("BoundBaseTableRef {{ table={}, oid={} }}", table_, oid_);
     }
-    return fmt::format("BoundBaseTableRef {{ table={}, alias={} }}", table_, *alias_);
+    return fmt::format("BoundBaseTableRef {{ table={}, oid={}, alias={} }}", table_, oid_, *alias_);
   }
 
   auto GetBoundTableName() const -> std::string {
@@ -37,6 +39,9 @@ class BoundBaseTableRef : public BoundTableRef {
   /** The name of the table. */
   std::string table_;
 
+  /** The oid of the table. */
+  table_oid_t oid_;
+
   /** The alias of the table */
   std::optional<std::string> alias_;
 

src/include/catalog/catalog.h

@@ -21,6 +21,7 @@
 #include "buffer/buffer_pool_manager.h"
 #include "catalog/schema.h"
 #include "container/hash/hash_function.h"
+#include "storage/index/b_plus_tree_index.h"
 #include "storage/index/extendible_hash_table_index.h"
 #include "storage/index/index.h"
 #include "storage/table/table_heap.h"
@@ -176,7 +177,7 @@ class Catalog {
    * @param table_oid The OID of the table to query
    * @return A (non-owning) pointer to the metadata for the table
    */
-  auto GetTable(table_oid_t table_oid) -> TableInfo * {
+  auto GetTable(table_oid_t table_oid) const -> TableInfo * {
     auto meta = tables_.find(table_oid);
     if (meta == tables_.end()) {
       return NULL_TABLE_INFO;
@@ -223,8 +224,9 @@ class Catalog {
     // TODO(Kyle): We should update the API for CreateIndex
     // to allow specification of the index type itself, not
     // just the key, value, and comparator types
-    auto index = std::make_unique<ExtendibleHashTableIndex<KeyType, ValueType, KeyComparator>>(std::move(meta), bpm_,
-                                                                                               hash_function);
+
+    // TODO(chi): support both hash index and btree index
+    auto index = std::make_unique<BPlusTreeIndex<KeyType, ValueType, KeyComparator>>(std::move(meta), bpm_);
 
     // Populate the index with all tuples in table heap
     auto *table_meta = GetTable(table_name);
@@ -311,7 +313,7 @@ class Catalog {
    * @return A vector of IndexInfo* for each index on the given table, empty vector
    * in the event that the table exists but no indexes have been created for it
    */
-  auto GetTableIndexes(const std::string &table_name) -> std::vector<IndexInfo *> {
+  auto GetTableIndexes(const std::string &table_name) const -> std::vector<IndexInfo *> {
     // Ensure the table exists
     if (table_names_.find(table_name) == table_names_.end()) {
       return std::vector<IndexInfo *>{};

src/include/catalog/schema.h

@@ -34,13 +34,13 @@ class Schema {
    */
   explicit Schema(const std::vector<Column> &columns);
 
-  static auto CopySchema(const Schema *from, const std::vector<uint32_t> &attrs) -> Schema * {
+  static auto CopySchema(const Schema *from, const std::vector<uint32_t> &attrs) -> Schema {
     std::vector<Column> cols;
     cols.reserve(attrs.size());
     for (const auto i : attrs) {
       cols.emplace_back(from->columns_[i]);
     }
-    return new Schema{cols};
+    return Schema{cols};
   }
 
   /** @return all the columns in the schema */

src/include/execution/plans/delete_plan.h

@@ -12,6 +12,7 @@
 
 #pragma once
 
+#include <string>
 #include <utility>
 
 #include "catalog/catalog.h"
@@ -50,6 +51,9 @@ class DeletePlanNode : public AbstractPlanNode {
 
   BUSTUB_PLAN_NODE_CLONE_WITH_CHILDREN(DeletePlanNode);
 
+ protected:
+  auto PlanNodeToString() const -> std::string override { return fmt::format("Delete {{ table_oid={} }}", table_oid_); }
+
  private:
   /** The identifier of the table from which tuples are deleted */
   table_oid_t table_oid_;