This commit added parser support of alter table

    - added alter and rename plan and statements
    - modified optimizor to bind db name and make plans
    - modified parsenodes
    - added node to string support and vice versa
    - added nodetransform of alter table

Author: Dingshilun

src/include/parser/alter_statement.h

@@ -22,36 +22,42 @@ namespace parser {
  * @brief Represents "ALTER TABLE add column COLUMN_NAME COLUMN_TYPE"
  * TODO: add implementation of AlterTableStatement
  */
-class AlterTableStatement : public TableRefStatement {
- public:
-  enum class AlterTableType { INVALID = 0, ADD = 1, DROP = 2 };
+struct AlterTableStatement : TableRefStatement {
+  enum class AlterTableType { INVALID = 0, ADD = 1, DROP = 2, RENAME = 3 };
   AlterTableStatement(AlterTableType type)
       : TableRefStatement(StatementType::ALTER),
         type(type),
-        names(new std::vector<char *>) {}
+        names(new std::vector<char*>),
+        oldName(nullptr),
+        newName(nullptr)
+        {};
 
   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 (oldName) delete oldName;
+    if (newName) delete newName;
   }
 
-  virtual void Accept(SqlNodeVisitor *v) override { v->Visit(this); }
-
-  const std::string GetInfo(UNUSED_ATTRIBUTE int num_indent) const override {
-    return std::string{};
-  }
-
-  const std::string GetInfo() const override { return std::string{}; }
+  virtual void Accept(SqlNodeVisitor* v) override { v->Visit(this); }
 
   AlterTableType type;
 
   // Dropped columns
-  std::vector<char *> *names;
+  std::vector<char*>* names;
 
   // Added columns
-  // std::vector<ColumnDefinition*>* columns;
+  //std::vector<ColumnDefinition*>* columns;
+
+    // the name that needs to be changed
+  char *oldName;
+  char *newName;
 };
 
 }  // End parser namespace

src/include/parser/rename_function_statement.h

@@ -15,23 +15,106 @@
 #include "parser/alter_statement.h"
 namespace peloton {
 
+namespace parser {
+class AlterTableStatement;
+}
+namespace catalog {
+class Schema;
+}
+namespace storage {
+class DataTable;
+}
+
 namespace planner {
 /** @brief The plan used for altering
  *  TODO: adding support for add/drop column
  */
 class AlterPlan : public AbstractPlan {
  public:
   AlterPlan() = delete;
-  explicit AlterPlan(UNUSED_ATTRIBUTE parser::AlterTableStatement *parse_tree) {
-    LOG_TRACE("%s", parse_tree->GetInfo().c_str());
-  }
+
+  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> &old_names,
+                     const std::vector<std::string> &new_names, AlterType a_type);
+  explicit AlterPlan(parser::AlterTableStatement *parse_tree);
+
   virtual ~AlterPlan() {}
 
-  virtual PlanNodeType GetPlanNodeType() const override {
-    return PlanNodeType::ALTER;
+  virtual PlanNodeType GetPlanNodeType() const { return PlanNodeType::ALTER; }
+
+  virtual std::unique_ptr<AbstractPlan> Copy() { return nullptr; }
+
+  const std::string GetInfo() const {
+    return StringUtil::Format("AlterPlan table:%s, database:%s",
+                              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;
+    }
   }
 
-  virtual std::unique_ptr<AbstractPlan> Copy() const override { return nullptr; }
+  std::string GetTableName() const { return table_name; }
+
+  std::string GetDatabaseName() const { return database_name; }
+
+  //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
+  std::string GetOldName() const { return this->old_names_[0]; }
+
+  //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
+  storage::DataTable *target_table_ = nullptr;
+
+  // Table Name
+  std::string table_name;
+
+  // Database Name
+  std::string database_name;
+
+  // Schema delta, define the column txn want to add
+  // 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
+  std::vector<std::string> old_names_;
+  std::vector<std::string> new_names_;
+
+  // Check to either AlterTable Table, INDEX or Rename
+  AlterType type;
+
 };
 }
 }