refacted the rename into alter (parser, planner)

Dingshilun · Dingshilun · commit bf20b05331ed · 2018-04-28T20:39:12.000-04:00
diff --git a/src/binder/bind_node_visitor.cpp b/src/binder/bind_node_visitor.cpp
@@ -190,9 +190,6 @@ void BindNodeVisitor::Visit(parser::TransactionStatement *) {}
 void BindNodeVisitor::Visit(parser::AlterTableStatement *node) {
   node->TryBindDatabaseName(default_database_name_);
 }
-void BindNodeVisitor::Visit(parser::RenameFuncStatement *node) {
-  node->TryBindDatabaseName(default_database_name_);
-}
 void BindNodeVisitor::Visit(parser::AnalyzeStatement *node) {
   node->TryBindDatabaseName(default_database_name_);
 }
diff --git a/src/executor/alter_executor.cpp b/src/executor/alter_executor.cpp
@@ -21,8 +21,9 @@ namespace executor {
 
 // Constructor for alter table executor
 AlterExecutor::AlterExecutor(const planner::AbstractPlan *node,
-                             ExecutorContext *executor_context, bool isAlter)
-    : AbstractExecutor(node, executor_context), isAlter_(isAlter) {}
+                             ExecutorContext *executor_context)
+    : AbstractExecutor(node, executor_context),
+      isAlter_(!reinterpret_cast<const planner::AlterPlan *>(node)->IsRename()) {}
 
 // Initialize executor
 // Nothing to initialize for now
