RelAlgDagSerializer Struct Reference

#include <RelAlgDagSerializer.h>

Static Public Member Functions
template<class Archive , class RexClass , typename std::enable_if_t< is_rex_class_v< RexClass >> * = nullptr>
static void	serialize (Archive &ar, RexClass &obj, const unsigned int version)
template<class Archive , class... RelAlgNodeClasses>
static void	registerClassesWithArchive (Archive &ar)
template<class Archive , class RelAlgClass , typename std::enable_if_t< is_rel_alg_node_class_v< RelAlgClass >> * = nullptr>
static void	serialize (Archive &ar, RelAlgClass &obj, const unsigned int version)
template<class Archive >
static void	serialize (Archive &ar, RelAlgDag &rel_alg_dag, const unsigned int version)

Detailed Description

Primary struct for serializing the RelAlgNode/Rex/RexScalar nodes in a RelAlgDag instance. All RelAlgDag-related classes/structs that don't have public getter/setter interfaces for serialization-dependent members need to friend this struct for private access and provide a serialization specialization below.

Definition at line 109 of file RelAlgDagSerializer.h.

Member Function Documentation

template<class Archive , class... RelAlgNodeClasses>

static void RelAlgDagSerializer::registerClassesWithArchive ( Archive &  ar )

inlinestatic

Utility method that registers polymorphic-derived classes with the boost archive. Registration is needed to ensure derived classes referenced via polymorphic pointer get properly designated for serialization. See: https://www.boost.org/doc/libs/1_74_0/libs/serialization/doc/serialization.html#registration

NOTE: the class types that need to be serialized are passed as a list of template arguments

Definition at line 206 of file RelAlgDagSerializer.h.

                                                      {
    (ar.template register_type<RelAlgNodeClasses>(), ...);
  }

template<class Archive , class RexClass , typename std::enable_if_t< is_rex_class_v< RexClass >> * = nullptr>

static void RelAlgDagSerializer::serialize ( Archive &  ar, RexClass &  obj, const unsigned int  version  )

inlinestatic

Primary serialization method for Rex/RexScalar-related classes. If you create a new class that inherits from the Rex/RexScalar base class that requires serialization, it needs to be added here.

Making use of "if constexpr" statements to avoid the boilerplate of creating a new templatized method for each class type. This also potentially allows for doing version checking in one spot, if we ever need to version serialization.

Definition at line 122 of file RelAlgDagSerializer.h.

References CHECK.

Referenced by boost::serialization::serialize().

                                                                                {
    if constexpr (std::is_same_v<Rex, RexClass>) {
      (ar & obj.hash_);
    } else if constexpr (std::is_same_v<RexScalar, RexClass>) {
      (ar & boost::serialization::base_object<Rex>(obj));
    } else if constexpr (std::is_same_v<RexAbstractInput, RexClass>) {
      (ar & boost::serialization::base_object<RexScalar>(obj));
      (ar & obj.in_index_);
    } else if constexpr (std::is_same_v<RexLiteral, RexClass>) {
      (ar & boost::serialization::base_object<RexScalar>(obj));
      (ar & obj.literal_);
      (ar & obj.type_);
      (ar & obj.target_type_);
      (ar & obj.scale_);
      (ar & obj.precision_);
      (ar & obj.target_scale_);
      (ar & obj.target_precision_);
    } else if constexpr (std::is_same_v<RexOperator, RexClass>) {
      (ar & boost::serialization::base_object<RexScalar>(obj));
      (ar & obj.op_);
      (ar & obj.operands_);
      (ar & obj.type_);
    } else if constexpr (std::is_same_v<RexSubQuery, RexClass>) {
      (ar & boost::serialization::base_object<RexScalar>(obj));
      (ar & obj.type_);

      // Execution result should not be set before serialization. If it is means
      // RelAlgExecutor got its hands on it first before serialization. This is not
      // advised. Serialization should happen before any RelAlgExecutor processing.
      CHECK(obj.result_);
      CHECK(*obj.result_ == nullptr);

      // BUT we still need to serialize the RexSubQuery::result_. It is a shared_ptr of a
      // shared_ptr. The outer shared ptr should always be defined, pointing to the
      // interior shared_ptr that should be null. The way it is designed, this 2-tiered
      // shared ptr acts as a link between RexSubQuery instances that were deep copied
      // from a parent. A result should not exist, but the link should, so we need to
      // serialize result_ (or find a better linking mechanism)
      (ar & obj.result_);

      (ar & obj.ra_);
    } else if constexpr (std::is_same_v<RexInput, RexClass>) {
      (ar & boost::serialization::base_object<RexAbstractInput>(obj));
      (ar & obj.node_);
    } else if constexpr (std::is_same_v<RexCase, RexClass>) {
      (ar & boost::serialization::base_object<RexScalar>(obj));
      (ar & obj.expr_pair_list_);
      (ar & obj.else_expr_);
    } else if constexpr (std::is_same_v<RexFunctionOperator, RexClass>) {
      (ar & boost::serialization::base_object<RexOperator>(obj));
      (ar & obj.name_);
    } else if constexpr (std::is_same_v<RexWindowFunctionOperator, RexClass>) {
      (ar & boost::serialization::base_object<RexFunctionOperator>(obj));
      (ar & obj.kind_);
      (ar & obj.partition_keys_);
      (ar & obj.order_keys_);
      (ar & obj.collation_);
      (ar & obj.frame_start_bound_);
      (ar & obj.frame_end_bound_);
      (ar & obj.is_rows_);
    } else if constexpr (std::is_same_v<RexRef, RexClass>) {
      (ar & boost::serialization::base_object<RexScalar>(obj));
      (ar & obj.index_);
    } else if constexpr (std::is_same_v<RexAgg, RexClass>) {
      (ar & boost::serialization::base_object<Rex>(obj));
      (ar & obj.agg_);
      (ar & obj.distinct_);
      (ar & obj.type_);
      (ar & obj.operands_);
    } else {
      static_assert(!sizeof(RexClass), "Unhandled Rex class during serialization.");
    }
  }

Here is the caller graph for this function:

template<class Archive , class RelAlgClass , typename std::enable_if_t< is_rel_alg_node_class_v< RelAlgClass >> * = nullptr>

static void RelAlgDagSerializer::serialize ( Archive &  ar, RelAlgClass &  obj, const unsigned int  version  )

inlinestatic

Primary serialization method for RelAlgNode-related classes, including the root RelAlgDag class. If you create a new class that inherits from the RelAlgNode base class that requires serialization, it needs to be added here.

NOTE: Making use of "if constexpr" statements to avoid the boilerplate of creating a new templatized method for each class type.

Definition at line 221 of file RelAlgDagSerializer.h.

                                                                                   {
    if constexpr (std::is_same_v<RelAlgNode, RelAlgClass>) {
      (ar & obj.inputs_);
      (ar & obj.id_);
      (ar & obj.hash_);
      (ar & obj.is_nop_);

      // NOTE: not serializing the id_in_plan_tree_, context_data_, targets_metainfo_,
      // dag_node_id_, query_plan_dag_, & query_plan_dag_hash_ members. They are only
      // needed for RelAlgExecutor pathways and not needed at the time serialization
      // is needed.
    } else if constexpr (std::is_same_v<RelScan, RelAlgClass>) {
      (ar & boost::serialization::base_object<RelAlgNode>(obj));

      // NOTE: we're not serializing anything in regard to the member RelScan::td_. The
      // table descriptor is instead a construction-dependent argument and will be
      // serialized as part of the save/load contruction data. See
      // boost::serialization::save_construct_data override below.
      (ar & obj.field_names_);
      (ar & obj.hint_applied_);
      (ar & obj.hints_);
    } else if constexpr (std::is_same_v<ModifyManipulationTarget, RelAlgClass>) {
      (ar & obj.is_update_via_select_);
      (ar & obj.is_delete_via_select_);
      (ar & obj.varlen_update_required_);
      (ar & obj.target_columns_);
      (ar & obj.force_rowwise_output_);

      // NOTE: we're not serializing table_descriptor_. The table descriptor is
      // instead a constructor-dependent argument and will be saved/loaded as part of
      // custom contructor data. See: boost::serializer::load_construct_data below for
      // more details.
    } else if constexpr (std::is_same_v<RelProject, RelAlgClass>) {
      (ar & boost::serialization::base_object<RelAlgNode>(obj));
      (ar & boost::serialization::base_object<ModifyManipulationTarget>(obj));
      (ar & obj.scalar_exprs_);
      (ar & obj.fields_);
      (ar & obj.hint_applied_);
      (ar & obj.hints_);
      (ar & obj.has_pushed_down_window_expr_);
    } else if constexpr (std::is_same_v<RelAggregate, RelAlgClass>) {
      (ar & boost::serialization::base_object<RelAlgNode>(obj));
      (ar & obj.groupby_count_);
      (ar & obj.agg_exprs_);
      (ar & obj.fields_);
      (ar & obj.hint_applied_);
      (ar & obj.hints_);
    } else if constexpr (std::is_same_v<RelJoin, RelAlgClass>) {
      (ar & boost::serialization::base_object<RelAlgNode>(obj));
      (ar & obj.condition_);
      (ar & obj.join_type_);
      (ar & obj.hint_applied_);
      (ar & obj.hints_);
    } else if constexpr (std::is_same_v<RelFilter, RelAlgClass>) {
      (ar & boost::serialization::base_object<RelAlgNode>(obj));
      (ar & obj.filter_);
    } else if constexpr (std::is_same_v<RelLeftDeepInnerJoin, RelAlgClass>) {
      (ar & boost::serialization::base_object<RelAlgNode>(obj));
      (ar & obj.condition_);
      (ar & obj.outer_conditions_per_level_);
      (ar & obj.original_filter_);
      (ar & obj.original_joins_);
    } else if constexpr (std::is_same_v<RelCompound, RelAlgClass>) {
      (ar & boost::serialization::base_object<RelAlgNode>(obj));
      (ar & boost::serialization::base_object<ModifyManipulationTarget>(obj));

      (ar & obj.filter_expr_);
      (ar & obj.groupby_count_);
      (ar & obj.agg_exprs_);
      (ar & obj.fields_);
      (ar & obj.is_agg_);
      (ar & obj.scalar_sources_);
      (ar & obj.target_exprs_);
      (ar & obj.hint_applied_);
      (ar & obj.hints_);
    } else if constexpr (std::is_same_v<RelSort, RelAlgClass>) {
      (ar & boost::serialization::base_object<RelAlgNode>(obj));
      (ar & obj.collation_);
      (ar & obj.limit_);
      (ar & obj.offset_);
    } else if constexpr (std::is_same_v<RelModify, RelAlgClass>) {
      (ar & boost::serialization::base_object<RelAlgNode>(obj));
      // NOTE: not serializing anything in regard to RelModify::catalog_ or
      // table_descriptor_ members. They will be used as constructor-dependent arguments
      // instead and will be saved/loaded with custom constuctor data. See:
      // RelAlgSerializer for more.
      (ar & obj.flattened_);
      (ar & obj.operation_);
      (ar & obj.target_column_list_);
    } else if constexpr (std::is_same_v<RelTableFunction, RelAlgClass>) {
      (ar & boost::serialization::base_object<RelAlgNode>(obj));
      (ar & obj.function_name_);
      (ar & obj.fields_);
      (ar & obj.col_inputs_);
      (ar & obj.table_func_inputs_);
      (ar & obj.target_exprs_);
    } else if constexpr (std::is_same_v<RelLogicalValues, RelAlgClass>) {
      (ar & boost::serialization::base_object<RelAlgNode>(obj));
      (ar & obj.tuple_type_);
      (ar & obj.values_);
    } else if constexpr (std::is_same_v<RelLogicalUnion, RelAlgClass>) {
      (ar & boost::serialization::base_object<RelAlgNode>(obj));
      (ar & obj.is_all_);
    } else {
      static_assert(!sizeof(RelAlgClass),
                    "Unhandled RelAlgNode class during serialization");
    }
  }

