This is an automated email from the ASF dual-hosted git repository. yiguolei pushed a commit to branch branch-2.1 in repository https://gitbox.apache.org/repos/asf/doris.git
commit 22322a38648cc58463d402da585c3c62458abef2 Author: Jerry Hu <[email protected]> AuthorDate: Fri Jan 26 20:44:02 2024 +0800 [refactor](join) remove unused RowRefListType from join (#30442) --- be/src/pipeline/exec/aggregation_sink_operator.cpp | 5 +- be/src/pipeline/exec/hashjoin_build_sink.cpp | 32 ++++++------ be/src/pipeline/exec/hashjoin_build_sink.h | 7 +++ be/src/vec/common/hash_table/hash_map.h | 2 +- be/src/vec/common/hash_table/hash_map_context.h | 12 ++--- .../common/hash_table/hash_map_context_creator.h | 37 +++++++------- .../vec/exec/join/process_hash_table_probe_impl.h | 36 ++++++------- be/src/vec/exec/join/vhash_join_node.cpp | 26 +++++----- be/src/vec/exec/join/vhash_join_node.h | 59 +++++++++------------- 9 files changed, 103 insertions(+), 113 deletions(-) diff --git a/be/src/pipeline/exec/aggregation_sink_operator.cpp b/be/src/pipeline/exec/aggregation_sink_operator.cpp index 8d3a70a3a3a..5746551a29f 100644 --- a/be/src/pipeline/exec/aggregation_sink_operator.cpp +++ b/be/src/pipeline/exec/aggregation_sink_operator.cpp @@ -656,9 +656,8 @@ void AggSinkLocalState<DependencyType, Derived>::_init_hash_method( is_nullable); } else { if (!try_get_hash_map_context_fixed<PHNormalHashMap, HashCRC32, - vectorized::AggregateDataPtr, - vectorized::AggregatedMethodVariants>( - _agg_data->method_variant, probe_exprs)) { + vectorized::AggregateDataPtr>(_agg_data->method_variant, + probe_exprs)) { _agg_data->init(Type::serialized); } } diff --git a/be/src/pipeline/exec/hashjoin_build_sink.cpp b/be/src/pipeline/exec/hashjoin_build_sink.cpp index 0c94ffe8a58..ccf2f2a5894 100644 --- a/be/src/pipeline/exec/hashjoin_build_sink.cpp +++ b/be/src/pipeline/exec/hashjoin_build_sink.cpp @@ -269,7 +269,7 @@ Status HashJoinBuildSinkLocalState::process_build_block(RuntimeState* state, using JoinOpType = std::decay_t<decltype(join_op)>; vectorized::ProcessHashTableBuild<HashTableCtxType, HashJoinBuildSinkLocalState> - hash_table_build_process(rows, block, raw_ptrs, this, + hash_table_build_process(rows, raw_ptrs, this, state->batch_size(), state); return hash_table_build_process.template run< JoinOpType::value, has_null_value, @@ -305,24 +305,23 @@ void HashJoinBuildSinkLocalState::_hash_table_init(RuntimeState* state) { auto& p = _parent->cast<HashJoinBuildSinkOperatorX>(); std::visit( [&](auto&& join_op_variants, auto have_other_join_conjunct) { - using RowRefListType = vectorized::RowRefList; if (_build_expr_ctxs.size() == 1 && !p._store_null_in_hash_table[0]) { // Single column optimization switch (_build_expr_ctxs[0]->root()->result_type()) { case TYPE_BOOLEAN: case TYPE_TINYINT: _shared_state->hash_table_variants - ->emplace<vectorized::I8HashTableContext<RowRefListType>>(); + ->emplace<vectorized::I8HashTableContext>(); break; case TYPE_SMALLINT: _shared_state->hash_table_variants - ->emplace<vectorized::I16HashTableContext<RowRefListType>>(); + ->emplace<vectorized::I16HashTableContext>(); break; case TYPE_INT: case TYPE_FLOAT: case TYPE_DATEV2: _shared_state->hash_table_variants - ->emplace<vectorized::I32HashTableContext<RowRefListType>>(); + ->emplace<vectorized::I32HashTableContext>(); break; case TYPE_BIGINT: case TYPE_DOUBLE: @@ -330,7 +329,7 @@ void HashJoinBuildSinkLocalState::_hash_table_init(RuntimeState* state) { case TYPE_DATE: case TYPE_DATETIMEV2: _shared_state->hash_table_variants - ->emplace<vectorized::I64HashTableContext<RowRefListType>>(); + ->emplace<vectorized::I64HashTableContext>(); break; case TYPE_LARGEINT: case TYPE_DECIMALV2: @@ -349,26 +348,26 @@ void HashJoinBuildSinkLocalState::_hash_table_init(RuntimeState* state) { vectorized::WhichDataType which(idx); if (which.is_decimal32()) { _shared_state->hash_table_variants - ->emplace<vectorized::I32HashTableContext<RowRefListType>>(); + ->emplace<vectorized::I32HashTableContext>(); } else if (which.is_decimal64()) { _shared_state->hash_table_variants - ->emplace<vectorized::I64HashTableContext<RowRefListType>>(); + ->emplace<vectorized::I64HashTableContext>(); } else { _shared_state->hash_table_variants - ->emplace<vectorized::I128HashTableContext<RowRefListType>>(); + ->emplace<vectorized::I128HashTableContext>(); } break; } default: _shared_state->hash_table_variants - ->emplace<vectorized::SerializedHashTableContext<RowRefListType>>(); + ->emplace<vectorized::SerializedHashTableContext>(); } return; } - if (!try_get_hash_map_context_fixed<JoinHashMap, HashCRC32, RowRefListType>( + if (!try_get_hash_map_context_fixed<JoinHashMap, HashCRC32>( *_shared_state->hash_table_variants, _build_expr_ctxs)) { _shared_state->hash_table_variants - ->emplace<vectorized::SerializedHashTableContext<RowRefListType>>(); + ->emplace<vectorized::SerializedHashTableContext>(); } }, _shared_state->join_op_variants, @@ -421,14 +420,15 @@ Status HashJoinBuildSinkOperatorX::init(const TPlanNode& tnode, RuntimeState* st const auto vexpr = _build_expr_ctxs.back()->root(); - bool null_aware = eq_join_conjunct.__isset.opcode && - eq_join_conjunct.opcode == TExprOpcode::EQ_FOR_NULL; + /// null safe equal means null = null is true, the operator in SQL should be: <=>. + const bool is_null_safe_equal = eq_join_conjunct.__isset.opcode && + eq_join_conjunct.opcode == TExprOpcode::EQ_FOR_NULL; - _is_null_safe_eq_join.push_back(null_aware); + _is_null_safe_eq_join.push_back(is_null_safe_equal); // if is null aware, build join column and probe join column both need dispose null value _store_null_in_hash_table.emplace_back( - null_aware || + is_null_safe_equal || (_build_expr_ctxs.back()->root()->is_nullable() && build_stores_null)); } return Status::OK(); diff --git a/be/src/pipeline/exec/hashjoin_build_sink.h b/be/src/pipeline/exec/hashjoin_build_sink.h index f70d9e67bce..7521563ecb8 100644 --- a/be/src/pipeline/exec/hashjoin_build_sink.h +++ b/be/src/pipeline/exec/hashjoin_build_sink.h @@ -109,6 +109,13 @@ protected: vectorized::MutableBlock _build_side_mutable_block; std::shared_ptr<VRuntimeFilterSlots> _runtime_filter_slots; bool _has_set_need_null_map_for_build = false; + + /* + * The comparison result of a null value with any other value is null, + * which means that for most join(exclude: null aware join, null equal safe join), + * the result of an equality condition involving null should be false, + * so null does not need to be added to the hash table. + */ bool _build_side_ignore_null = false; std::shared_ptr<SharedHashTableDependency> _shared_hash_table_dependency; std::vector<int> _build_col_ids; diff --git a/be/src/vec/common/hash_table/hash_map.h b/be/src/vec/common/hash_table/hash_map.h index 0bc7a5abbfe..018d134d875 100644 --- a/be/src/vec/common/hash_table/hash_map.h +++ b/be/src/vec/common/hash_table/hash_map.h @@ -201,7 +201,7 @@ using HashMap = HashMapTable<Key, HashMapCell<Key, Mapped, Hash>, Hash, Grower, template <typename Key, typename Mapped, typename Hash = DefaultHash<Key>> using NormalHashMap = HashMapTable<Key, HashMapCell<Key, Mapped, Hash>, Hash>; -template <typename Key, typename Mapped, typename Hash = DefaultHash<Key>> +template <typename Key, typename Hash = DefaultHash<Key>> using JoinHashMap = JoinHashTable<Key, Hash>; template <typename Key, typename Mapped, typename Hash = DefaultHash<Key>, diff --git a/be/src/vec/common/hash_table/hash_map_context.h b/be/src/vec/common/hash_table/hash_map_context.h index f8861ccfcd7..41f3bd52efd 100644 --- a/be/src/vec/common/hash_table/hash_map_context.h +++ b/be/src/vec/common/hash_table/hash_map_context.h @@ -569,15 +569,13 @@ struct MethodSingleNullableColumn : public SingleColumnMethod { } }; -template <typename RowRefListType> -using SerializedHashTableContext = MethodSerialized<JoinHashMap<StringRef, RowRefListType>>; +using SerializedHashTableContext = MethodSerialized<JoinHashMap<StringRef>>; -template <class T, typename RowRefListType> -using PrimaryTypeHashTableContext = - MethodOneNumber<T, JoinHashMap<T, RowRefListType, HashCRC32<T>>>; +template <class T> +using PrimaryTypeHashTableContext = MethodOneNumber<T, JoinHashMap<T, HashCRC32<T>>>; -template <class Key, bool has_null, typename Value> -using FixedKeyHashTableContext = MethodKeysFixed<JoinHashMap<Key, Value, HashCRC32<Key>>, has_null>; +template <class Key, bool has_null> +using FixedKeyHashTableContext = MethodKeysFixed<JoinHashMap<Key, HashCRC32<Key>>, has_null>; template <class Key, bool has_null> using SetFixedKeyHashTableContext = diff --git a/be/src/vec/common/hash_table/hash_map_context_creator.h b/be/src/vec/common/hash_table/hash_map_context_creator.h index 60376acea5e..89d6ab865ad 100644 --- a/be/src/vec/common/hash_table/hash_map_context_creator.h +++ b/be/src/vec/common/hash_table/hash_map_context_creator.h @@ -22,37 +22,38 @@ namespace doris::vectorized { -template <template <typename, typename, typename> typename HashMap, - template <typename> typename Hash, typename Key, typename Value, typename Variant> +template <template <typename...> typename HashMap, template <typename> typename Hash, typename Key, + typename... Mapped, typename Variant> void get_hash_map_context_fixed(Variant& variant, bool has_nullable_key, const Sizes& key_sizes) { if (has_nullable_key) { - variant.template emplace<MethodKeysFixed<HashMap<Key, Value, Hash<Key>>, true>>(key_sizes); + variant.template emplace<MethodKeysFixed<HashMap<Key, Mapped..., Hash<Key>>, true>>( + key_sizes); } else { - variant.template emplace<MethodKeysFixed<HashMap<Key, Value, Hash<Key>>>>(key_sizes); + variant.template emplace<MethodKeysFixed<HashMap<Key, Mapped..., Hash<Key>>>>(key_sizes); } } -template <template <typename, typename, typename> typename HashMap, - template <typename> typename Hash, typename Value, typename Variant> +template <template <typename... Args> typename HashMap, template <typename> typename Hash, + typename... Mapped, typename Variant> void get_hash_map_context_fixed(Variant& variant, size_t size, bool has_nullable_key, const Sizes& key_sizes) { if (size <= sizeof(UInt64)) { - get_hash_map_context_fixed<HashMap, Hash, UInt64, Value>(variant, has_nullable_key, - key_sizes); + get_hash_map_context_fixed<HashMap, Hash, UInt64, Mapped...>(variant, has_nullable_key, + key_sizes); } else if (size <= sizeof(UInt128)) { - get_hash_map_context_fixed<HashMap, Hash, UInt128, Value>(variant, has_nullable_key, - key_sizes); + get_hash_map_context_fixed<HashMap, Hash, UInt128, Mapped...>(variant, has_nullable_key, + key_sizes); } else if (size <= sizeof(UInt136)) { - get_hash_map_context_fixed<HashMap, Hash, UInt136, Value>(variant, has_nullable_key, - key_sizes); + get_hash_map_context_fixed<HashMap, Hash, UInt136, Mapped...>(variant, has_nullable_key, + key_sizes); } else if (size <= sizeof(UInt256)) { - get_hash_map_context_fixed<HashMap, Hash, UInt256, Value>(variant, has_nullable_key, - key_sizes); + get_hash_map_context_fixed<HashMap, Hash, UInt256, Mapped...>(variant, has_nullable_key, + key_sizes); } } -template <template <typename, typename, typename> typename HashMap, - template <typename> typename Hash, typename Value, typename Variant> +template <template <typename... Args> typename HashMap, template <typename> typename Hash, + typename... Mapped, typename Variant> bool try_get_hash_map_context_fixed(Variant& variant, const VExprContextSPtrs& expr_ctxs) { Sizes key_sizes; @@ -78,8 +79,8 @@ bool try_get_hash_map_context_fixed(Variant& variant, const VExprContextSPtrs& e } if (use_fixed_key) { - get_hash_map_context_fixed<HashMap, Hash, Value>(variant, bitmap_size + key_byte_size, - has_null, key_sizes); + get_hash_map_context_fixed<HashMap, Hash, Mapped...>(variant, bitmap_size + key_byte_size, + has_null, key_sizes); } return use_fixed_key; } diff --git a/be/src/vec/exec/join/process_hash_table_probe_impl.h b/be/src/vec/exec/join/process_hash_table_probe_impl.h index fd2ac01613d..9f5167bb555 100644 --- a/be/src/vec/exec/join/process_hash_table_probe_impl.h +++ b/be/src/vec/exec/join/process_hash_table_probe_impl.h @@ -611,24 +611,24 @@ struct ExtractType<T(U)> { MutableBlock & mutable_block, Block * output_block, \ bool* eos) -#define INSTANTIATION_FOR1(JoinOpType, Parent) \ - template struct ProcessHashTableProbe<JoinOpType, Parent>; \ - \ - INSTANTIATION(JoinOpType, Parent, (SerializedHashTableContext<RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I8HashTableContext<RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I16HashTableContext<RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I32HashTableContext<RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I64HashTableContext<RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I128HashTableContext<RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I256HashTableContext<RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I64FixedKeyHashTableContext<true, RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I64FixedKeyHashTableContext<false, RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I128FixedKeyHashTableContext<true, RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I128FixedKeyHashTableContext<false, RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I256FixedKeyHashTableContext<true, RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I256FixedKeyHashTableContext<false, RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I136FixedKeyHashTableContext<true, RowRefList>)); \ - INSTANTIATION(JoinOpType, Parent, (I136FixedKeyHashTableContext<false, RowRefList>)); +#define INSTANTIATION_FOR1(JoinOpType, Parent) \ + template struct ProcessHashTableProbe<JoinOpType, Parent>; \ + \ + INSTANTIATION(JoinOpType, Parent, (SerializedHashTableContext)); \ + INSTANTIATION(JoinOpType, Parent, (I8HashTableContext)); \ + INSTANTIATION(JoinOpType, Parent, (I16HashTableContext)); \ + INSTANTIATION(JoinOpType, Parent, (I32HashTableContext)); \ + INSTANTIATION(JoinOpType, Parent, (I64HashTableContext)); \ + INSTANTIATION(JoinOpType, Parent, (I128HashTableContext)); \ + INSTANTIATION(JoinOpType, Parent, (I256HashTableContext)); \ + INSTANTIATION(JoinOpType, Parent, (I64FixedKeyHashTableContext<true>)); \ + INSTANTIATION(JoinOpType, Parent, (I64FixedKeyHashTableContext<false>)); \ + INSTANTIATION(JoinOpType, Parent, (I128FixedKeyHashTableContext<true>)); \ + INSTANTIATION(JoinOpType, Parent, (I128FixedKeyHashTableContext<false>)); \ + INSTANTIATION(JoinOpType, Parent, (I256FixedKeyHashTableContext<true>)); \ + INSTANTIATION(JoinOpType, Parent, (I256FixedKeyHashTableContext<false>)); \ + INSTANTIATION(JoinOpType, Parent, (I136FixedKeyHashTableContext<true>)); \ + INSTANTIATION(JoinOpType, Parent, (I136FixedKeyHashTableContext<false>)); #define INSTANTIATION_FOR(JoinOpType) \ INSTANTIATION_FOR1(JoinOpType, HashJoinNode); \ diff --git a/be/src/vec/exec/join/vhash_join_node.cpp b/be/src/vec/exec/join/vhash_join_node.cpp index 271e522cd65..a813ec565a4 100644 --- a/be/src/vec/exec/join/vhash_join_node.cpp +++ b/be/src/vec/exec/join/vhash_join_node.cpp @@ -984,7 +984,7 @@ Status HashJoinNode::_process_build_block(RuntimeState* state, Block& block) { using JoinOpType = std::decay_t<decltype(join_op)>; ProcessHashTableBuild<HashTableCtxType, HashJoinNode> - hash_table_build_process(rows, block, raw_ptrs, this, + hash_table_build_process(rows, raw_ptrs, this, state->batch_size(), state); return hash_table_build_process.template run< JoinOpType::value, has_null_value, @@ -1005,29 +1005,27 @@ Status HashJoinNode::_process_build_block(RuntimeState* state, Block& block) { void HashJoinNode::_hash_table_init(RuntimeState* state) { std::visit( [&](auto&& join_op_variants, auto have_other_join_conjunct) { - using RowRefListType = RowRefList; - if (_build_expr_ctxs.size() == 1 && !_store_null_in_hash_table[0]) { // Single column optimization switch (_build_expr_ctxs[0]->root()->result_type()) { case TYPE_BOOLEAN: case TYPE_TINYINT: - _hash_table_variants->emplace<I8HashTableContext<RowRefListType>>(); + _hash_table_variants->emplace<I8HashTableContext>(); break; case TYPE_SMALLINT: - _hash_table_variants->emplace<I16HashTableContext<RowRefListType>>(); + _hash_table_variants->emplace<I16HashTableContext>(); break; case TYPE_INT: case TYPE_FLOAT: case TYPE_DATEV2: - _hash_table_variants->emplace<I32HashTableContext<RowRefListType>>(); + _hash_table_variants->emplace<I32HashTableContext>(); break; case TYPE_BIGINT: case TYPE_DOUBLE: case TYPE_DATETIME: case TYPE_DATE: case TYPE_DATETIMEV2: - _hash_table_variants->emplace<I64HashTableContext<RowRefListType>>(); + _hash_table_variants->emplace<I64HashTableContext>(); break; case TYPE_LARGEINT: case TYPE_DECIMALV2: @@ -1042,23 +1040,23 @@ void HashJoinNode::_hash_table_init(RuntimeState* state) { : type_ptr->get_type_id(); WhichDataType which(idx); if (which.is_decimal32()) { - _hash_table_variants->emplace<I32HashTableContext<RowRefListType>>(); + _hash_table_variants->emplace<I32HashTableContext>(); } else if (which.is_decimal64()) { - _hash_table_variants->emplace<I64HashTableContext<RowRefListType>>(); + _hash_table_variants->emplace<I64HashTableContext>(); } else { - _hash_table_variants->emplace<I128HashTableContext<RowRefListType>>(); + _hash_table_variants->emplace<I128HashTableContext>(); } break; } default: - _hash_table_variants->emplace<SerializedHashTableContext<RowRefListType>>(); + _hash_table_variants->emplace<SerializedHashTableContext>(); } return; } - if (!try_get_hash_map_context_fixed<JoinHashMap, HashCRC32, RowRefListType>( - *_hash_table_variants, _build_expr_ctxs)) { - _hash_table_variants->emplace<SerializedHashTableContext<RowRefListType>>(); + if (!try_get_hash_map_context_fixed<JoinHashMap, HashCRC32>(*_hash_table_variants, + _build_expr_ctxs)) { + _hash_table_variants->emplace<SerializedHashTableContext>(); } }, _join_op_variants, make_bool_variant(_have_other_join_conjunct)); diff --git a/be/src/vec/exec/join/vhash_join_node.h b/be/src/vec/exec/join/vhash_join_node.h index 535db4434dc..fb5bf19015d 100644 --- a/be/src/vec/exec/join/vhash_join_node.h +++ b/be/src/vec/exec/join/vhash_join_node.h @@ -101,10 +101,9 @@ using ProfileCounter = RuntimeProfile::Counter; template <class HashTableContext, typename Parent> struct ProcessHashTableBuild { - ProcessHashTableBuild(int rows, Block& acquired_block, ColumnRawPtrs& build_raw_ptrs, - Parent* parent, int batch_size, RuntimeState* state) + ProcessHashTableBuild(int rows, ColumnRawPtrs& build_raw_ptrs, Parent* parent, int batch_size, + RuntimeState* state) : _rows(rows), - _acquired_block(acquired_block), _build_raw_ptrs(build_raw_ptrs), _parent(parent), _batch_size(batch_size), @@ -149,51 +148,39 @@ struct ProcessHashTableBuild { private: const uint32_t _rows; - Block& _acquired_block; ColumnRawPtrs& _build_raw_ptrs; Parent* _parent = nullptr; int _batch_size; RuntimeState* _state = nullptr; }; -template <typename RowRefListType> -using I8HashTableContext = PrimaryTypeHashTableContext<UInt8, RowRefListType>; -template <typename RowRefListType> -using I16HashTableContext = PrimaryTypeHashTableContext<UInt16, RowRefListType>; -template <typename RowRefListType> -using I32HashTableContext = PrimaryTypeHashTableContext<UInt32, RowRefListType>; -template <typename RowRefListType> -using I64HashTableContext = PrimaryTypeHashTableContext<UInt64, RowRefListType>; -template <typename RowRefListType> -using I128HashTableContext = PrimaryTypeHashTableContext<UInt128, RowRefListType>; -template <typename RowRefListType> -using I256HashTableContext = PrimaryTypeHashTableContext<UInt256, RowRefListType>; +using I8HashTableContext = PrimaryTypeHashTableContext<UInt8>; +using I16HashTableContext = PrimaryTypeHashTableContext<UInt16>; +using I32HashTableContext = PrimaryTypeHashTableContext<UInt32>; +using I64HashTableContext = PrimaryTypeHashTableContext<UInt64>; +using I128HashTableContext = PrimaryTypeHashTableContext<UInt128>; +using I256HashTableContext = PrimaryTypeHashTableContext<UInt256>; -template <bool has_null, typename RowRefListType> -using I64FixedKeyHashTableContext = FixedKeyHashTableContext<UInt64, has_null, RowRefListType>; +template <bool has_null> +using I64FixedKeyHashTableContext = FixedKeyHashTableContext<UInt64, has_null>; -template <bool has_null, typename RowRefListType> -using I128FixedKeyHashTableContext = FixedKeyHashTableContext<UInt128, has_null, RowRefListType>; +template <bool has_null> +using I128FixedKeyHashTableContext = FixedKeyHashTableContext<UInt128, has_null>; -template <bool has_null, typename RowRefListType> -using I256FixedKeyHashTableContext = FixedKeyHashTableContext<UInt256, has_null, RowRefListType>; +template <bool has_null> +using I256FixedKeyHashTableContext = FixedKeyHashTableContext<UInt256, has_null>; -template <bool has_null, typename RowRefListType> -using I136FixedKeyHashTableContext = FixedKeyHashTableContext<UInt136, has_null, RowRefListType>; +template <bool has_null> +using I136FixedKeyHashTableContext = FixedKeyHashTableContext<UInt136, has_null>; using HashTableVariants = - std::variant<std::monostate, SerializedHashTableContext<RowRefList>, - I8HashTableContext<RowRefList>, I16HashTableContext<RowRefList>, - I32HashTableContext<RowRefList>, I64HashTableContext<RowRefList>, - I128HashTableContext<RowRefList>, I256HashTableContext<RowRefList>, - I64FixedKeyHashTableContext<true, RowRefList>, - I64FixedKeyHashTableContext<false, RowRefList>, - I128FixedKeyHashTableContext<true, RowRefList>, - I128FixedKeyHashTableContext<false, RowRefList>, - I256FixedKeyHashTableContext<true, RowRefList>, - I256FixedKeyHashTableContext<false, RowRefList>, - I136FixedKeyHashTableContext<true, RowRefList>, - I136FixedKeyHashTableContext<false, RowRefList>>; + std::variant<std::monostate, SerializedHashTableContext, I8HashTableContext, + I16HashTableContext, I32HashTableContext, I64HashTableContext, + I128HashTableContext, I256HashTableContext, I64FixedKeyHashTableContext<true>, + I64FixedKeyHashTableContext<false>, I128FixedKeyHashTableContext<true>, + I128FixedKeyHashTableContext<false>, I256FixedKeyHashTableContext<true>, + I256FixedKeyHashTableContext<false>, I136FixedKeyHashTableContext<true>, + I136FixedKeyHashTableContext<false>>; class VExprContext; --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