@@ -37,7 +38,7 @@ bool AlterExecutor::DExecute() {
   LOG_TRACE("Executing Drop...");
   bool result = false;
   if (!isAlter_) {
-    const planner::RenamePlan &node = GetPlanNode<planner::RenamePlan>();
+    const planner::AlterPlan &node = GetPlanNode<planner::AlterPlan>();
     auto current_txn = executor_context_->GetTransaction();
     result = RenameColumn(node, current_txn);
   } else {
@@ -58,7 +59,7 @@ bool AlterExecutor::DExecute() {
 }
 
 bool AlterExecutor::RenameColumn(
-    const peloton::planner::RenamePlan &node,
+    const peloton::planner::AlterPlan &node,
     peloton::concurrency::TransactionContext *txn) {
   auto database_name = node.GetDatabaseName();
   auto table_name = node.GetTableName();
diff --git a/src/executor/plan_executor.cpp b/src/executor/plan_executor.cpp
@@ -336,13 +336,9 @@ executor::AbstractExecutor *BuildExecutorTree(
       child_executor =
           new executor::PopulateIndexExecutor(plan, executor_context);
       break;
-    case PlanNodeType::RENAME:
-      child_executor =
-          new executor::AlterExecutor(plan, executor_context, false);
-      break;
     case PlanNodeType::ALTER:
       child_executor =
-          new executor::AlterExecutor(plan, executor_context, true);
+          new executor::AlterExecutor(plan, executor_context);
       break;
     default:
       LOG_ERROR("Unsupported plan node type : %s",
diff --git a/src/include/binder/bind_node_visitor.h b/src/include/binder/bind_node_visitor.h
@@ -68,7 +68,6 @@ class BindNodeVisitor : public SqlNodeVisitor {
   void Visit(parser::CopyStatement *) override;
   void Visit(parser::AnalyzeStatement *) override;
   void Visit(parser::AlterTableStatement *) override;
-  void Visit(parser::RenameFuncStatement *) override;
 
   void Visit(expression::CaseExpression *expr) override;
   void Visit(expression::SubqueryExpression *expr) override;
diff --git a/src/include/common/sql_node_visitor.h b/src/include/common/sql_node_visitor.h
@@ -21,7 +21,6 @@ class CreateFunctionStatement;
 class InsertStatement;
 class DeleteStatement;
 class DropStatement;
-class RenameFuncStatement;
 class AlterTableStatement;
 class ExplainStatement;
 class PrepareStatement;
@@ -84,7 +83,6 @@ class SqlNodeVisitor {
   virtual void Visit(parser::CopyStatement *) {}
   virtual void Visit(parser::AnalyzeStatement *) {}
   virtual void Visit(parser::AlterTableStatement *) {}
-  virtual void Visit(parser::RenameFuncStatement *) {}
   virtual void Visit(parser::ExplainStatement *){};
 
   virtual void Visit(expression::ComparisonExpression *expr);
diff --git a/src/include/executor/alter_executor.h b/src/include/executor/alter_executor.h
@@ -15,7 +15,6 @@
 #include "concurrency/transaction_context.h"
 #include "executor/abstract_executor.h"
 #include "planner/alter_plan.h"
-#include "planner/rename_plan.h"
 
 namespace peloton {
 
@@ -33,7 +32,7 @@ class AlterExecutor : public AbstractExecutor {
   AlterExecutor &operator=(AlterExecutor &&) = delete;
 
   AlterExecutor(const planner::AbstractPlan *node,
-                ExecutorContext *executor_context, bool isAlter);
+                ExecutorContext *executor_context);
 
   ~AlterExecutor() {}
 
@@ -42,7 +41,7 @@ class AlterExecutor : public AbstractExecutor {
 
   bool DExecute();
 
-  bool RenameColumn(const planner::RenamePlan &node,
+  bool RenameColumn(const planner::AlterPlan &node,
                     concurrency::TransactionContext *txn);
 
   bool DropColumn(const planner::AlterPlan &node,
diff --git a/src/include/optimizer/query_node_visitor.h b/src/include/optimizer/query_node_visitor.h
@@ -29,7 +29,6 @@ class CopyStatement;
 class AnalyzeStatement;
 class VariableSetStatement;
 class JoinDefinition;
-class RenameFuncStatement;
 class AlterTableStatement;
 struct TableRef;
 
diff --git a/src/include/optimizer/query_to_operator_transformer.h b/src/include/optimizer/query_to_operator_transformer.h
@@ -63,7 +63,6 @@ class QueryToOperatorTransformer : public SqlNodeVisitor {
   void Visit(parser::UpdateStatement *op) override;
   void Visit(parser::CopyStatement *op) override;
   void Visit(parser::AnalyzeStatement *op) override;
-  void Visit(parser::RenameFuncStatement *op) override;
   void Visit(parser::AlterTableStatement *op) override;
   void Visit(expression::ComparisonExpression *expr) override;
   void Visit(expression::OperatorExpression *expr) override;
diff --git a/src/include/parser/postgresparser.h b/src/include/parser/postgresparser.h
@@ -293,10 +293,8 @@ class PostgresParser {
   static expression::AbstractExpression *SubqueryExprTransform(SubLink *node);
 
   // transform helper for alter table statement
-  static parser::AlterTableStatement *AlterTransform(AlterTableStmt *root);
+  static parser::AlterTableStatement *AlterTransform(Node *root);
 
-  // transform helper for alter rename statement
-  static parser::RenameFuncStatement *RenameTransform(RenameStmt *root);
 };
 
 }  // namespace parser
diff --git a/src/include/parser/statements.h b/src/include/parser/statements.h
@@ -25,7 +25,6 @@
 #include "explain_statement.h"
 #include "insert_statement.h"
 #include "prepare_statement.h"
-#include "rename_function_statement.h"
 #include "select_statement.h"
 #include "sql_statement.h"
 #include "transaction_statement.h"
diff --git a/src/optimizer/optimizer.cpp b/src/optimizer/optimizer.cpp
@@ -42,7 +42,6 @@
 #include "planner/projection_plan.h"
 #include "planner/seq_scan_plan.h"
 #include "planner/alter_plan.h"
-#include "planner/rename_plan.h"
 
 #include "storage/data_table.h"
 
@@ -155,14 +154,6 @@ unique_ptr<planner::AbstractPlan> Optimizer::HandleDDLStatement(
       ddl_plan = move(alter_plan);
       break;
     }
-    case StatementType::RENAME: {
-      LOG_TRACE("Adding Rename Plan");
-      unique_ptr<planner::AbstractPlan> rename_plan(
-          new planner::RenamePlan((parser::RenameFuncStatement *)tree));
-      ddl_plan = move(rename_plan);
-      LOG_TRACE("plan build complete");
-      break;
-    }
     case StatementType::DROP: {
       LOG_TRACE("Adding Drop plan...");
       unique_ptr<planner::AbstractPlan> drop_plan(
diff --git a/src/optimizer/query_to_operator_transformer.cpp b/src/optimizer/query_to_operator_transformer.cpp
@@ -336,8 +336,6 @@ void QueryToOperatorTransformer::Visit(
     UNUSED_ATTRIBUTE parser::ExecuteStatement *op) {}
 void QueryToOperatorTransformer::Visit(
     UNUSED_ATTRIBUTE parser::TransactionStatement *op) {}
-void QueryToOperatorTransformer::Visit(
-    UNUSED_ATTRIBUTE parser::RenameFuncStatement *op) {}
 void QueryToOperatorTransformer::Visit(
     UNUSED_ATTRIBUTE parser::AlterTableStatement *op) {}
 void QueryToOperatorTransformer::Visit(parser::UpdateStatement *op) {
diff --git a/src/parser/postgresparser.cpp b/src/parser/postgresparser.cpp
@@ -1730,94 +1730,92 @@ parser::TransactionStatement *PostgresParser::TransactionTransform(
 }
 
 parser::AlterTableStatement *PostgresParser::AlterTransform(
-    AlterTableStmt *root) {
-  // TODO (shilun) adding alter type check
-  // 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());
-  if (relation->relname) {
-    result->table_info_->table_name = strdup(relation->relname);
-  }
-  if (relation->catalogname) {
-    result->table_info_->database_name = strdup(relation->catalogname);
-  }
-
-  for (auto cell = root->cmds->head; cell != NULL; cell = cell->next) {
-    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));
-      result->type = AlterTableStatement::AlterTableType::DROP;
-      break;
-    default: {
+    Node *root) {
+  switch(root->type){
+  case T_RenameStmt:{
+    RenameStmt *newRoot = reinterpret_cast<RenameStmt *>(root);
+    if (newRoot->renameType != ObjectType::OBJECT_COLUMN) {
       throw NotImplementedException(StringUtil::Format(
-          "Alter Table type %d not supported yet...\n", cmd->subtype));
+          "Rename type %d not supported yes...\n", newRoot->relationType));
     }
+    parser::AlterTableStatement *result = new parser::AlterTableStatement(
+        parser::AlterTableStatement::AlterTableType::RENAME);
+    RangeVar *relation = newRoot->relation;
+    result->table_info_ =
+        std::unique_ptr<parser::TableInfo>(new parser::TableInfo());
+    if (relation->relname) {
+      result->table_info_.get()->table_name = strdup(relation->relname);
     }
+    if (relation->catalogname) {
+      result->table_info_.get()->database_name = strdup(relation->catalogname);
+    }
+    if (newRoot->subname) {
+      result->oldName = strdup(newRoot->subname);
+    }
+    if (newRoot->newname) {
+      result->newName = strdup(newRoot->newname);
+    }
+    LOG_TRACE("finished transform");
+    return result;
   }
-  return result;
-}
-
-/**
- * RenameTransorm - right now we only support
- * ALTER TABLE [ ONLY ] name [ * ]
-    RENAME [ COLUMN ] column TO new_column
- * @param root
- * @return
- */
-parser::RenameFuncStatement *PostgresParser::RenameTransform(RenameStmt *root) {
-  if (root->renameType != ObjectType::OBJECT_COLUMN) {
-    throw NotImplementedException(StringUtil::Format(
-        "Rename type %d not supported yes...\n", root->relationType));
-  }
-  parser::RenameFuncStatement *result = new parser::RenameFuncStatement(
-      parser::RenameFuncStatement::ObjectType::COLUMN);
-  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);
-    LOG_TRACE("root->relname: %s", relation->relname);
-  }
-  if (relation->catalogname) {
-    result->table_info_->database_name = strdup(relation->catalogname);
-    LOG_TRACE("root->catalogname: %s", relation->catalogname);
-  }
-  if (root->subname) {
-    result->oldName = strdup(root->subname);
-    LOG_TRACE("root->subname: %s", root->subname);
+  case T_AlterTableStmt: {
+    // TODO (shilun) adding alter type check
+    // Currently we only support add/drop column type
+    AlterTableStmt *newRoot = reinterpret_cast<AlterTableStmt *>(root);
+    parser::AlterTableStatement* result =
+        new AlterTableStatement(AlterTableStatement::AlterTableType::INVALID);
+
+    // Get database and table name
+    RangeVar* relation = newRoot->relation;
+    result->table_info_ = std::unique_ptr<parser::TableInfo>(new parser::TableInfo());
+    if (relation->relname) {
+      result->table_info_.get()->table_name = strdup(relation->relname);
+    }
+    if (relation->catalogname) {
+      result->table_info_.get()->database_name = strdup(relation->catalogname);
+    }
+
+    for (auto cell = newRoot->cmds->head; cell != NULL; cell = cell->next) {
+      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));
+        result->type = AlterTableStatement::AlterTableType::DROP;
+        break;
+      default: {
+        throw NotImplementedException(StringUtil::Format(
+            "Alter Table type %d not supported yet...\n", cmd->subtype));
+      }
+      }
+    }
+    return result;
   }
-  if (root->newname) {
-    result->newName = strdup(root->newname);
-    LOG_TRACE("root->newname: %s", root->newname);
+  default:
+    LOG_ERROR("Not supported Alter Node type yet");
+    throw NotImplementedException(StringUtil::Format(
+        "Alter Table type %d not supported yet...", root->type));
   }
-  LOG_TRACE("finished transform");
-  return result;
+
 }
 
+
 // This function transfers a single Postgres statement into
 // a Peloton SQLStatement object. It checks the type of
 // Postgres parsenode of the input and call the corresponding
 // helper function.
 parser::SQLStatement *PostgresParser::NodeTransform(Node *stmt) {
   parser::SQLStatement *result = nullptr;
   switch (stmt->type) {
+    case T_RenameStmt:// also use alter transform to transform the node
     case T_AlterTableStmt:
       // TODO (Shilun): adding T_ALTER_TABLE_STMT
-      result = AlterTransform(reinterpret_cast<AlterTableStmt *>(stmt));
-      break;
-    case T_RenameStmt:
-      result = RenameTransform(reinterpret_cast<RenameStmt *>(stmt));
+      result = AlterTransform(stmt);
       break;
     case T_SelectStmt:
       result = SelectTransform(reinterpret_cast<SelectStmt *>(stmt));
diff --git a/src/planner/alter_plan.cpp b/src/planner/alter_plan.cpp

Original file line number	Diff line number	Diff line change
`@@ -190,9 +190,6 @@ void BindNodeVisitor::Visit(parser::TransactionStatement *) {}`
`190`	`190`	`void BindNodeVisitor::Visit(parser::AlterTableStatement *node) {`
`191`	`191`	`node->TryBindDatabaseName(default_database_name_);`
`192`	`192`	`}`
`193`		`-void BindNodeVisitor::Visit(parser::RenameFuncStatement *node) {`
`194`		`- node->TryBindDatabaseName(default_database_name_);`
`195`		`-}`
`196`	`193`	`void BindNodeVisitor::Visit(parser::AnalyzeStatement *node) {`
`197`	`194`	`node->TryBindDatabaseName(default_database_name_);`
`198`	`195`	`}`