Merge pull request #11 from sxzh93/add_column_parser_planner

added parser support for change column type and add column

Author: DeanChensj

src/common/internal_types.cpp

@@ -426,6 +426,9 @@ std::string AlterTypeToString(AlterType type) {
     case AlterType::RENAME: {
       return "RENAME";
     }
+    case AlterType::ALTER: {
+      return "ALTER";
+    }
     default: {
       throw ConversionException(
           StringUtil::Format("No string conversion for AlterType value '%d'",
@@ -440,6 +443,8 @@ AlterType StringToAlterType(const std::string &str) {
     return AlterType::INVALID;
   } else if (upper_str == "RENAME") {
     return AlterType::RENAME;
+  } else if (upper_str == "ALTER") {
+    return AlterType::ALTER;
   } else {
     throw ConversionException(StringUtil::Format(
         "No AlterType conversion from string '%s'", upper_str.c_str()));

src/executor/alter_executor.cpp

@@ -23,7 +23,8 @@ namespace executor {
 AlterExecutor::AlterExecutor(const planner::AbstractPlan *node,
                              ExecutorContext *executor_context)
     : AbstractExecutor(node, executor_context),
-      isAlter_(!reinterpret_cast<const planner::AlterPlan *>(node)->IsRename()) {}
+      isAlter_(
+          !reinterpret_cast<const planner::AlterPlan *>(node)->IsRename()) {}
 
 // Initialize executor
 // Nothing to initialize for now
@@ -46,7 +47,7 @@ bool AlterExecutor::DExecute() {
     auto current_txn = executor_context_->GetTransaction();
     AlterType type = node.GetAlterTableType();
     switch (type) {
-      case AlterType::DROP:
+      case AlterType::ALTER:
         result = DropColumn(node, current_txn);
         break;
       default:

src/include/common/internal_types.h

@@ -646,8 +646,7 @@ 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
+  ALTER = 2
 };
 std::string AlterTypeToString(AlterType type);
 AlterType StringToAlterType(const std::string &str);
@@ -1230,7 +1229,8 @@ std::ostream &operator<<(std::ostream &os, const RWType &type);
 typedef CuckooMap<ItemPointer, RWType, ItemPointerHasher, ItemPointerComparator>
     ReadWriteSet;
 
-typedef tbb::concurrent_unordered_set<ItemPointer, ItemPointerHasher, ItemPointerComparator> WriteSet;
+typedef tbb::concurrent_unordered_set<ItemPointer, ItemPointerHasher,
+                                      ItemPointerComparator> WriteSet;
 
 // this enum is to identify why the version should be GC'd.
 enum class GCVersionType {

src/include/parser/alter_statement.h

@@ -14,6 +14,7 @@
 
 #include "parser/sql_statement.h"
 #include "common/sql_node_visitor.h"
+#include "parser/create_statement.h"
 
 namespace peloton {
 namespace parser {
@@ -24,39 +25,50 @@ namespace parser {
  */
 class AlterTableStatement : public TableRefStatement {
  public:
-  enum class AlterTableType { INVALID = 0, ADD = 1, DROP = 2, RENAME = 3 };
+  enum class AlterTableType { INVALID = 0, ALTER = 1, RENAME = 2 };
   AlterTableStatement(AlterTableType type)
       : TableRefStatement(StatementType::ALTER),
         type(type),
-        names(new std::vector<char*>),
         oldName(nullptr),
-        newName(nullptr)
-        {};
+        newName(nullptr) {
+    dropped_names =
+        type == AlterTableType::RENAME ? nullptr : (new std::vector<char *>);
+    added_columns = type == AlterTableType::RENAME
+                        ? nullptr
+                        : (new std::vector<std::unique_ptr<ColumnDefinition>>);
+    changed_type_columns =
+        type == AlterTableType::RENAME
+            ? nullptr
+            : (new std::vector<std::unique_ptr<ColumnDefinition>>);
+  }
 
   virtual ~AlterTableStatement() {
-    /*if (columns != nullptr) {
-      for (auto col : *columns) delete col;
-      delete columns;
-    }*/
-    if (names != nullptr) {
-      for (auto name : *names) delete name;
-      delete names;
+    if (added_columns != nullptr) {
+      delete added_columns;
+    }
+    if (dropped_names != nullptr) {
+      for (auto name : *dropped_names) delete name;
+      delete dropped_names;
+    }
+    if (changed_type_columns != nullptr) {
+      delete changed_type_columns;
     }
     if (oldName) delete oldName;
     if (newName) delete newName;
   }
 
-  virtual void Accept(SqlNodeVisitor* v) override { v->Visit(this); }
+  virtual void Accept(SqlNodeVisitor *v) override { v->Visit(this); }
 
   AlterTableType type;
 
   // Dropped columns
-  std::vector<char*>* names;
+  std::vector<char *> *dropped_names;
 
   // Added columns
-  //std::vector<ColumnDefinition*>* columns;
+  std::vector<std::unique_ptr<ColumnDefinition>> *added_columns;
 
-    // the name that needs to be changed
+  std::vector<std::unique_ptr<ColumnDefinition>> *changed_type_columns;
+  // the name that needs to be changed
   char *oldName;
   char *newName;
 };

src/include/planner/alter_plan.h

@@ -33,15 +33,16 @@ class AlterPlan : public AbstractPlan {
  public:
   AlterPlan() = delete;
 
-  explicit 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);
+  explicit AlterPlan(
+      const std::string &database_name, const std::string &table_name,
+      const std::vector<std::string> &dropped_columns,
+      const std::vector<std::unique_ptr<catalog::Schema>> &added_columns,
+      AlterType a_type);
   explicit AlterPlan(const std::string &database_name,
                      const std::string &table_name,
                      const std::vector<std::string> &old_names,
-                     const std::vector<std::string> &new_names, AlterType a_type);
+                     const std::vector<std::string> &new_names,
+                     AlterType a_type);
   explicit AlterPlan(parser::AlterTableStatement *parse_tree);
 
   virtual ~AlterPlan() {}
@@ -52,49 +53,47 @@ class AlterPlan : public AbstractPlan {
 
   const std::string GetInfo() const {
     return StringUtil::Format("AlterPlan table:%s, database:%s",
-                              this->table_name.c_str(), this->database_name.c_str());
+                              this->table_name.c_str(),
+                              this->database_name.c_str());
   }
 
   std::unique_ptr<AbstractPlan> Copy() const {
-    switch(this->type) {
-    case AlterType::DROP:
-    case AlterType::ADD:
-      return std::unique_ptr<AbstractPlan>(
-          new AlterPlan(database_name, table_name,
-              //std::unique_ptr<catalog::Schema>(
-              //    catalog::Schema::CopySchema(added_columns)),
-                        dropped_columns, type));
-    case AlterType::RENAME:
-      return std::unique_ptr<AbstractPlan>(
-          new AlterPlan(database_name, table_name, old_names_, new_names_, type));
-    default:
-      LOG_ERROR("Not supported Copy of Alter type yet");
-      return nullptr;
+    switch (this->type) {
+      case AlterType::ALTER:
+        return std::unique_ptr<AbstractPlan>(new AlterPlan(
+            database_name, table_name, dropped_columns, added_columns, type));
+      case AlterType::RENAME:
+        return std::unique_ptr<AbstractPlan>(new AlterPlan(
+            database_name, table_name, old_names_, new_names_, type));
+      default:
+        LOG_ERROR("Not supported Copy of Alter type yet");
+        return nullptr;
     }
   }
 
   std::string GetTableName() const { return table_name; }
 
   std::string GetDatabaseName() const { return database_name; }
 
-  //catalog::Schema *GetAddedColumns() const { return added_columns; }
+  // catalog::Schema *GetAddedColumns() const { return added_columns; }
 
   const std::vector<std::string> &GetDroppedColumns() const {
     return dropped_columns;
   }
 
   AlterType GetAlterTableType() const { return type; }
 
-  //function used for rename statement
+  // function used for rename statement
   std::string GetOldName() const { return this->old_names_[0]; }
 
-  //function used for rename statement
+  // function used for rename statement
   std::string GetNewName() const { return this->new_names_[0]; }
 
-  //return true if the alter plan is rename statement
-  bool IsRename() const { return this->type==AlterType::RENAME;}
-private:
-// Target Table
+  // return true if the alter plan is rename statement
+  bool IsRename() const { return this->type == AlterType::RENAME; }
+
+ private:
+  // Target Table
   storage::DataTable *target_table_ = nullptr;
 
   // Table Name
@@ -104,17 +103,17 @@ class AlterPlan : public AbstractPlan {
   std::string database_name;
 
   // Schema delta, define the column txn want to add
-  // catalog::Schema *added_columns;
+  std::vector<std::unique_ptr<catalog::Schema>> added_columns;
   // dropped_column, define the column you want to drop
   std::vector<std::string> dropped_columns;
-
-  //used for store rename function data
+  // changed-type columns, define the column you want to change type
+  std::vector<std::pair<std::string, type::TypeId>> changed_type_columns;
+  // used for store rename function data
   std::vector<std::string> old_names_;
   std::vector<std::string> new_names_;
 
   // Check to either AlterTable Table, INDEX or Rename
   AlterType type;
-
 };
 }
 }