duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

package/src/duckdb/src/common/radix_partitioning.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/common/radix_partitioning.hpp"
 
 #include "duckdb/common/types/column/partitioned_column_data.hpp"
-#include "duckdb/common/types/row/row_data_collection.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/vector_operations/binary_executor.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
@@ -13,20 +12,20 @@ template <idx_t radix_bits>
 struct RadixPartitioningConstants {
 public:
 	//! Bitmask of the upper bits starting at the 5th byte
-	static constexpr const idx_t NUM_PARTITIONS = RadixPartitioning::NumberOfPartitions(radix_bits);
-	static constexpr const idx_t SHIFT = RadixPartitioning::Shift(radix_bits);
-	static constexpr const hash_t MASK = RadixPartitioning::Mask(radix_bits);
+	static constexpr idx_t NUM_PARTITIONS = RadixPartitioning::NumberOfPartitions(radix_bits);
+	static constexpr idx_t SHIFT = RadixPartitioning::Shift(radix_bits);
+	static constexpr hash_t MASK = RadixPartitioning::Mask(radix_bits);
 
 public:
 	//! Apply bitmask and right shift to get a number between 0 and NUM_PARTITIONS
-	static inline hash_t ApplyMask(hash_t hash) {
+	static hash_t ApplyMask(const hash_t hash) {
 		D_ASSERT((hash & MASK) >> SHIFT < NUM_PARTITIONS);
 		return (hash & MASK) >> SHIFT;
 	}
 };
 
 template <class OP, class RETURN_TYPE, typename... ARGS>
-RETURN_TYPE RadixBitsSwitch(idx_t radix_bits, ARGS &&... args) {
+RETURN_TYPE RadixBitsSwitch(const idx_t radix_bits, ARGS &&... args) {
 	D_ASSERT(radix_bits <= RadixPartitioning::MAX_RADIX_BITS);
 	switch (radix_bits) {
 	case 0:
@@ -71,7 +70,7 @@ struct RadixLessThan {
 
 struct SelectFunctor {
 	template <idx_t radix_bits>
-	static idx_t Operation(Vector &hashes, const SelectionVector *sel, idx_t count, idx_t cutoff,
+	static idx_t Operation(Vector &hashes, const SelectionVector *sel, const idx_t count, const idx_t cutoff,
 	                       SelectionVector *true_sel, SelectionVector *false_sel) {
 		Vector cutoff_vector(Value::HASH(cutoff));
 		return BinaryExecutor::Select<hash_t, hash_t, RadixLessThan<radix_bits>>(hashes, cutoff_vector, sel, count,
@@ -79,18 +78,24 @@ struct SelectFunctor {
 	}
 };
 
-idx_t RadixPartitioning::Select(Vector &hashes, const SelectionVector *sel, idx_t count, idx_t radix_bits, idx_t cutoff,
-                                SelectionVector *true_sel, SelectionVector *false_sel) {
+idx_t RadixPartitioning::Select(Vector &hashes, const SelectionVector *sel, const idx_t count, const idx_t radix_bits,
+                                const idx_t cutoff, SelectionVector *true_sel, SelectionVector *false_sel) {
 	return RadixBitsSwitch<SelectFunctor, idx_t>(radix_bits, hashes, sel, count, cutoff, true_sel, false_sel);
 }
 
 struct ComputePartitionIndicesFunctor {
 	template <idx_t radix_bits>
-	static void Operation(Vector &hashes, Vector &partition_indices, idx_t count) {
-		UnaryExecutor::Execute<hash_t, hash_t>(hashes, partition_indices, count, [&](hash_t hash) {
-			using CONSTANTS = RadixPartitioningConstants<radix_bits>;
-			return CONSTANTS::ApplyMask(hash);
-		});
+	static void Operation(Vector &hashes, Vector &partition_indices, const SelectionVector &append_sel,
+	                      const idx_t append_count) {
+		using CONSTANTS = RadixPartitioningConstants<radix_bits>;
+		if (append_sel.IsSet()) {
+			auto hashes_sliced = Vector(hashes, append_sel, append_count);
+			UnaryExecutor::Execute<hash_t, hash_t>(hashes_sliced, partition_indices, append_count,
+			                                       [&](hash_t hash) { return CONSTANTS::ApplyMask(hash); });
+		} else {
+			UnaryExecutor::Execute<hash_t, hash_t>(hashes, partition_indices, append_count,
+			                                       [&](hash_t hash) { return CONSTANTS::ApplyMask(hash); });
+		}
 	}
 };
 
@@ -130,20 +135,23 @@ void RadixPartitionedColumnData::InitializeAppendStateInternal(PartitionedColumn
 		partitions[i]->InitializeAppend(*state.partition_append_states[i]);
 		state.partition_buffers.emplace_back(CreatePartitionBuffer());
 	}
+
+	// Initialize fixed-size map
+	state.fixed_partition_entries.resize(RadixPartitioning::NumberOfPartitions(radix_bits));
 }
 
 void RadixPartitionedColumnData::ComputePartitionIndices(PartitionedColumnDataAppendState &state, DataChunk &input) {
 	D_ASSERT(partitions.size() == RadixPartitioning::NumberOfPartitions(radix_bits));
 	D_ASSERT(state.partition_buffers.size() == RadixPartitioning::NumberOfPartitions(radix_bits));
 	RadixBitsSwitch<ComputePartitionIndicesFunctor, void>(radix_bits, input.data[hash_col_idx], state.partition_indices,
-	                                                      input.size());
+	                                                      *FlatVector::IncrementalSelectionVector(), input.size());
 }
 
 //===--------------------------------------------------------------------===//
 // Tuple Data Partitioning
 //===--------------------------------------------------------------------===//
 RadixPartitionedTupleData::RadixPartitionedTupleData(BufferManager &buffer_manager, const TupleDataLayout &layout_p,
-                                                     idx_t radix_bits_p, idx_t hash_col_idx_p)
+                                                     const idx_t radix_bits_p, const idx_t hash_col_idx_p)
     : PartitionedTupleData(PartitionedTupleDataType::RADIX, buffer_manager, layout_p.Copy()), radix_bits(radix_bits_p),
       hash_col_idx(hash_col_idx_p) {
 	D_ASSERT(radix_bits <= RadixPartitioning::MAX_RADIX_BITS);
@@ -172,12 +180,12 @@ void RadixPartitionedTupleData::Initialize() {
 }
 
 void RadixPartitionedTupleData::InitializeAppendStateInternal(PartitionedTupleDataAppendState &state,
-                                                              TupleDataPinProperties properties) const {
+                                                              const TupleDataPinProperties properties) const {
 	// Init pin state per partition
 	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
 	state.partition_pin_states.reserve(num_partitions);
 	for (idx_t i = 0; i < num_partitions; i++) {
-		state.partition_pin_states.emplace_back(make_uniq<TupleDataPinState>());
+		state.partition_pin_states.emplace_back(make_unsafe_uniq<TupleDataPinState>());
 		partitions[i]->InitializeAppend(*state.partition_pin_states[i], properties);
 	}
 
@@ -194,10 +202,11 @@ void RadixPartitionedTupleData::InitializeAppendStateInternal(PartitionedTupleDa
 	state.fixed_partition_entries.resize(RadixPartitioning::NumberOfPartitions(radix_bits));
 }
 
-void RadixPartitionedTupleData::ComputePartitionIndices(PartitionedTupleDataAppendState &state, DataChunk &input) {
+void RadixPartitionedTupleData::ComputePartitionIndices(PartitionedTupleDataAppendState &state, DataChunk &input,
+                                                        const SelectionVector &append_sel, const idx_t append_count) {
 	D_ASSERT(partitions.size() == RadixPartitioning::NumberOfPartitions(radix_bits));
 	RadixBitsSwitch<ComputePartitionIndicesFunctor, void>(radix_bits, input.data[hash_col_idx], state.partition_indices,
-	                                                      input.size());
+	                                                      append_sel, append_count);
 }
 
 void RadixPartitionedTupleData::ComputePartitionIndices(Vector &row_locations, idx_t count,
@@ -205,7 +214,8 @@ void RadixPartitionedTupleData::ComputePartitionIndices(Vector &row_locations, i
 	Vector intermediate(LogicalType::HASH);
 	partitions[0]->Gather(row_locations, *FlatVector::IncrementalSelectionVector(), count, hash_col_idx, intermediate,
 	                      *FlatVector::IncrementalSelectionVector(), nullptr);
-	RadixBitsSwitch<ComputePartitionIndicesFunctor, void>(radix_bits, intermediate, partition_indices, count);
+	RadixBitsSwitch<ComputePartitionIndicesFunctor, void>(radix_bits, intermediate, partition_indices,
+	                                                      *FlatVector::IncrementalSelectionVector(), count);
 }
 
 void RadixPartitionedTupleData::RepartitionFinalizeStates(PartitionedTupleData &old_partitioned_data,

package/src/duckdb/src/common/random_engine.cpp

@@ -35,6 +35,10 @@ uint32_t RandomEngine::NextRandomInteger() {
 	return random_state->pcg();
 }
 
+uint32_t RandomEngine::NextRandomInteger(uint32_t min, uint32_t max) {
+	return min + static_cast<uint32_t>(NextRandom() * double(max - min));
+}
+
 void RandomEngine::SetSeed(uint32_t seed) {
 	random_state->pcg.seed(seed);
 }

package/src/duckdb/src/common/re2_regex.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/common/numeric_utils.hpp"
+#include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector.hpp"
 #include <memory>
 
@@ -7,56 +8,90 @@
 
 namespace duckdb_re2 {
 
+static size_t GetMultibyteCharLength(const char c) {
+	if ((c & 0x80) == 0) {
+		return 1; // 1-byte character (ASCII)
+	} else if ((c & 0xE0) == 0xC0) {
+		return 2; // 2-byte character
+	} else if ((c & 0xF0) == 0xE0) {
+		return 3; // 3-byte character
+	} else if ((c & 0xF8) == 0xF0) {
+		return 4; // 4-byte character
+	} else {
+		return 0; // invalid UTF-8leading byte
+	}
+}
+
 Regex::Regex(const std::string &pattern, RegexOptions options) {
 	RE2::Options o;
 	o.set_case_sensitive(options == RegexOptions::CASE_INSENSITIVE);
 	regex = duckdb::make_shared_ptr<duckdb_re2::RE2>(StringPiece(pattern), o);
 }
 
-bool RegexSearchInternal(const char *input, Match &match, const Regex &r, RE2::Anchor anchor, size_t start,
-                         size_t end) {
-	auto &regex = r.GetRegex();
+bool RegexSearchInternal(const char *input_data, size_t input_size, Match &match, const RE2 &regex, RE2::Anchor anchor,
+                         size_t start, size_t end) {
 	duckdb::vector<StringPiece> target_groups;
 	auto group_count = duckdb::UnsafeNumericCast<size_t>(regex.NumberOfCapturingGroups() + 1);
 	target_groups.resize(group_count);
 	match.groups.clear();
-	if (!regex.Match(StringPiece(input), start, end, anchor, target_groups.data(),
+	if (!regex.Match(StringPiece(input_data, input_size), start, end, anchor, target_groups.data(),
 	                 duckdb::UnsafeNumericCast<int>(group_count))) {
 		return false;
 	}
 	for (auto &group : target_groups) {
 		GroupMatch group_match;
 		group_match.text = group.ToString();
-		group_match.position = group.data() != nullptr ? duckdb::NumericCast<uint32_t>(group.data() - input) : 0;
+		group_match.position = group.data() != nullptr ? duckdb::NumericCast<uint32_t>(group.data() - input_data) : 0;
 		match.groups.emplace_back(group_match);
 	}
 	return true;
 }
 
 bool RegexSearch(const std::string &input, Match &match, const Regex &regex) {
-	return RegexSearchInternal(input.c_str(), match, regex, RE2::UNANCHORED, 0, input.size());
+	auto input_sz = input.size();
+	return RegexSearchInternal(input.c_str(), input_sz, match, regex.GetRegex(), RE2::UNANCHORED, 0, input_sz);
 }
 
 bool RegexMatch(const std::string &input, Match &match, const Regex &regex) {
-	return RegexSearchInternal(input.c_str(), match, regex, RE2::ANCHOR_BOTH, 0, input.size());
+	auto input_sz = input.size();
+	return RegexSearchInternal(input.c_str(), input_sz, match, regex.GetRegex(), RE2::ANCHOR_BOTH, 0, input_sz);
 }
 
 bool RegexMatch(const char *start, const char *end, Match &match, const Regex &regex) {
-	return RegexSearchInternal(start, match, regex, RE2::ANCHOR_BOTH, 0,
-	                           duckdb::UnsafeNumericCast<size_t>(end - start));
+	auto sz = duckdb::UnsafeNumericCast<size_t>(end - start);
+	return RegexSearchInternal(start, sz, match, regex.GetRegex(), RE2::ANCHOR_BOTH, 0, sz);
 }
 
 bool RegexMatch(const std::string &input, const Regex &regex) {
 	Match nop_match;
-	return RegexSearchInternal(input.c_str(), nop_match, regex, RE2::ANCHOR_BOTH, 0, input.size());
+	auto input_sz = input.size();
+	return RegexSearchInternal(input.c_str(), input_sz, nop_match, regex.GetRegex(), RE2::ANCHOR_BOTH, 0, input_sz);
 }
 
 duckdb::vector<Match> RegexFindAll(const std::string &input, const Regex &regex) {
+	return RegexFindAll(input.c_str(), input.size(), regex.GetRegex());
+}
+
+duckdb::vector<Match> RegexFindAll(const char *input_data, size_t input_size, const RE2 &regex) {
 	duckdb::vector<Match> matches;
 	size_t position = 0;
 	Match match;
-	while (RegexSearchInternal(input.c_str(), match, regex, RE2::UNANCHORED, position, input.size())) {
-		position += match.position(0) + match.length(0);
+	while (RegexSearchInternal(input_data, input_size, match, regex, RE2::UNANCHORED, position, input_size)) {
+		if (match.length(0)) {
+			position = match.position(0) + match.length(0);
+		} else { // match.length(0) == 0
+			auto next_char_length = GetMultibyteCharLength(input_data[match.position(0)]);
+			if (!next_char_length) {
+				throw duckdb::InvalidInputException("Invalid UTF-8 leading byte at position " +
+				                                    std::to_string(match.position(0) + 1));
+			}
+			if (match.position(0) + next_char_length < input_size) {
+				position = match.position(0) + next_char_length;
+			} else {
+				matches.emplace_back(match);
+				break;
+			}
+		}
 		matches.emplace_back(match);
 	}
 	return matches;

package/src/duckdb/src/common/render_tree.cpp

@@ -0,0 +1,243 @@
+#include "duckdb/common/render_tree.hpp"
+#include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
+#include "duckdb/execution/operator/join/physical_delim_join.hpp"
+#include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
+
+namespace duckdb {
+
+struct PipelineRenderNode {
+	explicit PipelineRenderNode(const PhysicalOperator &op) : op(op) {
+	}
+
+	const PhysicalOperator &op;
+	unique_ptr<PipelineRenderNode> child;
+};
+
+} // namespace duckdb
+
+namespace {
+
+using duckdb::MaxValue;
+using duckdb::PhysicalDelimJoin;
+using duckdb::PhysicalOperator;
+using duckdb::PhysicalOperatorType;
+using duckdb::PhysicalPositionalScan;
+using duckdb::PipelineRenderNode;
+using duckdb::RenderTreeNode;
+
+class TreeChildrenIterator {
+public:
+	template <class T>
+	static bool HasChildren(const T &op) {
+		return !op.children.empty();
+	}
+	template <class T>
+	static void Iterate(const T &op, const std::function<void(const T &child)> &callback) {
+		for (auto &child : op.children) {
+			callback(*child);
+		}
+	}
+};
+
+template <>
+bool TreeChildrenIterator::HasChildren(const PhysicalOperator &op) {
+	switch (op.type) {
+	case PhysicalOperatorType::LEFT_DELIM_JOIN:
+	case PhysicalOperatorType::RIGHT_DELIM_JOIN:
+	case PhysicalOperatorType::POSITIONAL_SCAN:
+		return true;
+	default:
+		return !op.children.empty();
+	}
+}
+template <>
+void TreeChildrenIterator::Iterate(const PhysicalOperator &op,
+                                   const std::function<void(const PhysicalOperator &child)> &callback) {
+	for (auto &child : op.children) {
+		callback(*child);
+	}
+	if (op.type == PhysicalOperatorType::LEFT_DELIM_JOIN || op.type == PhysicalOperatorType::RIGHT_DELIM_JOIN) {
+		auto &delim = op.Cast<PhysicalDelimJoin>();
+		callback(*delim.join);
+	} else if ((op.type == PhysicalOperatorType::POSITIONAL_SCAN)) {
+		auto &pscan = op.Cast<PhysicalPositionalScan>();
+		for (auto &table : pscan.child_tables) {
+			callback(*table);
+		}
+	}
+}
+
+template <>
+bool TreeChildrenIterator::HasChildren(const PipelineRenderNode &op) {
+	return op.child.get();
+}
+
+template <>
+void TreeChildrenIterator::Iterate(const PipelineRenderNode &op,
+                                   const std::function<void(const PipelineRenderNode &child)> &callback) {
+	if (op.child) {
+		callback(*op.child);
+	}
+}
+
+} // namespace
+
+namespace duckdb {
+
+template <class T>
+static void GetTreeWidthHeight(const T &op, idx_t &width, idx_t &height) {
+	if (!TreeChildrenIterator::HasChildren(op)) {
+		width = 1;
+		height = 1;
+		return;
+	}
+	width = 0;
+	height = 0;
+
+	TreeChildrenIterator::Iterate<T>(op, [&](const T &child) {
+		idx_t child_width, child_height;
+		GetTreeWidthHeight<T>(child, child_width, child_height);
+		width += child_width;
+		height = MaxValue<idx_t>(height, child_height);
+	});
+	height++;
+}
+
+static unique_ptr<RenderTreeNode> CreateNode(const LogicalOperator &op) {
+	return make_uniq<RenderTreeNode>(op.GetName(), op.ParamsToString());
+}
+
+static unique_ptr<RenderTreeNode> CreateNode(const PhysicalOperator &op) {
+	return make_uniq<RenderTreeNode>(op.GetName(), op.ParamsToString());
+}
+
+static unique_ptr<RenderTreeNode> CreateNode(const PipelineRenderNode &op) {
+	return CreateNode(op.op);
+}
+
+static unique_ptr<RenderTreeNode> CreateNode(const ProfilingNode &op) {
+	auto &info = op.GetProfilingInfo();
+	InsertionOrderPreservingMap<string> extra_info;
+	if (info.Enabled(MetricsType::EXTRA_INFO)) {
+		extra_info = op.GetProfilingInfo().extra_info;
+	}
+
+	string node_name = "QUERY";
+	if (op.depth > 0) {
+		node_name = info.GetMetricAsString(MetricsType::OPERATOR_TYPE);
+	}
+
+	auto result = make_uniq<RenderTreeNode>(node_name, extra_info);
+	if (info.Enabled(MetricsType::OPERATOR_CARDINALITY)) {
+		result->extra_text[RenderTreeNode::CARDINALITY] = info.GetMetricAsString(MetricsType::OPERATOR_CARDINALITY);
+	}
+	if (info.Enabled(MetricsType::OPERATOR_TIMING)) {
+		string timing = StringUtil::Format("%.2f", info.metrics.at(MetricsType::OPERATOR_TIMING).GetValue<double>());
+		result->extra_text[RenderTreeNode::TIMING] = timing + "s";
+	}
+	return result;
+}
+
+template <class T>
+static idx_t CreateTreeRecursive(RenderTree &result, const T &op, idx_t x, idx_t y) {
+	auto node = CreateNode(op);
+
+	if (!TreeChildrenIterator::HasChildren(op)) {
+		result.SetNode(x, y, std::move(node));
+		return 1;
+	}
+	idx_t width = 0;
+	// render the children of this node
+	TreeChildrenIterator::Iterate<T>(op, [&](const T &child) {
+		auto child_x = x + width;
+		auto child_y = y + 1;
+		node->AddChildPosition(child_x, child_y);
+		width += CreateTreeRecursive<T>(result, child, child_x, child_y);
+	});
+	result.SetNode(x, y, std::move(node));
+	return width;
+}
+
+template <class T>
+static unique_ptr<RenderTree> CreateTree(const T &op) {
+	idx_t width, height;
+	GetTreeWidthHeight<T>(op, width, height);
+
+	auto result = make_uniq<RenderTree>(width, height);
+
+	// now fill in the tree
+	CreateTreeRecursive<T>(*result, op, 0, 0);
+	return result;
+}
+
+RenderTree::RenderTree(idx_t width_p, idx_t height_p) : width(width_p), height(height_p) {
+	nodes = make_uniq_array<unique_ptr<RenderTreeNode>>((width + 1) * (height + 1));
+}
+
+optional_ptr<RenderTreeNode> RenderTree::GetNode(idx_t x, idx_t y) {
+	if (x >= width || y >= height) {
+		return nullptr;
+	}
+	return nodes[GetPosition(x, y)].get();
+}
+
+bool RenderTree::HasNode(idx_t x, idx_t y) {
+	if (x >= width || y >= height) {
+		return false;
+	}
+	return nodes[GetPosition(x, y)].get() != nullptr;
+}
+
+idx_t RenderTree::GetPosition(idx_t x, idx_t y) {
+	return y * width + x;
+}
+
+void RenderTree::SetNode(idx_t x, idx_t y, unique_ptr<RenderTreeNode> node) {
+	nodes[GetPosition(x, y)] = std::move(node);
+}
+
+unique_ptr<RenderTree> RenderTree::CreateRenderTree(const LogicalOperator &op) {
+	return CreateTree<LogicalOperator>(op);
+}
+
+unique_ptr<RenderTree> RenderTree::CreateRenderTree(const PhysicalOperator &op) {
+	return CreateTree<PhysicalOperator>(op);
+}
+
+unique_ptr<RenderTree> RenderTree::CreateRenderTree(const ProfilingNode &op) {
+	return CreateTree<ProfilingNode>(op);
+}
+
+void RenderTree::SanitizeKeyNames() {
+	for (idx_t i = 0; i < width * height; i++) {
+		if (!nodes[i]) {
+			continue;
+		}
+		InsertionOrderPreservingMap<string> new_map;
+		for (auto &entry : nodes[i]->extra_text) {
+			auto key = entry.first;
+			if (StringUtil::StartsWith(key, "__")) {
+				key = StringUtil::Replace(key, "__", "");
+				key = StringUtil::Replace(key, "_", " ");
+				key = StringUtil::Title(key);
+			}
+			auto &value = entry.second;
+			new_map.insert(make_pair(key, value));
+		}
+		nodes[i]->extra_text = std::move(new_map);
+	}
+}
+
+unique_ptr<RenderTree> RenderTree::CreateRenderTree(const Pipeline &pipeline) {
+	auto operators = pipeline.GetOperators();
+	D_ASSERT(!operators.empty());
+	unique_ptr<PipelineRenderNode> node;
+	for (auto &op : operators) {
+		auto new_node = make_uniq<PipelineRenderNode>(op.get());
+		new_node->child = std::move(node);
+		node = std::move(new_node);
+	}
+	return CreateTree<PipelineRenderNode>(*node);
+}
+
+} // namespace duckdb

package/src/duckdb/src/common/row_operations/row_aggregate.cpp

@@ -25,7 +25,7 @@ void RowOperations::InitializeStates(TupleDataLayout &layout, Vector &addresses,
 		for (idx_t i = 0; i < count; ++i) {
 			auto row_idx = sel.get_index(i);
 			auto row = pointers[row_idx];
-			aggr.function.initialize(row + offsets[aggr_idx]);
+			aggr.function.initialize(aggr.function, row + offsets[aggr_idx]);
 		}
 		++aggr_idx;
 	}

package/src/duckdb/src/common/row_operations/row_gather.cpp

@@ -96,8 +96,8 @@ static void GatherNestedVector(Vector &rows, const SelectionVector &row_sel, Vec
 	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
 
 	// Build the gather locations
-	auto data_locations = make_unsafe_uniq_array<data_ptr_t>(count);
-	auto mask_locations = make_unsafe_uniq_array<data_ptr_t>(count);
+	auto data_locations = make_unsafe_uniq_array_uninitialized<data_ptr_t>(count);
+	auto mask_locations = make_unsafe_uniq_array_uninitialized<data_ptr_t>(count);
 	for (idx_t i = 0; i < count; i++) {
 		auto row_idx = row_sel.get_index(i);
 		auto row = ptrs[row_idx];

package/src/duckdb/src/common/row_operations/row_matcher.cpp

@@ -8,10 +8,10 @@ namespace duckdb {
 
 using ValidityBytes = TupleDataLayout::ValidityBytes;
 
-template <bool NO_MATCH_SEL, class T, class OP>
-static idx_t TemplatedMatch(Vector &, const TupleDataVectorFormat &lhs_format, SelectionVector &sel, const idx_t count,
-                            const TupleDataLayout &rhs_layout, Vector &rhs_row_locations, const idx_t col_idx,
-                            const vector<MatchFunction> &, SelectionVector *no_match_sel, idx_t &no_match_count) {
+template <bool NO_MATCH_SEL, class T, class OP, bool LHS_ALL_VALID>
+static idx_t TemplatedMatchLoop(const TupleDataVectorFormat &lhs_format, SelectionVector &sel, const idx_t count,
+                                const TupleDataLayout &rhs_layout, Vector &rhs_row_locations, const idx_t col_idx,
+                                SelectionVector *no_match_sel, idx_t &no_match_count) {
 	using COMPARISON_OP = ComparisonOperationWrapper<OP>;
 
 	// LHS
@@ -31,7 +31,7 @@ static idx_t TemplatedMatch(Vector &, const TupleDataVectorFormat &lhs_format, S
 		const auto idx = sel.get_index(i);
 
 		const auto lhs_idx = lhs_sel.get_index(idx);
-		const auto lhs_null = lhs_validity.AllValid() ? false : !lhs_validity.RowIsValid(lhs_idx);
+		const auto lhs_null = LHS_ALL_VALID ? false : !lhs_validity.RowIsValid(lhs_idx);
 
 		const auto &rhs_location = rhs_locations[idx];
 		const ValidityBytes rhs_mask(rhs_location);
@@ -47,6 +47,19 @@ static idx_t TemplatedMatch(Vector &, const TupleDataVectorFormat &lhs_format, S
 	return match_count;
 }
 
+template <bool NO_MATCH_SEL, class T, class OP>
+static idx_t TemplatedMatch(Vector &, const TupleDataVectorFormat &lhs_format, SelectionVector &sel, const idx_t count,
+                            const TupleDataLayout &rhs_layout, Vector &rhs_row_locations, const idx_t col_idx,
+                            const vector<MatchFunction> &, SelectionVector *no_match_sel, idx_t &no_match_count) {
+	if (lhs_format.unified.validity.AllValid()) {
+		return TemplatedMatchLoop<NO_MATCH_SEL, T, OP, true>(lhs_format, sel, count, rhs_layout, rhs_row_locations,
+		                                                     col_idx, no_match_sel, no_match_count);
+	} else {
+		return TemplatedMatchLoop<NO_MATCH_SEL, T, OP, false>(lhs_format, sel, count, rhs_layout, rhs_row_locations,
+		                                                      col_idx, no_match_sel, no_match_count);
+	}
+}
+
 template <bool NO_MATCH_SEL, class OP>
 static idx_t StructMatchEquality(Vector &lhs_vector, const TupleDataVectorFormat &lhs_format, SelectionVector &sel,
                                  const idx_t count, const TupleDataLayout &rhs_layout, Vector &rhs_row_locations,
@@ -198,6 +211,22 @@ void RowMatcher::Initialize(const bool no_match_sel, const TupleDataLayout &layo
 	}
 }
 
+void RowMatcher::Initialize(const bool no_match_sel, const TupleDataLayout &layout, const Predicates &predicates,
+                            vector<column_t> &columns) {
+
+	// The columns must have the same size as the predicates vector
+	D_ASSERT(columns.size() == predicates.size());
+
+	// The largest column_id must be smaller than the number of types to not cause an out-of-bounds error
+	D_ASSERT(*max_element(columns.begin(), columns.end()) < layout.GetTypes().size());
+
+	match_functions.reserve(predicates.size());
+	for (idx_t idx = 0; idx < predicates.size(); idx++) {
+		column_t col_idx = columns[idx];
+		match_functions.push_back(GetMatchFunction(no_match_sel, layout.GetTypes()[col_idx], predicates[idx]));
+	}
+}
+
 idx_t RowMatcher::Match(DataChunk &lhs, const vector<TupleDataVectorFormat> &lhs_formats, SelectionVector &sel,
                         idx_t count, const TupleDataLayout &rhs_layout, Vector &rhs_row_locations,
                         SelectionVector *no_match_sel, idx_t &no_match_count) {
@@ -211,6 +240,30 @@ idx_t RowMatcher::Match(DataChunk &lhs, const vector<TupleDataVectorFormat> &lhs
 	return count;
 }
 
+idx_t RowMatcher::Match(DataChunk &lhs, const vector<TupleDataVectorFormat> &lhs_formats, SelectionVector &sel,
+                        idx_t count, const TupleDataLayout &rhs_layout, Vector &rhs_row_locations,
+                        SelectionVector *no_match_sel, idx_t &no_match_count, const vector<column_t> &columns) {
+	D_ASSERT(!match_functions.empty());
+
+	// The column_ids must have the same size as the match_functions vector
+	D_ASSERT(columns.size() == match_functions.size());
+
+	// The largest column_id must be smaller than the number columns to not cause an out-of-bounds error
+	D_ASSERT(*max_element(columns.begin(), columns.end()) < lhs.ColumnCount());
+
+	for (idx_t fun_idx = 0; fun_idx < match_functions.size(); fun_idx++) {
+		// if we only care about specific columns, we need to use the column_ids to get the correct column index
+		// otherwise, we just use the fun_idx
+		const auto col_idx = columns[fun_idx];
+
+		const auto &match_function = match_functions[fun_idx];
+		count =
+		    match_function.function(lhs.data[col_idx], lhs_formats[col_idx], sel, count, rhs_layout, rhs_row_locations,
+		                            col_idx, match_function.child_functions, no_match_sel, no_match_count);
+	}
+	return count;
+}
+
 MatchFunction RowMatcher::GetMatchFunction(const bool no_match_sel, const LogicalType &type,
                                            const ExpressionType predicate) {
 	return no_match_sel ? GetMatchFunction<true>(type, predicate) : GetMatchFunction<false>(type, predicate);