added alter varchar length support, changed the plan to use schema

addressed bug

Author: Dingshilun

src/executor/alter_executor.cpp

@@ -116,25 +116,22 @@ bool AlterExecutor::AlterTable(const peloton::planner::AlterPlan &node,
       catalog::Schema::CopySchema(old_schema, column_ids));
   auto columns = temp_schema->GetColumns();
   // Step 2: change column type if exists
-  for (auto change_pair : node.GetChangedTypeColumns()) {
+  for (auto &change_col : node.GetChangedTypeColumns().get()->GetColumns()) {
     bool is_found = false;
     oid_t i = 0;
     for (; i < columns.size(); ++i) {
-      if (columns[i].GetName() == change_pair.first) {
+      if (columns[i].GetName() == change_col.GetName()) {
         is_found = true;
         break;
       }
     }
     if (!is_found) {
       LOG_TRACE("Change column type failed: Column %s does not exists",
-                change_pair.first.c_str());
+                change_col.GetName().c_str());
       txn->SetResult(ResultType::FAILURE);
       return false;
     } else {
-      columns[i].SetType(change_pair.second);
-      columns[i].SetInlined();
-      columns[i].SetLength(type::VarlenType::GetTypeSize(change_pair.second));
-
+      columns[i] = std::move(change_col);
       // TODO: decide VARCHAR's size when change type
       // if (change_pair.second == type::TypeId::VARCHAR) {}
     }
@@ -143,10 +140,8 @@ bool AlterExecutor::AlterTable(const peloton::planner::AlterPlan &node,
   // Step 3: append add column to new schema
   // construct add column schema
   std::vector<catalog::Column> add_columns;
-  for (size_t i = 0; i < node.GetAddedColumns().size(); ++i) {
-    for (auto column : node.GetAddedColumns()[i]->GetColumns()) {
-      add_columns.push_back(column);
-    }
+  for (auto column : node.GetAddedColumns()->GetColumns()) {
+    add_columns.push_back(column);
   }
   // Check if added column exists
   for (auto new_column : add_columns) {

src/include/planner/alter_plan.h

@@ -36,7 +36,8 @@ class AlterPlan : public AbstractPlan {
   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,
+      const std::unique_ptr<catalog::Schema> &added_columns,
+      const std::unique_ptr<catalog::Schema> &changed_type_columns,
       AlterType a_type);
   explicit AlterPlan(const std::string &database_name,
                      const std::string &table_name,
@@ -61,7 +62,7 @@ class AlterPlan : public AbstractPlan {
     switch (this->type) {
       case AlterType::ALTER:
         return std::unique_ptr<AbstractPlan>(new AlterPlan(
-            database_name, table_name, dropped_columns, added_columns, type));
+            database_name, table_name, dropped_columns, added_columns, changed_type_columns, type));
       case AlterType::RENAME:
         return std::unique_ptr<AbstractPlan>(new AlterPlan(
             database_name, table_name, old_names_, new_names_, type));
@@ -75,15 +76,15 @@ class AlterPlan : public AbstractPlan {
 
   std::string GetDatabaseName() const { return database_name; }
 
-  const std::vector<std::unique_ptr<catalog::Schema>> &GetAddedColumns() const {
+  const std::unique_ptr<catalog::Schema> &GetAddedColumns() const {
     return added_columns;
   }
 
   const std::vector<std::string> &GetDroppedColumns() const {
     return dropped_columns;
   }
 
-  const std::vector<std::pair<std::string, type::TypeId>> &
+  const std::unique_ptr<catalog::Schema> &
   GetChangedTypeColumns() const {
     return changed_type_columns;
   };
@@ -110,11 +111,11 @@ class AlterPlan : public AbstractPlan {
   std::string database_name;
 
   // Schema delta, define the column txn want to add
-  std::vector<std::unique_ptr<catalog::Schema>> added_columns;
+  std::unique_ptr<catalog::Schema> added_columns;
   // dropped_column, define the column you want to drop
   std::vector<std::string> dropped_columns;
   // changed-type columns, define the column you want to change type
-  std::vector<std::pair<std::string, type::TypeId>> changed_type_columns;
+  std::unique_ptr<catalog::Schema> changed_type_columns;
   // used for store rename function data
   std::vector<std::string> old_names_;
   std::vector<std::string> new_names_;

src/parser/postgresparser.cpp

@@ -1802,15 +1802,16 @@ parser::AlterTableStatement *PostgresParser::AlterTransform(Node *root) {
           }
           case AT_AlterColumnType: {
             ColumnDef *def = (ColumnDef *)cmd->def;
-            TypeName *type_name = def->typeName;
-            char *name = (reinterpret_cast<value *>(
-                              type_name->names->tail->data.ptr_value)
-                              ->val.str);
-            LOG_TRACE("DATA Type is :%s", name);
-            auto type_id = ColumnDefinition::StrToDataType(name);
-            std::unique_ptr<ColumnDefinition> col_def(
-                new ColumnDefinition(cmd->name, type_id));
-            result->changed_type_columns->push_back(std::move(col_def));
+            def->colname = cmd->name;
+            parser::CreateStatement tmp_statement(
+                parser::CreateStatement::CreateType::kTable);
+            LOG_TRACE("Adding change type column");
+            ColumnDefTransform(reinterpret_cast<ColumnDef *>(def),
+                               &tmp_statement);
+            for (size_t i = 0; i < tmp_statement.columns.size();i++){
+              result->changed_type_columns->emplace_back(std::move(tmp_statement.columns[i]));
+            }
+            LOG_TRACE("adding end");
             break;
           }
           default: {

src/planner/alter_plan.cpp

@@ -23,16 +23,15 @@ namespace planner {
 AlterPlan::AlterPlan(
     const std::string &database_name, const std::string &table_name,
     const std::vector<std::string> &dropped_columns,
-    UNUSED_ATTRIBUTE const std::vector<std::unique_ptr<catalog::Schema>>
-        &added_columns_,
+    const std::unique_ptr<catalog::Schema> &added_columns,
+    const std::unique_ptr<catalog::Schema> &changed_type_columns,
     AlterType a_type)
     : table_name(table_name),
       database_name(database_name),
       dropped_columns(dropped_columns),
       type(a_type) {
-  //        for (size_t i=0;i<added_columns.size();i++){
-  //          this->added_columns.push_back(std::move(added_columns_[i]));
-  //        }
+          this->added_columns = std::unique_ptr<catalog::Schema>(new catalog::Schema(*added_columns));
+          this->changed_type_columns = std::unique_ptr<catalog::Schema>(new catalog::Schema(*changed_type_columns));
 }
 
 AlterPlan::AlterPlan(const std::string &database_name,
@@ -85,17 +84,25 @@ AlterPlan::AlterPlan(parser::AlterTableStatement *parse_tree) {
         }
         columns.emplace_back(column);
       }
-      added_columns.emplace_back(
-          std::unique_ptr<catalog::Schema>(new catalog::Schema(columns)));
-
+      added_columns = std::unique_ptr<catalog::Schema>(new catalog::Schema(columns));
+      columns.clear();
       // deal with change column types
       for (size_t i = 0; i < (*parse_tree->changed_type_columns).size(); i++) {
         auto &tmp = (*parse_tree->changed_type_columns)[i];
-        type::TypeId val =
-            parser::ColumnDefinition::GetValueType(tmp.get()->type);
-        std::string name = tmp.get()->name;
-        changed_type_columns.emplace_back(std::make_pair(name, val));
+        type::TypeId val = parser::ColumnDefinition::GetValueType(tmp.get()->type);
+        bool is_inline = (val == type::TypeId::VARCHAR) ? false : true;
+        auto column = catalog::Column(
+            val, type::Type::GetTypeSize(val),
+            std::string((*parse_tree->changed_type_columns)[i].get()->name),
+            is_inline);
+        if ((*parse_tree->changed_type_columns)[i].get()->not_null) {
+          catalog::Constraint constraint(ConstraintType::NOTNULL,
+                                         "con_not_null");
+          column.AddConstraint(constraint);
+        }
+        columns.emplace_back(column);
       }
+      changed_type_columns = std::unique_ptr<catalog::Schema>(new catalog::Schema(columns));
       break;
     }
     default: