boost::serialization Namespace Reference

Classes
struct	is_catalog_rel_alg_node
struct	is_modify_target_rel_alg_node

Functions
template<class Archive >
void	serialize (Archive &ar, RegisteredQueryHint &query_hint, const unsigned int version)
template<class Archive >
void	serialize (Archive &ar, ExplainedQueryHint &query_hint, const unsigned int version)
template<class Archive >
void	save (Archive &ar, const ExplainedQueryHint &query_hint, const unsigned int version)
template<class Archive >
void	load (Archive &ar, ExplainedQueryHint &query_hint, const unsigned int version)
template<class Archive >
void	save_construct_data (Archive &ar, const ExplainedQueryHint *query_hint, const unsigned int version)
template<class Archive >
void	load_construct_data (Archive &ar, ExplainedQueryHint *query_hint, const unsigned int version)
template<class RelAlgType , typename std::enable_if_t< all_serializable_rel_alg_classes_v< RelAlgType >> * = nullptr>
void	serialize (boost::archive::text_iarchive &ar, RelAlgType &obj, const unsigned int version)
template<class RelAlgType , typename std::enable_if_t< all_serializable_rel_alg_classes_v< RelAlgType >> * = nullptr>
void	serialize (boost::archive::text_oarchive &ar, RelAlgType &obj, const unsigned int version)
template<class Archive >
void	serialize (Archive &ar, boost::blank &blank, const unsigned int version)
template<class RelAlgNodeType , typename std::enable_if_t< is_catalog_rel_alg_node_v< RelAlgNodeType >> * = nullptr>
void	save_construct_data (boost::archive::text_oarchive &ar, const RelAlgNodeType *node, const unsigned int version)
template<class RelAlgNodeType >
void	construct_catalog_rel_alg_node (RelAlgNodeType *node, const Catalog_Namespace::Catalog *cat, const TableDescriptor *td)
void	construct_catalog_rel_alg_node (RelModify *node, const Catalog_Namespace::Catalog &cat, const TableDescriptor *td)
void	construct_catalog_rel_alg_node (RelScan *node, const Catalog_Namespace::Catalog &cat, const TableDescriptor *td)
template<class RelAlgNodeType , typename std::enable_if_t< is_catalog_rel_alg_node< RelAlgNodeType >::value > * = nullptr>
void	load_construct_data (boost::archive::text_iarchive &ar, RelAlgNodeType *node, const unsigned int version)
template<class Archive >
void	serialize (Archive &ar, RexWindowFunctionOperator::RexWindowBound &window_bound, const unsigned int version)
template<class Archive >
void	serialize (Archive &, SortField &, const unsigned int)
template<class Archive >
void	save_construct_data (Archive &ar, const SortField *sort_field, const unsigned int version)
template<class Archive >
void	load_construct_data (Archive &ar, SortField *sort_field, const unsigned int version)
template<class Archive >
void	serialize (Archive &ar, SQLTypeInfo &type_info, const unsigned int version)
template<class Archive >
void	save (Archive &ar, const SQLTypeInfo &type_info, const unsigned int version)
template<class Archive >
void	load (Archive &ar, SQLTypeInfo &type_info, const unsigned int version)
template<class Archive , class T >
void	serialize (Archive &ar, std::optional< T > &in_opt, const unsigned int version)
template<class Archive >
void	serialize (Archive &, TargetMetaInfo &, const unsigned int)
template<class Archive >
void	save_construct_data (Archive &ar, const TargetMetaInfo *target_meta, const unsigned int version)
template<class Archive >
void	load_construct_data (Archive &ar, TargetMetaInfo *target_meta, const unsigned int version)

Variables
template<class T >
constexpr bool	is_catalog_rel_alg_node_v = is_catalog_rel_alg_node<T>::value
template<class T >
constexpr bool	is_modify_target_rel_alg_node_v

Function Documentation

template<class RelAlgNodeType >

