This is an automated email from the ASF dual-hosted git repository.
yiguolei pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new dba7162d814 [refactor](join) remove unused RowRefListType from join
(#30442)
dba7162d814 is described below
commit dba7162d814fa00ec02dd54e29925fddf0596d3e
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]
