added alter table drop column parser, planner, and catalog support, waiting for executor

Author: Dingshilun

src/catalog/catalog.cpp

@@ -812,10 +812,20 @@ ResultType Catalog::AddColumn(
 }
 
 ResultType Catalog::DropColumn(
-    UNUSED_ATTRIBUTE const std::string &database_name,
-    UNUSED_ATTRIBUTE const std::string &table_name,
-    UNUSED_ATTRIBUTE const std::vector<std::string> &columns,
-    UNUSED_ATTRIBUTE concurrency::TransactionContext *txn) {
+    const std::string &database_name,
+    const std::string &table_name,
+    const std::vector<std::string> &columns,
+    concurrency::TransactionContext *txn) {
+  try {
+    oid_t table_oid = Catalog::GetInstance()
+        ->GetTableObject(database_name, table_name, txn)
+        ->GetTableOid();
+    for (std::string name: columns) {
+      catalog::ColumnCatalog::GetInstance()->DeleteColumn(table_oid, name, txn);
+    }
+  } catch(CatalogException &e){
+    return ResultType::FAILURE;
+  }
   return ResultType::SUCCESS;
 }
 

src/include/common/internal_types.h

@@ -646,6 +646,8 @@ std::ostream &operator<<(std::ostream &os, const DropType &type);
 enum class AlterType {
   INVALID = INVALID_TYPE_ID,  // invalid alter type
   RENAME = 1,                 // rename table, column, database...
+  ADD = 2,
+  DROP = 3
 };
 std::string AlterTypeToString(AlterType type);
 AlterType StringToAlterType(const std::string &str);

src/optimizer/optimizer.cpp

@@ -149,7 +149,10 @@ unique_ptr<planner::AbstractPlan> Optimizer::HandleDDLStatement(
   switch (stmt_type) {
     case StatementType::ALTER: {
       // TODO (shilun) adding support of Alter
-      LOG_TRACE("TO BE Implemented...");
+      LOG_TRACE("Adding Alter Plan");
+      unique_ptr<planner::AbstractPlan> alter_plan(
+          new planner::AlterPlan((parser::AlterTableStatement *)tree));
+      ddl_plan = move(alter_plan);
       break;
     }
     case StatementType::RENAME: {

src/parser/postgresparser.cpp

@@ -1732,13 +1732,13 @@ parser::TransactionStatement *PostgresParser::TransactionTransform(
 parser::AlterTableStatement *PostgresParser::AlterTransform(
     AlterTableStmt *root) {
   // TODO (shilun) adding alter type check
-  parser::AlterTableStatement *result = new AlterTableStatement(
-      parser::AlterTableStatement::AlterTableType::INVALID);
+  // Currently we only support add/drop column type
+  parser::AlterTableStatement* result =
+      new AlterTableStatement(AlterTableStatement::AlterTableType::INVALID);
 
   // Get database and table name
-  RangeVar *relation = root->relation;
-  result->table_info_ =
-      std::unique_ptr<parser::TableInfo>(new parser::TableInfo());
+  RangeVar* relation = root->relation;
+  result->table_info_ = std::unique_ptr<parser::TableInfo>(new parser::TableInfo());
   if (relation->relname) {
     result->table_info_->table_name = strdup(relation->relname);
   }
@@ -1747,22 +1747,22 @@ parser::AlterTableStatement *PostgresParser::AlterTransform(
   }
 
   for (auto cell = root->cmds->head; cell != NULL; cell = cell->next) {
-    auto cmd = reinterpret_cast<AlterTableCmd *>(cell->data.ptr_value);
+    auto cmd = reinterpret_cast<AlterTableCmd*>(cell->data.ptr_value);
     switch (cmd->subtype) {
-      /*case AT_AddColumn: {
-        auto column =
-            ColumnDefTransform(reinterpret_cast<ColumnDef*>(cmd->def));
-        result->columns->push_back(column);
-        break;
-      }
-      case AT_DropColumn:
-        result->names->push_back(strdup(cmd->name));
-        break;
-      case AT_AlterColumnGenericOptions:*/
-      default: {
-        throw NotImplementedException(StringUtil::Format(
-            "Alter Table type %d not supported yet...\n", cmd->subtype));
-      }
+    /*case AT_AddColumn: {
+      auto column =
+          ColumnDefTransform(reinterpret_cast<ColumnDef*>(cmd->def));
+      result->columns->push_back(column);
+      break;
+    }*/
+    case AT_DropColumn:
+      result->names->push_back(strdup(cmd->name));
+      result->type = AlterTableStatement::AlterTableType::DROP;
+      break;
+    default: {
+      throw NotImplementedException(StringUtil::Format(
+          "Alter Table type %d not supported yet...\n", cmd->subtype));
+    }
     }
   }
   return result;

src/planner/alter_plan.cpp

@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// alter_table_plan.cpp
+//
+// Identification: src/planner/alter_table_plan.cpp
+//
+// Copyright (c) 2015-16, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#include "planner/alter_plan.h"
+
+#include "catalog/column.h"
+#include "catalog/schema.h"
+#include "parser/alter_statement.h"
+#include "storage/data_table.h"
+
+namespace peloton {
+namespace planner {
+
+AlterPlan::AlterPlan(const std::string &database_name,
+                               const std::string &table_name,
+                               //std::unique_ptr<catalog::Schema> added_columns,
+                               const std::vector<std::string> &dropped_columns,
+                               AlterType a_type)
+    : table_name(table_name),
+      database_name(database_name),
+      //added_columns(added_columns.release()),
+      dropped_columns(dropped_columns),
+      type(a_type) {}
+
+AlterPlan::AlterPlan(parser::AlterTableStatement *parse_tree) {
+  table_name = std::string(parse_tree->GetTableName());
+  database_name = std::string(parse_tree->GetDatabaseName());
+  switch (parse_tree->type){
+    case parser::AlterTableStatement::AlterTableType::DROP:
+      for (auto col : *parse_tree->names) {
+        LOG_TRACE("Drooped column name: %s", col);
+        dropped_columns.push_back(std::string(col));
+        type = AlterType::DROP;
+      }
+    case parser::AlterTableStatement::AlterTableType::ADD:
+    default:
+      LOG_TRACE("Not Implemented the plan yet!");
+  }
+  //std::vector<catalog::Column> columns;
+  // case 1: add column(column name + column data type)
+  //if (parse_tree->type == AlterTableType::COLUMN) {
+    // Add columns: traverse through vector of ColumnDefinition
+    /*for (auto col : *parse_tree->columns) {
+      type::TypeId val = col->GetValueType(col->type);
+      LOG_TRACE("Column name: %s", col->name);
+
+      bool is_inline = (val == type::TypeId::VARCHAR) ? false : true;
+      auto column = catalog::Column(val, type::Type::GetTypeSize(val),
+                                    std::string(col->name), is_inline);
+      LOG_TRACE("Column is_line: %d", is_inline);
+      // Add not_null constraints
+      if (col->not_null) {
+        catalog::Constraint constraint(ConstraintType::NOTNULL, "con_not_null");
+        column.AddConstraint(constraint);
+      }
+      columns.push_back(column);
+    }
+    added_columns = new catalog::Schema(columns);*/
+
+    // Drop columns: traverse through vector of char*(column name)
+
+  }
+
+
+}  // namespace planner
+}  // namespace peloton