void boost::serialization::construct_catalog_rel_alg_node ( RelAlgNodeType *  node, const Catalog_Namespace::Catalog *  cat, const TableDescriptor *  td  )

inline

Construction templates for TableDescriptor dependent classes

Definition at line 467 of file RelAlgDagSerializer.h.

Referenced by load_construct_data().

                                                                      {
  ::new (node) RelAlgNodeType(td, cat);
}

Here is the caller graph for this function:

void boost::serialization::construct_catalog_rel_alg_node ( RelModify *  node, const Catalog_Namespace::Catalog &  cat, const TableDescriptor *  td  )

inline

RelModify construction specialization, which requires a catalog reference

Definition at line 476 of file RelAlgDagSerializer.h.

                                                                      {
  ::new (node) RelModify(cat, td);
}

void boost::serialization::construct_catalog_rel_alg_node ( RelScan *  node, const Catalog_Namespace::Catalog &  cat, const TableDescriptor *  td  )

inline

RelScan construction specialization, which requires a catalog reference

Definition at line 485 of file RelAlgDagSerializer.h.

                                                                      {
  ::new (node) RelScan(td, cat);
}

template<class Archive >

void boost::serialization::load	(	Archive &	ar,
		SQLTypeInfo &	type_info,
		const unsigned int	version
	)

Definition at line 52 of file SQLTypeInfoSerializer.h.

References SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), SQLTypeInfo::set_dict_intersection(), SQLTypeInfo::set_dimension(), SQLTypeInfo::set_notnull(), SQLTypeInfo::set_scale(), SQLTypeInfo::set_size(), SQLTypeInfo::set_subtype(), SQLTypeInfo::set_type(), and run_benchmark_import::type.

                                                                           {
  SQLTypes type;
  SQLTypes subtype;
  int dimension{0};
  int scale{0};
  bool notnull{false};
  EncodingType compression;
  int comp_param{0};
  int size{0};
  bool is_dict_intersection{false};

  ar >> type;
  type_info.set_type(type);
  ar >> subtype;
  type_info.set_subtype(subtype);
  ar >> dimension;
  type_info.set_dimension(dimension);
  ar >> scale;
  type_info.set_scale(scale);
  ar >> notnull;
  type_info.set_notnull(notnull);
  ar >> compression;
  type_info.set_compression(compression);
  ar >> comp_param;
  type_info.set_comp_param(comp_param);
  ar >> size;
  type_info.set_size(size);
  ar >> is_dict_intersection;
  if (is_dict_intersection) {
    type_info.set_dict_intersection();
  }
}

Here is the call graph for this function:

template<class Archive >

void boost::serialization::load	(	Archive &	ar,
		ExplainedQueryHint &	query_hint,
		const unsigned int	version
	)

Definition at line 73 of file QueryHintSerializer.h.

References ExplainedQueryHint::setInheritPaths(), ExplainedQueryHint::setKVOptions(), and ExplainedQueryHint::setListOptions().