template<class Archive >

static void RelAlgDagSerializer::serialize ( Archive &  ar, RelAlgDag &  rel_alg_dag, const unsigned int  version  )

inlinestatic

Primary serialization method for the RelAlgDag clas.

Definition at line 334 of file RelAlgDagSerializer.h.

References RelAlgDag::build_state_, RelAlgDag::global_hints_, RelAlgDag::nodes_, RelAlgDag::query_hint_, and RelAlgDag::subqueries_.

                                                                                         {
    // Need to register all RelAlgNode and RexRexScalar-derived classes for
    // serialization. This is to ensure derived classes referenced via polymorphic
    // pointer get properly designated for serialization.
    registerClassesWithArchive<Archive, REL_ALG_NODE_DERIVED_CLASSES>(ar);
    registerClassesWithArchive<Archive, REX_DERIVED_CLASSES>(ar);

    // NOTE: we are not archiving RelTranslatedJoin as it is a RelAlgNode only created
    // during query execution and therefore not relevant here as the serialization
    // archive for the RelAlgDag should only be saved/loaded before query execution to
    // avoid having to serialize any query state

    // now archive relevant RelAlgDag members
    (ar & rel_alg_dag.build_state_);
    (ar & rel_alg_dag.nodes_);
    (ar & rel_alg_dag.subqueries_);
    (ar & rel_alg_dag.query_hint_);
    (ar & rel_alg_dag.global_hints_);
  }

---

The documentation for this struct was generated from the following file:

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/RelAlgDagSerializer/serialization/RelAlgDagSerializer.h