Revert "Removed unused serialization stuff from plan nodes"

pmenon · pmenon · commit ec280f99cfa6 · 2018-05-29T17:03:38.000-04:00
This reverts commit 74427c7.
diff --git a/src/include/planner/abstract_plan.h b/src/include/planner/abstract_plan.h
@@ -20,6 +20,8 @@
 #include "codegen/query_parameters_map.h"
 #include "common/printable.h"
 #include "planner/binding_context.h"
+#include "type/serializeio.h"
+#include "type/serializer.h"
 #include "common/internal_types.h"
 #include "type/value.h"
 #include "util/hash_util.h"
@@ -64,6 +66,8 @@ class AbstractPlan : public Printable {
 
   const AbstractPlan *GetChild(uint32_t child_index) const;
 
+  const AbstractPlan *GetParent() const;
+  
   //===--------------------------------------------------------------------===//
   // Accessors
   //===--------------------------------------------------------------------===//
@@ -107,6 +111,23 @@ class AbstractPlan : public Printable {
 
   virtual std::unique_ptr<AbstractPlan> Copy() const = 0;
 
+  // A plan will be sent to anther node via serialization
+  // So serialization should be implemented by the derived classes
+
+  //===--------------------------------------------------------------------===//
+  // Serialization/Deserialization
+  // Each sub-class will have to implement these functions
+  // After the implementation for each sub-class, we should set these to pure
+  // virtual
+  //===--------------------------------------------------------------------===//
+  virtual bool SerializeTo(SerializeOutput &output UNUSED_ATTRIBUTE) const {
+    return false;
+  }
+  virtual bool DeserializeFrom(SerializeInput &input UNUSED_ATTRIBUTE) {
+    return false;
+  }
+  virtual int SerializeSize() const { return 0; }
+
   virtual hash_t Hash() const;
 
   virtual bool operator==(const AbstractPlan &rhs) const;
@@ -122,10 +143,16 @@ class AbstractPlan : public Printable {
     }
   }
 
+ protected:
+  // only used by its derived classes (when deserialization)
+  AbstractPlan *Parent() const { return parent_; }
+
  private:
   // A plan node can have multiple children
   std::vector<std::unique_ptr<AbstractPlan>> children_;
 
+  AbstractPlan *parent_ = nullptr;
+  
   // TODO: This field is harded coded now. This needs to be changed when
   // optimizer has the cost model and cardinality estimation
   int estimated_cardinality_ = 500000;
diff --git a/src/include/planner/abstract_scan_plan.h b/src/include/planner/abstract_scan_plan.h
@@ -71,6 +71,8 @@ class AbstractScan : public AbstractPlan {
  protected:
   void SetTargetTable(storage::DataTable *table) { target_table_ = table; }
 
+  void AddColumnId(oid_t col_id) { column_ids_.push_back(col_id); }
+
   void SetPredicate(expression::AbstractExpression *predicate) {
     predicate_ = std::unique_ptr<expression::AbstractExpression>(predicate);
   }
diff --git a/src/include/planner/seq_scan_plan.h b/src/include/planner/seq_scan_plan.h
@@ -18,20 +18,10 @@
 
 #include "common/internal_types.h"
 #include "common/logger.h"
-#include "expression/abstract_expression.h"
 #include "planner/abstract_scan_plan.h"
 #include "type/serializer.h"
 
 namespace peloton {
-
-namespace expression {
-class Parameter;
-}  // namespace expression
-
-namespace storage {
-class DataTable;
-}  // namespace storage
-
 namespace planner {
 
 class SeqScanPlan : public AbstractScan {
@@ -58,6 +48,15 @@ class SeqScanPlan : public AbstractScan {
 
   void SetParameterValues(std::vector<type::Value> *values) override;
 
+  //===--------------------------------------------------------------------===//
+  // Serialization/Deserialization
+  //===--------------------------------------------------------------------===//
+  bool SerializeTo(SerializeOutput &output) const override;
+  bool DeserializeFrom(SerializeInput &input) override;
+
+  /* For init SerializeOutput */
+  int SerializeSize() const override;
+
   std::unique_ptr<AbstractPlan> Copy() const override {
     auto *new_plan =
         new SeqScanPlan(GetTable(), GetPredicate()->Copy(), GetColumnIds());
diff --git a/src/planner/abstract_plan.cpp b/src/planner/abstract_plan.cpp
@@ -14,6 +14,7 @@
 
 #include "common/logger.h"
 #include "common/macros.h"
+#include "expression/expression_util.h"
 #include "util/hash_util.h"
 
 namespace peloton {
@@ -37,6 +38,8 @@ const AbstractPlan *AbstractPlan::GetChild(uint32_t child_index) const {
   return children_[child_index].get();
 }
 
+const AbstractPlan *AbstractPlan::GetParent() const { return parent_; }
+
 // Get a string representation of this plan
 std::ostream &operator<<(std::ostream &os, const AbstractPlan &plan) {
   os << PlanNodeTypeToString(plan.GetPlanNodeType());
diff --git a/src/planner/seq_scan_plan.cpp b/src/planner/seq_scan_plan.cpp
@@ -6,21 +6,246 @@
 //
 // Identification: src/planner/seq_scan_plan.cpp
 //
-// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
+// Copyright (c) 2015-17, Carnegie Mellon University Database Group
 //
 //===----------------------------------------------------------------------===//
 
 #include "planner/seq_scan_plan.h"
 
+#include "parser/select_statement.h"
+#include "catalog/manager.h"
+#include "catalog/schema.h"
 #include "common/logger.h"
 #include "common/macros.h"
 #include "expression/abstract_expression.h"
+#include "expression/expression_util.h"
 #include "storage/data_table.h"
+#include "storage/storage_manager.h"
 #include "common/internal_types.h"
 
 namespace peloton {
 namespace planner {
 
+//===--------------------------------------------------------------------===//
+// Serialization/Deserialization
+//===--------------------------------------------------------------------===//
+
+/**
+ * The SeqScanPlan has the following members:
+ *   database_id, table_id, predicate, column_id, parent(might be NULL)
+ * TODO: SeqScanPlan doesn't have children, so we don't need to handle it
+ *
+ * Therefore a SeqScanPlan is serialized as:
+ * [(int) total size]
+ * [(int8_t) plan type]
+ * [(int) database_id]
+ * [(int) table_id]
+ * [(int) num column_id]
+ * [(int) column id...]
+ * [(int8_t) expr type]     : if invalid, predicate is null
+ * [(bytes) predicate]      : predicate is Expression
+ * [(int8_t) plan type]     : if invalid, parent is null
+ * [(bytes) parent]         : parent is also a plan
+ *
+ * TODO: parent_ seems never be set or used
+ */
+
+bool SeqScanPlan::SerializeTo(SerializeOutput &output) const {
+  // A placeholder for the total size written at the end
+  int start = output.Position();
+  output.WriteInt(-1);
+
+  // Write the SeqScanPlan type
+  PlanNodeType plan_type = GetPlanNodeType();
+  output.WriteByte(static_cast<int8_t>(plan_type));
+
+  // Write database id and table id
+  if (!GetTable()) {
+    // The plan is not completed
+    return false;
+  }
+  oid_t database_id = GetTable()->GetDatabaseOid();
+  oid_t table_id = GetTable()->GetOid();
+
+  output.WriteInt(static_cast<int>(database_id));
+  output.WriteInt(static_cast<int>(table_id));
+
+  // If column has 0 item, just write the columnid_count with 0
+  int columnid_count = GetColumnIds().size();
+  output.WriteInt(columnid_count);
+
+  // If column has 0 item, nothing happens here
+  for (int it = 0; it < columnid_count; it++) {
+    oid_t col_id = GetColumnIds()[it];
+    output.WriteInt(static_cast<int>(col_id));
+  }
+
+  // Write predicate
+  if (GetPredicate() == nullptr) {
+    // Write the type
+    output.WriteByte(static_cast<int8_t>(ExpressionType::INVALID));
+  } else {
+    // Write the expression type
+    ExpressionType expr_type = GetPredicate()->GetExpressionType();
+    output.WriteByte(static_cast<int8_t>(expr_type));
+  }
+
+  // Write parent, but parent seems never be set or used right now
+  if (GetParent() == nullptr) {
+    // Write the type
+    output.WriteByte(static_cast<int8_t>(PlanNodeType::INVALID));
+  } else {
+    // Write the parent type
+    PlanNodeType parent_type = GetParent()->GetPlanNodeType();
+    output.WriteByte(static_cast<int8_t>(parent_type));
+
+    // Write parent
+    GetParent()->SerializeTo(output);
+  }
+
+  // Write the total length
+  int32_t sz = static_cast<int32_t>(output.Position() - start - sizeof(int));
+  PELOTON_ASSERT(sz > 0);
+  output.WriteIntAt(start, sz);
+
+  return true;
+}
+
+/**
+   * Therefore a SeqScanPlan is serialized as:
+   * [(int) total size]
+   * [(int8_t) plan type]
+   * [(int) database_id]
+   * [(int) table_id]
+   * [(int) num column_id]
+   * [(int) column id...]
+   * [(int8_t) expr type]     : if invalid, predicate is null
+   * [(bytes) predicate]      : predicate is Expression
+   * [(int8_t) plan type]     : if invalid, parent is null
+   * [(bytes) parent]         : parent is also a plan
+ */
+bool SeqScanPlan::DeserializeFrom(SerializeInput &input) {
+  // Read the size of SeqScanPlan class
+  input.ReadInt();
+
+  // Read the type
+  UNUSED_ATTRIBUTE PlanNodeType plan_type =
+      (PlanNodeType)input.ReadEnumInSingleByte();
+  PELOTON_ASSERT(plan_type == GetPlanNodeType());
+
+  // Read database id
+  oid_t database_oid = input.ReadInt();
+
+  // Read table id
+  oid_t table_oid = input.ReadInt();
+
+  // Get table and set it to the member
+  storage::DataTable *target_table = nullptr;
+  try{
+      target_table = static_cast<storage::DataTable *>(
+        storage::StorageManager::GetInstance()->GetTableWithOid(
+              database_oid, table_oid));
+  } catch (CatalogException &e) {
+      LOG_TRACE("Can't find table %d! Return false", table_oid);
+      return false;
+  }
+  SetTargetTable(target_table);
+
+  // Read the number of column_id and set them to column_ids_
+  oid_t columnid_count = input.ReadInt();
+  for (oid_t it = 0; it < columnid_count; it++) {
+    oid_t column_id = input.ReadInt();
+    AddColumnId(column_id);
+  }
+
+  // Read the type
+  ExpressionType expr_type = (ExpressionType)input.ReadEnumInSingleByte();
+
+  // Predicate deserialization
+  if (expr_type != ExpressionType::INVALID) {
+    switch (expr_type) {
+      //            case ExpressionType::COMPARE_IN:
+      //                predicate_ =
+      //                std::unique_ptr<ExpressionType::COMPARE_IN>(new
+      //                ComparisonExpression (101));
+      //                predicate_.DeserializeFrom(input);
+      //              break;
+
+      default: {
+        LOG_ERROR(
+            "Expression deserialization :: Unsupported EXPRESSION_TYPE: %s",
+            ExpressionTypeToString(expr_type).c_str());
+        break;
+      }
+    }
+  }
+
+  // Read the type of parent
+  PlanNodeType parent_type = (PlanNodeType)input.ReadEnumInSingleByte();
+
+  // Parent deserialization
+  if (parent_type != PlanNodeType::INVALID) {
+    switch (expr_type) {
+      //            case ExpressionType::COMPARE_IN:
+      //                predicate_ =
+      //                std::unique_ptr<ExpressionType::COMPARE_IN>(new
+      //                ComparisonExpression (101));
+      //                predicate_.DeserializeFrom(input);
+      //              break;
+
+      default: {
+        LOG_ERROR("Parent deserialization :: Unsupported PlanNodeType: %s",
+                  ExpressionTypeToString(expr_type).c_str());
+        break;
+      }
+    }
+  }
+
+  return true;
+}
+/**
+ *
+ * SeqScanPlan is serialized as:
+ * [(int) total size]
+ * [(int8_t) plan type]
+ * [(int) database_id]
+ * [(int) table_id]
+ * [(int) num column_id]
+ * [(int) column id...]
+ * [(int8_t) expr type]     : if invalid, predicate is null
+ * [(bytes) predicate]      : predicate is Expression
+ * [(int8_t) plan type]     : if invalid, parent is null
+ * [(bytes) parent]         : parent is also a plan
+ *
+ * So, the fixed size part is:
+ *      [(int) total size]   4 +
+ *      [(int8_t) plan type] 1 +
+ *      [(int) database_id]  4 +
+ *      [(int) table_id]     4 +
+ *      [(int) num column_id]4 +
+ *      [(int8_t) expr type] 1 +
+ *      [(int8_t) plan type] 1 =
+ *     the variant part is :
+ *      [(int) column id...]: num column_id * 4
+ *      [(bytes) predicate] : predicate->GetSerializeSize()
+ *      [(bytes) parent]    : parent->GetSerializeSize()
+ */
+int SeqScanPlan::SerializeSize() const {
+  // Fixed size. see the detail above
+  int size_fix = sizeof(int) * 4 + 3;
+  int size_column_ids = GetColumnIds().size() * sizeof(int);
+  int size = size_fix + size_column_ids;
+
+  if (GetPredicate() != nullptr) {
+    size = size + GetPredicate()->SerializeSize();
+  }
+  if (Parent()) {
+    size = size + Parent()->SerializeSize();
+  }
+
+  return size;
+}
+
 void SeqScanPlan::SetParameterValues(std::vector<type::Value> *values) {
   LOG_TRACE("Setting parameter values in Sequential Scan");
 

Original file line number	Diff line number	Diff line change
`@@ -71,6 +71,8 @@ class AbstractScan : public AbstractPlan {`
`71`	`71`	`protected:`
`72`	`72`	`void SetTargetTable(storage::DataTable *table) { target_table_ = table; }`
`73`	`73`
	`74`	`+ void AddColumnId(oid_t col_id) { column_ids_.push_back(col_id); }`
	`75`	`+`
`74`	`76`	`void SetPredicate(expression::AbstractExpression *predicate) {`
`75`	`77`	`predicate_ = std::unique_ptr<expression::AbstractExpression>(predicate);`
`76`	`78`	`}`