Referenced by load_module(), ReductionInterpreterImpl::runLoad(), tf_test_torch_load_model(), and anonymous_namespace{ResultSetReductionCodegen.cpp}::translate_body().

                                                                                   {
  std::vector<int> inherit_paths;
  std::vector<std::string> list_options;
  std::unordered_map<std::string, std::string> kv_options;
  ar >> inherit_paths;
  query_hint.setInheritPaths(inherit_paths);
  ar >> list_options;
  query_hint.setListOptions(list_options);
  ar >> kv_options;
  query_hint.setKVOptions(kv_options);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class Archive >

void boost::serialization::load_construct_data ( Archive &  ar, SortField *  sort_field, const unsigned int  version  )

inline

Definition at line 44 of file SortFieldSerializer.h.

References field().

                                                            {
  size_t field;
  SortDirection sort_dir;
  NullSortedPosition nulls_pos;
  ar >> field;
  ar >> sort_dir;
  ar >> nulls_pos;
  ::new (sort_field) SortField(field, sort_dir, nulls_pos);
}

Here is the call graph for this function:

template<class Archive >

void boost::serialization::load_construct_data ( Archive &  ar, TargetMetaInfo *  target_meta, const unsigned int  version  )

inline

Definition at line 45 of file TargetMetaInfoSerializer.h.

                                                            {
  std::string resname;
  SQLTypeInfo ti;
  SQLTypeInfo physical_ti;
  ar >> resname;
  ar >> ti;
  ar >> physical_ti;
  ::new (target_meta) TargetMetaInfo(resname, ti, physical_ti);
}

template<class Archive >

void boost::serialization::load_construct_data ( Archive &  ar, ExplainedQueryHint *  query_hint, const unsigned int  version  )

inline

Definition at line 96 of file QueryHintSerializer.h.

                                                            {
  QueryHint hint;
  bool global_hint;
  bool is_marker;
  bool has_kv_type_options;
  ar >> hint;
  ar >> global_hint;
  ar >> is_marker;
  ar >> has_kv_type_options;
  ::new (query_hint)
      ExplainedQueryHint(hint, global_hint, is_marker, has_kv_type_options);
}

template<class RelAlgNodeType , typename std::enable_if_t< is_catalog_rel_alg_node< RelAlgNodeType >::value > * = nullptr>

void boost::serialization::load_construct_data ( boost::archive::text_iarchive &  ar, RelAlgNodeType *  node, const unsigned int  version  )

inline

Loads constructor data and instantiates TableDescriptor-dependent classes by loading the table name and accessing its table descriptor from a thread-local catalog reference.

NOTE: for proper overload resolution of boost::serialization::load_construct_data while maintaining templatization on RelAlgNode type, this function is specialized on the Archive type, in this case boost::archive::text_iarchive. This would break if other archives are used.

Definition at line 504 of file RelAlgDagSerializer.h.

References cat(), CHECK, construct_catalog_rel_alg_node(), Catalog_Namespace::SysCatalog::getCatalog(), and Catalog_Namespace::SysCatalog::instance().

                                                            {
  std::string db_name;
  ar >> db_name;
  const Catalog_Namespace::Catalog* cat{nullptr};
  const TableDescriptor* td{nullptr};
  if (!db_name.empty()) {
    cat = Catalog_Namespace::SysCatalog::instance().getCatalog(db_name).get();
    CHECK(cat) << "Catalog not found for database: " << db_name;
  }

  std::string table_name;
  ar >> table_name;
  if (!table_name.empty()) {
    CHECK(cat);
    td = cat->getMetadataForTable(table_name, false);
    CHECK(td) << "Table metadata not found for table: " << table_name
              << " in catalog: " << cat->name();
  }

  if constexpr (is_modify_target_rel_alg_node_v<RelAlgNodeType>) {
    construct_catalog_rel_alg_node(node, cat, td);
  } else {
    CHECK(cat);
    construct_catalog_rel_alg_node(node, *cat, td);
  }
}

Here is the call graph for this function:

template<class Archive >

void boost::serialization::save	(	Archive &	ar,
		const SQLTypeInfo &	type_info,
		const unsigned int	version
	)

Definition at line 39 of file SQLTypeInfoSerializer.h.

References SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_dimension(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_size(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), and SQLTypeInfo::is_dict_intersection().

                                                                                 {
  ar << type_info.get_type();
  ar << type_info.get_subtype();
  ar << type_info.get_dimension();
  ar << type_info.get_scale();
  ar << type_info.get_notnull();
  ar << type_info.get_compression();
  ar << type_info.get_comp_param();
  ar << type_info.get_size();
  ar << type_info.is_dict_intersection();
}

Here is the call graph for this function:

template<class Archive >

void boost::serialization::save	(	Archive &	ar,
		const ExplainedQueryHint &	query_hint,
		const unsigned int	version
	)

Definition at line 66 of file QueryHintSerializer.h.

References ExplainedQueryHint::getInteritPath(), ExplainedQueryHint::getKVOptions(), and ExplainedQueryHint::getListOptions().

Referenced by tf_test_torch_regression().

                                                                                         {
  ar << query_hint.getInteritPath();
  ar << query_hint.getListOptions();
  ar << query_hint.getKVOptions();
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class Archive >

void boost::serialization::save_construct_data ( Archive &  ar, const SortField *  sort_field, const unsigned int  version  )

inline

Definition at line 35 of file SortFieldSerializer.h.

References SortField::getField(), SortField::getNullsPosition(), and SortField::getSortDir().

                                                            {
  ar << sort_field->getField();
  ar << sort_field->getSortDir();
  ar << sort_field->getNullsPosition();
}

Here is the call graph for this function:

template<class Archive >

void boost::serialization::save_construct_data ( Archive &  ar, const TargetMetaInfo *  target_meta, const unsigned int  version  )

inline

Definition at line 36 of file TargetMetaInfoSerializer.h.

References TargetMetaInfo::get_physical_type_info(), TargetMetaInfo::get_resname(), and TargetMetaInfo::get_type_info().

                                                            {
  ar << target_meta->get_resname();
  ar << target_meta->get_type_info();
  ar << target_meta->get_physical_type_info();
}

Here is the call graph for this function:

template<class Archive >

void boost::serialization::save_construct_data ( Archive &  ar, const ExplainedQueryHint *  query_hint, const unsigned int  version  )

inline

Definition at line 86 of file QueryHintSerializer.h.

References ExplainedQueryHint::getHint(), ExplainedQueryHint::hasKvOptions(), ExplainedQueryHint::hasOptions(), and ExplainedQueryHint::isGlobalHint().

                                                            {
  ar << query_hint->getHint();
  ar << query_hint->isGlobalHint();
  ar << query_hint->hasOptions();
  ar << query_hint->hasKvOptions();
}

Here is the call graph for this function:

template<class RelAlgNodeType , typename std::enable_if_t< is_catalog_rel_alg_node_v< RelAlgNodeType >> * = nullptr>

void boost::serialization::save_construct_data ( boost::archive::text_oarchive &  ar, const RelAlgNodeType *  node, const unsigned int  version  )

inline

Saves constructor data for TableDescriptor-dependent classes by saving out the table descriptor name. The table name seems like the best choice for a synchonization-independent descriptor. It was not immediately obvious whether the table id is the same across all nodes in a distributed cluster, for instance.

NOTE: for proper overload resolution of boost::serialization::save_construct_data while maintaining templatization on RelAlgNode type, this function is specialized on the Archive type, in this case boost::archive::text_oarchive. If other archive types are to be used, then they would need to have specializations added here.

Definition at line 433 of file RelAlgDagSerializer.h.

References CHECK, and Catalog_Namespace::Catalog::name().

                                                            {
  const Catalog_Namespace::Catalog* catalog{nullptr};
  if constexpr (is_modify_target_rel_alg_node_v<RelAlgNodeType>) {
    catalog = node->getModifiedTableCatalog();
  } else {
    catalog = &node->getCatalog();
  }

  if (catalog) {
    ar << catalog->name();
  } else {
    ar << std::string();
  }

  auto* td = node->getTableDescriptor();
  if (td) {
    CHECK(!td->tableName.empty());
    ar << td->tableName;
  } else {
    // we need to serialize an empty string as deserialization will expect to see a
    // string. The empty string will indicate a null table descriptor. There are many
    // circumstances in which a catalog-dependent RelAlgNode might have a null
    // TableDescriptor. Generally speaking, RelScan and RelModify nodes require a valid
    // table descriptor. RelCompound and RelProject do not.
    ar << std::string();
  }
}

Here is the call graph for this function:

template<class Archive >

void boost::serialization::serialize	(	Archive &	,
		SortField &	,
		const unsigned	int
	)

Definition at line 25 of file SortFieldSerializer.h.

                                                         {
  // We will not serialize anything directly from SortField instances and instead
  // serialize constructor data. This is handled in the save/load_construct_data functions
  // below below. See:
  // https://www.boost.org/doc/libs/1_74_0/libs/serialization/doc/serialization.html#constructors
  // for more.
  // We still need to provide this no-op method for compilation tho.
}

template<class Archive >

void boost::serialization::serialize	(	Archive &	,
		TargetMetaInfo &	,
		const unsigned	int
	)

Definition at line 26 of file TargetMetaInfoSerializer.h.

                                                              {
  // We will not serialize anything directly from TargetMetaInfo instances and instead
  // serialize constructor data. This is handled in the save/load_construct_data functions
  // below below. See:
  // https://www.boost.org/doc/libs/1_74_0/libs/serialization/doc/serialization.html#constructors
  // for more.
  // We still need to provide this no-op method for compilation tho.
}

template<class Archive >

void boost::serialization::serialize	(	Archive &	ar,
		RegisteredQueryHint &	query_hint,
		const unsigned int	version
	)

Definition at line 27 of file QueryHintSerializer.h.

References RegisteredQueryHint::aggregate_tree_fanout, RegisteredQueryHint::bbox_intersect_allow_gpu_build, RegisteredQueryHint::bbox_intersect_bucket_threshold, RegisteredQueryHint::bbox_intersect_keys_per_bin, RegisteredQueryHint::bbox_intersect_max_size, RegisteredQueryHint::bbox_intersect_no_cache, RegisteredQueryHint::columnar_output, RegisteredQueryHint::cpu_mode, RegisteredQueryHint::cuda_block_size, RegisteredQueryHint::cuda_grid_size_multiplier, RegisteredQueryHint::dynamic_watchdog, RegisteredQueryHint::force_baseline_hash_join, RegisteredQueryHint::force_one_to_many_hash_join, RegisteredQueryHint::keep_result, RegisteredQueryHint::keep_table_function_result, RegisteredQueryHint::loop_join_inner_table_max_num_rows, RegisteredQueryHint::max_join_hash_table_size, RegisteredQueryHint::ndv_groups_estimator_multiplier, RegisteredQueryHint::opt_cuda_grid_and_block_size, RegisteredQueryHint::preflight_count_query_threshold, RegisteredQueryHint::query_time_limit, RegisteredQueryHint::registered_hint, RegisteredQueryHint::rowwise_output, RegisteredQueryHint::table_reordering_off, RegisteredQueryHint::use_loop_join, RegisteredQueryHint::watchdog, and RegisteredQueryHint::watchdog_max_projected_rows_per_device.

Referenced by BOOST_CLASS_TRACKING(), and anonymous_namespace{ResultSetIteration.cpp}::GeoTargetValueBuilder< GEO_SOURCE_TYPE, GeoTargetFetcher >::build().

                                                                                         {
  (ar & query_hint.cpu_mode);
  (ar & query_hint.columnar_output);
  (ar & query_hint.rowwise_output);
  (ar & query_hint.bbox_intersect_bucket_threshold);
  (ar & query_hint.bbox_intersect_max_size);
  (ar & query_hint.bbox_intersect_allow_gpu_build);
  (ar & query_hint.bbox_intersect_no_cache);
  (ar & query_hint.bbox_intersect_keys_per_bin);
  (ar & query_hint.keep_result);
  (ar & query_hint.keep_table_function_result);
  (ar & query_hint.aggregate_tree_fanout);
  (ar & query_hint.cuda_block_size);
  (ar & query_hint.cuda_grid_size_multiplier);
  (ar & query_hint.opt_cuda_grid_and_block_size);
  (ar & query_hint.watchdog);
  (ar & query_hint.dynamic_watchdog);
  (ar & query_hint.query_time_limit);
  (ar & query_hint.use_loop_join);
  (ar & query_hint.loop_join_inner_table_max_num_rows);
  (ar & query_hint.max_join_hash_table_size);
  (ar & query_hint.force_baseline_hash_join);
  (ar & query_hint.force_one_to_many_hash_join);
  (ar & query_hint.watchdog_max_projected_rows_per_device);
  (ar & query_hint.preflight_count_query_threshold);
  (ar & query_hint.table_reordering_off);
  (ar & query_hint.ndv_groups_estimator_multiplier);
  (ar & query_hint.registered_hint);
}

Here is the caller graph for this function:

template<class Archive >

void boost::serialization::serialize	(	Archive &	ar,
		RexWindowFunctionOperator::RexWindowBound &	window_bound,
		const unsigned int	version
	)

Definition at line 27 of file RexWindowBoundSerializer.h.

References RexWindowFunctionOperator::RexWindowBound::bound_expr, RexWindowFunctionOperator::RexWindowBound::following, RexWindowFunctionOperator::RexWindowBound::is_current_row, RexWindowFunctionOperator::RexWindowBound::order_key, RexWindowFunctionOperator::RexWindowBound::preceding, and RexWindowFunctionOperator::RexWindowBound::unbounded.

                                           {
  (ar & window_bound.unbounded);
  (ar & window_bound.preceding);
  (ar & window_bound.following);
  (ar & window_bound.is_current_row);
  (ar & window_bound.bound_expr);
  (ar & window_bound.order_key);
}

template<class Archive >

void boost::serialization::serialize	(	Archive &	ar,
		SQLTypeInfo &	type_info,
		const unsigned int	version
	)

Definition at line 31 of file SQLTypeInfoSerializer.h.

                                                                                {
  // need to split serialization of type_info into separate load/store methods defined
  // above. See 'Splitting Free Functions' section of
  // https://www.boost.org/doc/libs/1_74_0/libs/serialization/doc/serialization.html#splitting
  split_free(ar, type_info, version);
}

template<class Archive >

void boost::serialization::serialize	(	Archive &	ar,
		ExplainedQueryHint &	query_hint,
		const unsigned int	version
	)

Definition at line 58 of file QueryHintSerializer.h.

                                                                                        {
  // need to split serialization into separate load/store methods since members are only
  // accessible through getters/setters. See:
  // https://www.boost.org/doc/libs/1_74_0/libs/serialization/doc/serialization.html#splitting
  split_free(ar, query_hint, version);
}

template<class Archive , class T >

void boost::serialization::serialize	(	Archive &	ar,
		std::optional< T > &	in_opt,
		const unsigned int	version
	)

boost surprisingly does not have native support for serializing std::optional values from STL. This is a workaround for that by converting a std::optional to a boost::optional for serialization. There is a compilation issue with using the standard boost::serialization::split_free to handle different pathways for load/store of a std::optional. This compilation issue requires a workaround. The commented out code below is what would be used if the split_free route compiles, so keeping it around in case one day it does work as it would be preferred. More on the compilation issue in comments below.

Definition at line 68 of file StdOptionalSerializer.h.

                                                                                {
  // NOTE: uncomment if we find that a more recent gcc or boost works
  // ::boost::serialization::split_free(ar, in_opt, version);

  // The if constexpr block below is a workaround to what appears to be a gcc v9.4.0 bug.
  // The preferred way to split the load/save code paths is to use the
  // boost::serialization::split_free:
  // https://www.boost.org/doc/libs/1_74_0/libs/serialization/doc/serialization.html#splitting
  //
  // However, doing it the split_free way, which means overriding the save/load free
  // functions for std::optional, results in a very strange compilation error.
  // The parent header file for doing RelAlgDag serialization does a:
  // #include <boost/serialization/shared_ptr.hpp>
  //
  // shared_ptr.hpp in turn does a:
  // #include <boost/serialization/shared_ptr_helper.hpp>
  // see:
  // https://www.boost.org/doc/libs/1_74_0/boost/serialization/shared_ptr.hpp)
  //
  // shared_ptr_helper.hpp has this ifndef block:
  //
  // #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
  // template<class Archive, template<class U> class SPT >
  // void load(
  //   Archive & ar,
  //   SPT< class U > &t,
  //   const unsigned int file_version
  // );
  // #endif
  //
  // see: https://www.boost.org/doc/libs/1_74_0/boost/serialization/shared_ptr_helper.hpp
  //
  // That load free-function declaration confuses gcc, and you get a compilation error
  // like this:
  //
  // clang-format off
  //
  // In file included from /usr/include/c++/9/bits/move.h:55,
  //                  from /usr/include/c++/9/bits/stl_pair.h:59,
  //                  from /usr/include/c++/9/utility:70,
  //                  from /usr/include/c++/9/algorithm:60,
  //                  from ../QueryEngine/Execute.h:20,
  //                  from heavydb-internal/build/QueryEngine/CMakeFiles/QueryEngine.dir/cmake_pch.hxx:5,
  //                  from <command-line>:
  // /usr/include/c++/9/type_traits: In instantiation of ‘struct std::__is_trivially_copy_constructible_impl<boost::serialization::U, true>’:
  // /usr/include/c++/9/type_traits:1157:12:   required from ‘struct std::is_trivially_copy_constructible<boost::serialization::U>’
  // /usr/include/c++/9/type_traits:2938:25:   required from ‘constexpr const bool std::is_trivially_copy_constructible_v<boost::serialization::U>’
  // /usr/include/c++/9/optional:469:12:   required by substitution of ‘template<class Archive, template<class U> class SPT> void boost::serialization::load(Archive&, SPT<boost::serialization::U>&, unsigned int) [with Archive = boost::archive::text_iarchive; SPT = <missing>]’
  // /usr/include/boost/serialization/split_free.hpp:58:13:   required from ‘static void boost::serialization::free_loader<Archive, T>::invoke(Archive&, T&, unsigned int) [with Archive = boost::archive::text_iarchive; T = std::optional<long unsigned int>]’
  // /usr/include/boost/serialization/split_free.hpp:74:18:   required from ‘void boost::serialization::split_free(Archive&, T&, unsigned int) [with Archive = boost::archive::text_iarchive; T = std::optional<long unsigned int>]’
  // ../QueryEngine/RelAlgSerializerOptional.h:52:37:   [ skipping 42 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
  // /usr/include/boost/archive/detail/iserializer.hpp:624:18:   required from ‘void boost::archive::load(Archive&, T&) [with Archive = boost::archive::text_iarchive; T = RelAlgDag]’
  // /usr/include/boost/archive/detail/common_iarchive.hpp:67:22:   required from ‘void boost::archive::detail::common_iarchive<Archive>::load_override(T&) [with T = RelAlgDag; Archive = boost::archive::text_iarchive]’
  // /usr/include/boost/archive/basic_text_iarchive.hpp:70:9:   required from ‘void boost::archive::basic_text_iarchive<Archive>::load_override(T&) [with T = RelAlgDag; Archive = boost::archive::text_iarchive]’
  // /usr/include/boost/archive/text_iarchive.hpp:82:52:   required from ‘void boost::archive::text_iarchive_impl<Archive>::load_override(T&) [with T = RelAlgDag; Archive = boost::archive::text_iarchive]’
  // /usr/include/boost/archive/detail/interface_iarchive.hpp:68:9:   required from ‘Archive& boost::archive::detail::interface_iarchive<Archive>::operator>>(T&) [with T = RelAlgDag; Archive = boost::archive::text_iarchive]’
  // ../QueryEngine/RelAlgDagSerializer/RelAlgDagSerializer.cpp:70:12:   required from here
  // /usr/include/c++/9/type_traits:1150:12: error: invalid use of incomplete type ‘class boost::serialization::U’
  //  1150 |     struct __is_trivially_copy_constructible_impl<_Tp, true>
  //       |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  // In file included from /usr/include/boost/serialization/shared_ptr.hpp:29,
  //                  from ../QueryEngine/RelAlgDagSerializer/RelAlgDagSerializer.h:25,
  //                  from ../QueryEngine/RelAlgDagSerializer/RelAlgDagSerializer.cpp:17:
  // /usr/include/boost/serialization/shared_ptr_helper.hpp:45:16: note: forward declaration of ‘class boost::serialization::U’
  //    45 |     SPT< class U > &t,
  //       |                ^
  // In file included from /usr/include/c++/9/bits/move.h:55,
  //                  from /usr/include/c++/9/bits/stl_pair.h:59,
  //                  from /usr/include/c++/9/utility:70,
  //                  from /usr/include/c++/9/algorithm:60,
  //                  from ../QueryEngine/Execute.h:20,
  //                  from heavydb-internal/build/QueryEngine/CMakeFiles/QueryEngine.dir/cmake_pch.hxx:5,
  //                  from <command-line>:
  //
  //
  // clang-format on
  //
  // It appears as tho there's a gcc bug that confuses the load() free function
  // declaration in shared_ptr_helper.hpp when trying to resolve overrides with the
  // two-argument template and somehow substitutes the second template argument with a
  // boost::serialization::U class type, which does not exist.
  //
  // So the workaround is to use the if contexpr switch and pull the definitions of the
  // load/save free functions for std::optional directly into the serialize override,
  // which works fine and has no other conflicts.
  //
  // If we find that we upgrade to a more recent version of gcc and it works, we can move
  // back to the split_free approach, which is commented out above.

  if constexpr (std::is_same_v<::boost::archive::text_iarchive, Archive>) {
    // load case
    boost::optional<T> boost_opt;
    (ar & boost_opt);

    if (boost_opt) {
      in_opt = *boost_opt;
    } else {
      // probably unnecessary
      in_opt.reset();
    }
  } else {
    // save case
    static_assert(std::is_same_v<::boost::archive::text_oarchive, Archive>);
    boost::optional<T> boost_opt;
    if (in_opt) {
      boost_opt = *in_opt;
    }
    (ar & boost_opt);
  }
}

template<class RelAlgType , typename std::enable_if_t< all_serializable_rel_alg_classes_v< RelAlgType >> * = nullptr>

void boost::serialization::serialize	(	boost::archive::text_iarchive &	ar,
		RelAlgType &	obj,
		const unsigned int	version
	)

boost::serialization::serialize overload for all RelAlgDag-related classes that require serialization.

NOTE: for proper overload resolution of boost::serialization::serialize while maintaining templatization on the RelAlgDag-related class type, this function is specialized on the Archive type. If other archive types are to be used, they need to be specialized here.

Definition at line 370 of file RelAlgDagSerializer.h.

References RelAlgDagSerializer::serialize().

                                           {
  RelAlgDagSerializer::serialize(ar, obj, version);
}

Here is the call graph for this function:

template<class RelAlgType , typename std::enable_if_t< all_serializable_rel_alg_classes_v< RelAlgType >> * = nullptr>

void boost::serialization::serialize	(	boost::archive::text_oarchive &	ar,
		RelAlgType &	obj,
		const unsigned int	version
	)

Definition at line 379 of file RelAlgDagSerializer.h.

References RelAlgDagSerializer::serialize().

                                           {
  RelAlgDagSerializer::serialize(ar, obj, version);
}

Here is the call graph for this function:

template<class Archive >

void boost::serialization::serialize	(	Archive &	ar,
		boost::blank &	blank,
		const unsigned int	version
	)

Needed for boost::variant with a boost::blank item.

Definition at line 389 of file RelAlgDagSerializer.h.

                                                                           {
  // no-op. does nothing with an empty class
}

Variable Documentation

template<class T >

constexpr bool boost::serialization::is_catalog_rel_alg_node_v = is_catalog_rel_alg_node<T>::value

inline

Definition at line 409 of file RelAlgDagSerializer.h.

template<class T >

constexpr bool boost::serialization::is_modify_target_rel_alg_node_v

inline

Initial value:

=
    is_modify_target_rel_alg_node<T>::value

Definition at line 417 of file RelAlgDagSerializer.h.