Updated optimize to continue support for old/weird/strange AF copy executor

Author: pmenon

src/common/internal_types.cpp

@@ -1382,9 +1382,6 @@ std::string PlanNodeTypeToString(PlanNodeType type) {
     case PlanNodeType::RESULT: {
       return ("RESULT");
     }
-    case PlanNodeType::COPY: {
-      return ("COPY");
-    }
     case PlanNodeType::MOCK: {
       return ("MOCK");
     }
@@ -1394,6 +1391,9 @@ std::string PlanNodeTypeToString(PlanNodeType type) {
     case PlanNodeType::ANALYZE: {
       return ("ANALYZE");
     }
+    case PlanNodeType::EXPORT_EXTERNAL_FILE: {
+      return ("EXPORT_EXTERNAL_FILE");
+    }
     default: {
       throw ConversionException(
           StringUtil::Format("No string conversion for PlanNodeType value '%d'",
@@ -1461,12 +1461,12 @@ PlanNodeType StringToPlanNodeType(const std::string &str) {
     return PlanNodeType::HASH;
   } else if (upper_str == "RESULT") {
     return PlanNodeType::RESULT;
-  } else if (upper_str == "COPY") {
-    return PlanNodeType::COPY;
   } else if (upper_str == "MOCK") {
     return PlanNodeType::MOCK;
   } else if (upper_str == "ANALYZE") {
     return PlanNodeType::ANALYZE;
+  } else if (upper_str == "EXPORT_EXTERNAL_FILE") {
+    return PlanNodeType::EXPORT_EXTERNAL_FILE;
   } else {
     throw ConversionException(StringUtil::Format(
         "No PlanNodeType conversion from string '%s'", upper_str.c_str()));

src/executor/copy_executor.cpp

@@ -6,23 +6,25 @@
 //
 // Identification: src/executor/copy_executor.cpp
 //
-// Copyright (c) 2015-17, Carnegie Mellon University Database Group
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
 //
 //===----------------------------------------------------------------------===//
 
+#include "executor/copy_executor.h"
+
+#include <sys/stat.h>
+#include <sys/mman.h>
+
 #include "common/logger.h"
 #include "catalog/catalog.h"
 #include "concurrency/transaction_manager_factory.h"
-#include "executor/copy_executor.h"
 #include "executor/executor_context.h"
 #include "executor/logical_tile_factory.h"
-#include "planner/copy_plan.h"
+#include "planner/export_external_file_plan.h"
 #include "storage/table_factory.h"
 #include "network/postgres_protocol_handler.h"
 #include "common/exception.h"
 #include "common/macros.h"
-#include <sys/stat.h>
-#include <sys/mman.h>
 
 namespace peloton {
 namespace executor {
@@ -35,7 +37,7 @@ CopyExecutor::CopyExecutor(const planner::AbstractPlan *node,
                            ExecutorContext *executor_context)
     : AbstractExecutor(node, executor_context) {}
 
-CopyExecutor::~CopyExecutor() {}
+CopyExecutor::~CopyExecutor() = default;
 
 /**
  * @brief Basic initialization.
@@ -45,21 +47,19 @@ bool CopyExecutor::DInit() {
   PELOTON_ASSERT(children_.size() == 1);
 
   // Grab info from plan node and check it
-  const planner::CopyPlan &node = GetPlanNode<planner::CopyPlan>();
+  const auto &node = GetPlanNode<planner::ExportExternalFilePlan>();
 
-  bool success = InitFileHandle(node.file_path.c_str(), "w");
+  bool success = InitFileHandle(node.GetFileName().c_str(), "w");
 
   if (success == false) {
-    throw ExecutorException("Failed to create file " + node.file_path +
+    throw ExecutorException("Failed to create file " + node.GetFileName() +
                             ". Try absolute path and make sure you have the "
                             "permission to access this file.");
-    return false;
   }
-  LOG_DEBUG("Created target copy output file: %s", node.file_path.c_str());
+  LOG_DEBUG("Created target copy output file: %s", node.GetFileName().c_str());
   return true;
 }
 
-
 bool CopyExecutor::InitFileHandle(const char *name, const char *mode) {
   auto file = fopen(name, mode);
   if (file == NULL) {

src/executor/plan_executor.cpp

@@ -328,7 +328,7 @@ executor::AbstractExecutor *BuildExecutorTree(
           new executor::CreateFunctionExecutor(plan, executor_context);
       break;
 
-    case PlanNodeType::COPY:
+    case PlanNodeType::EXPORT_EXTERNAL_FILE:
       child_executor = new executor::CopyExecutor(plan, executor_context);
       break;
 

src/include/common/internal_types.h

@@ -596,7 +596,7 @@ enum class PlanNodeType {
 
   // Utility
   RESULT = 70,
-  COPY = 71,
+  EXPORT_EXTERNAL_FILE = 71,
   CREATE_FUNC = 72,
 
   // Test
@@ -1355,6 +1355,7 @@ enum class RuleType : uint32_t {
   INNER_JOIN_TO_HASH_JOIN,
   IMPLEMENT_DISTINCT,
   IMPLEMENT_LIMIT,
+  EXPORT_EXTERNAL_FILE_TO_PHYSICAL,
 
   // Don't move this one
   RewriteDelimiter,

src/include/optimizer/child_property_deriver.h

@@ -59,6 +59,7 @@ class ChildPropertyDeriver : public OperatorVisitor {
   void Visit(const PhysicalSortGroupBy *) override;
   void Visit(const PhysicalDistinct *) override;
   void Visit(const PhysicalAggregate *) override;
+  void Visit(const PhysicalExportExternalFile *) override;
 
  private:
   void DeriveForJoin();

src/include/optimizer/input_column_deriver.h

@@ -93,6 +93,8 @@ class InputColumnDeriver : public OperatorVisitor {
 
   void Visit(const PhysicalAggregate *) override;
 
+  void Visit(const PhysicalExportExternalFile *) override;
+
  private:
   /**
    * @brief Provide all tuple value expressions needed in the expression

src/include/optimizer/operator_node.h

@@ -72,7 +72,8 @@ enum class OpType {
   Update,
   Aggregate,
   HashGroupBy,
-  SortGroupBy
+  SortGroupBy,
+  ExportExternalFile,
 };
 
 //===--------------------------------------------------------------------===//

src/include/optimizer/operator_visitor.h

@@ -6,7 +6,7 @@
 //
 // Identification: src/include/optimizer/operator_visitor.h
 //
-// Copyright (c) 2015-16, Carnegie Mellon University Database Group
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
 //
 //===----------------------------------------------------------------------===//
 
@@ -23,7 +23,7 @@ namespace optimizer {
 
 class OperatorVisitor {
  public:
-  virtual ~OperatorVisitor(){};
+  virtual ~OperatorVisitor() = default;
 
   // Physical operator
   virtual void Visit(const DummyScan *) {}
@@ -49,6 +49,7 @@ class OperatorVisitor {
   virtual void Visit(const PhysicalSortGroupBy *) {}
   virtual void Visit(const PhysicalDistinct *) {}
   virtual void Visit(const PhysicalAggregate *) {}
+  virtual void Visit(const PhysicalExportExternalFile *) {}
 
   // Logical operator
   virtual void Visit(const LeafOperator *) {}

src/include/optimizer/operators.h

@@ -325,12 +325,19 @@ class LogicalUpdate : public OperatorNode<LogicalUpdate> {
 };
 
 //===--------------------------------------------------------------------===//
-// External file get
+// Export to external file
 //===--------------------------------------------------------------------===//
 class LogicalExportExternalFile
     : public OperatorNode<LogicalExportExternalFile> {
  public:
-  static Operator make();
+  static Operator make(ExternalFileFormat format, std::string file_name);
+
+  bool operator==(const BaseOperatorNode &r) override;
+
+  hash_t Hash() const override;
+
+  ExternalFileFormat format;
+  std::string file_name;
 };
 
 //===--------------------------------------------------------------------===//
@@ -604,6 +611,22 @@ class PhysicalUpdate : public OperatorNode<PhysicalUpdate> {
   const std::vector<std::unique_ptr<parser::UpdateClause>> *updates;
 };
 
+//===--------------------------------------------------------------------===//
+// Physical ExportExternalFile
+//===--------------------------------------------------------------------===//
+class PhysicalExportExternalFile
+    : public OperatorNode<PhysicalExportExternalFile> {
+ public:
+  static Operator make(ExternalFileFormat format, std::string file_name);
+
+  bool operator==(const BaseOperatorNode &r) override;
+
+  hash_t Hash() const override;
+
+  ExternalFileFormat format;
+  std::string file_name;
+};
+
 //===--------------------------------------------------------------------===//
 // PhysicalHashGroupBy
 //===--------------------------------------------------------------------===//

src/include/optimizer/plan_generator.h

@@ -94,6 +94,8 @@ class PlanGenerator : public OperatorVisitor {
 
   void Visit(const PhysicalAggregate *) override;
 
+  void Visit(const PhysicalExportExternalFile *) override;
+
  private:
   /**
    * @brief Generate all tuple value expressions of a base table