duckdb 0.10.2-dev0.0 → 0.10.2-dev3.0

package/src/duckdb/src/core_functions/scalar/list/flatten.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/storage/statistics/list_stats.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
 
 namespace duckdb {
 
@@ -17,24 +18,33 @@ void ListFlattenFunction(DataChunk &args, ExpressionState &state, Vector &result
 
 	idx_t count = args.size();
 
-	UnifiedVectorFormat list_data;
-	input.ToUnifiedFormat(count, list_data);
-	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
-	auto &child_vector = ListVector::GetEntry(input);
-
+	// Prepare the result vector
 	result.SetVectorType(VectorType::FLAT_VECTOR);
+	// This holds the new offsets and lengths
 	auto result_entries = FlatVector::GetData<list_entry_t>(result);
 	auto &result_validity = FlatVector::Validity(result);
 
-	if (child_vector.GetType().id() == LogicalTypeId::SQLNULL) {
-		for (idx_t i = 0; i < count; i++) {
-			auto list_index = list_data.sel->get_index(i);
-			if (!list_data.validity.RowIsValid(list_index)) {
-				result_validity.SetInvalid(i);
+	// The outermost list in each row
+	UnifiedVectorFormat row_data;
+	input.ToUnifiedFormat(count, row_data);
+	auto row_entries = UnifiedVectorFormat::GetData<list_entry_t>(row_data);
+
+	// The list elements in each row: [HERE, ...]
+	auto &row_lists = ListVector::GetEntry(input);
+	UnifiedVectorFormat row_lists_data;
+	idx_t total_row_lists = ListVector::GetListSize(input);
+	row_lists.ToUnifiedFormat(total_row_lists, row_lists_data);
+	auto row_lists_entries = UnifiedVectorFormat::GetData<list_entry_t>(row_lists_data);
+
+	if (row_lists.GetType().id() == LogicalTypeId::SQLNULL) {
+		for (idx_t row_cnt = 0; row_cnt < count; row_cnt++) {
+			auto row_idx = row_data.sel->get_index(row_cnt);
+			if (!row_data.validity.RowIsValid(row_idx)) {
+				result_validity.SetInvalid(row_cnt);
 				continue;
 			}
-			result_entries[i].offset = 0;
-			result_entries[i].length = 0;
+			result_entries[row_cnt].offset = 0;
+			result_entries[row_cnt].length = 0;
 		}
 		if (args.AllConstant()) {
 			result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -42,48 +52,59 @@ void ListFlattenFunction(DataChunk &args, ExpressionState &state, Vector &result
 		return;
 	}
 
-	auto child_size = ListVector::GetListSize(input);
-	UnifiedVectorFormat child_data;
-	child_vector.ToUnifiedFormat(child_size, child_data);
-	auto child_entries = UnifiedVectorFormat::GetData<list_entry_t>(child_data);
-	auto &data_vector = ListVector::GetEntry(child_vector);
-
-	idx_t offset = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto list_index = list_data.sel->get_index(i);
-		if (!list_data.validity.RowIsValid(list_index)) {
-			result_validity.SetInvalid(i);
+	// The actual elements inside each row list: [[HERE, ...], []]
+	// This one becomes the child vector of the result.
+	auto &elem_vector = ListVector::GetEntry(row_lists);
+
+	// We'll use this selection vector to slice the elem_vector.
+	idx_t child_elem_cnt = ListVector::GetListSize(row_lists);
+	SelectionVector sel(child_elem_cnt);
+	idx_t sel_idx = 0;
+
+	// HERE, [[]], ...
+	for (idx_t row_cnt = 0; row_cnt < count; row_cnt++) {
+		auto row_idx = row_data.sel->get_index(row_cnt);
+
+		if (!row_data.validity.RowIsValid(row_idx)) {
+			result_validity.SetInvalid(row_cnt);
 			continue;
 		}
-		auto list_entry = list_entries[list_index];
-
-		idx_t source_offset = 0;
-		// Find first valid child list entry to get offset
-		for (idx_t j = 0; j < list_entry.length; j++) {
-			auto child_list_index = child_data.sel->get_index(list_entry.offset + j);
-			if (child_data.validity.RowIsValid(child_list_index)) {
-				source_offset = child_entries[child_list_index].offset;
-				break;
+
+		idx_t list_offset = sel_idx;
+		idx_t list_length = 0;
+
+		// [HERE, [...], ...]
+		auto row_entry = row_entries[row_idx];
+		for (idx_t row_lists_cnt = 0; row_lists_cnt < row_entry.length; row_lists_cnt++) {
+			auto row_lists_idx = row_lists_data.sel->get_index(row_entry.offset + row_lists_cnt);
+
+			// Skip invalid lists
+			if (!row_lists_data.validity.RowIsValid(row_lists_idx)) {
+				continue;
 			}
-		}
 
-		idx_t length = 0;
-		// Find last valid child list entry to get length
-		for (idx_t j = list_entry.length - 1; j != (idx_t)-1; j--) {
-			auto child_list_index = child_data.sel->get_index(list_entry.offset + j);
-			if (child_data.validity.RowIsValid(child_list_index)) {
-				auto child_entry = child_entries[child_list_index];
-				length = child_entry.offset + child_entry.length - source_offset;
-				break;
+			// [[HERE, ...], [.., ...]]
+			auto list_entry = row_lists_entries[row_lists_idx];
+			list_length += list_entry.length;
+
+			for (idx_t elem_cnt = 0; elem_cnt < list_entry.length; elem_cnt++) {
+				// offset of the element in the elem_vector.
+				idx_t offset = list_entry.offset + elem_cnt;
+				sel.set_index(sel_idx, offset);
+				sel_idx++;
 			}
 		}
-		ListVector::Append(result, data_vector, source_offset + length, source_offset);
 
-		result_entries[i].offset = offset;
-		result_entries[i].length = length;
-		offset += length;
+		result_entries[row_cnt].offset = list_offset;
+		result_entries[row_cnt].length = list_length;
 	}
 
+	ListVector::SetListSize(result, sel_idx);
+
+	auto &result_child_vector = ListVector::GetEntry(result);
+	result_child_vector.Slice(elem_vector, sel, sel_idx);
+	result_child_vector.Flatten(sel_idx);
+
 	if (args.AllConstant()) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	}
@@ -93,6 +114,22 @@ static unique_ptr<FunctionData> ListFlattenBind(ClientContext &context, ScalarFu
                                                 vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(bound_function.arguments.size() == 1);
 
+	if (arguments[0]->return_type.id() == LogicalTypeId::ARRAY) {
+		auto child_type = ArrayType::GetChildType(arguments[0]->return_type);
+		if (child_type.id() == LogicalTypeId::ARRAY) {
+			child_type = LogicalType::LIST(ArrayType::GetChildType(child_type));
+		}
+		arguments[0] =
+		    BoundCastExpression::AddCastToType(context, std::move(arguments[0]), LogicalType::LIST(child_type));
+	} else if (arguments[0]->return_type.id() == LogicalTypeId::LIST) {
+		auto child_type = ListType::GetChildType(arguments[0]->return_type);
+		if (child_type.id() == LogicalTypeId::ARRAY) {
+			child_type = LogicalType::LIST(ArrayType::GetChildType(child_type));
+			arguments[0] =
+			    BoundCastExpression::AddCastToType(context, std::move(arguments[0]), LogicalType::LIST(child_type));
+		}
+	}
+
 	auto &input_type = arguments[0]->return_type;
 	bound_function.arguments[0] = input_type;
 	if (input_type.id() == LogicalTypeId::UNKNOWN) {

package/src/duckdb/src/core_functions/scalar/list/list_aggregates.cpp

@@ -474,12 +474,12 @@ static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, Scala
 
 	FunctionBinder function_binder(context);
 	auto best_function_idx = function_binder.BindFunction(func.name, func.functions, types, error);
-	if (best_function_idx == DConstants::INVALID_INDEX) {
+	if (!best_function_idx.IsValid()) {
 		throw BinderException("No matching aggregate function\n%s", error.Message());
 	}
 
 	// found a matching function, bind it as an aggregate
-	auto best_function = func.functions.GetFunctionByOffset(best_function_idx);
+	auto best_function = func.functions.GetFunctionByOffset(best_function_idx.GetIndex());
 	if (IS_AGGR) {
 		return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, child_type, best_function, arguments);
 	}

package/src/duckdb/src/core_functions/scalar/list/list_sort.cpp

@@ -239,6 +239,9 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 			auto &result_entry = ListVector::GetEntry(result);
 			auto result_data = ListVector::GetData(result);
 			for (idx_t i = 0; i < count; i++) {
+				if (!result_validity.RowIsValid(i)) {
+					continue;
+				}
 				for (idx_t j = result_data[i].offset; j < result_data[i].offset + result_data[i].length; j++) {
 					auto b = sel_sorted.get_index(j) - result_data[i].offset;
 					result_entry.SetValue(j, Value::BIGINT(b + 1));

package/src/duckdb/src/core_functions/scalar/math/numeric.cpp

@@ -167,7 +167,8 @@ ScalarFunctionSet AbsOperatorFun::GetFunctions() {
 		case LogicalTypeId::TINYINT:
 		case LogicalTypeId::SMALLINT:
 		case LogicalTypeId::INTEGER:
-		case LogicalTypeId::BIGINT: {
+		case LogicalTypeId::BIGINT:
+		case LogicalTypeId::HUGEINT: {
 			ScalarFunction func({type}, type, ScalarFunction::GetScalarUnaryFunction<TryAbsOperator>(type));
 			func.statistics = PropagateAbsStats;
 			abs.AddFunction(func);
@@ -575,7 +576,7 @@ static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionSt
 	auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
 	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
 	auto width = DecimalType::GetWidth(func_expr.children[0]->return_type);
-	if (info.target_scale <= -int32_t(width)) {
+	if (info.target_scale <= -int32_t(width - source_scale)) {
 		// scale too big for width
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 		result.SetValue(0, Value::INTEGER(0));

package/src/duckdb/src/core_functions/scalar/string/hex.cpp

@@ -392,16 +392,14 @@ ScalarFunctionSet HexFun::GetFunctions() {
 	ScalarFunctionSet to_hex;
 	to_hex.AddFunction(
 	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
-
+	to_hex.AddFunction(
+	    ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
 	to_hex.AddFunction(
 	    ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, ToHexFunction<int64_t, HexIntegralOperator>));
-
 	to_hex.AddFunction(
 	    ScalarFunction({LogicalType::UBIGINT}, LogicalType::VARCHAR, ToHexFunction<uint64_t, HexIntegralOperator>));
-
 	to_hex.AddFunction(
 	    ScalarFunction({LogicalType::HUGEINT}, LogicalType::VARCHAR, ToHexFunction<hugeint_t, HexHugeIntOperator>));
-
 	to_hex.AddFunction(
 	    ScalarFunction({LogicalType::UHUGEINT}, LogicalType::VARCHAR, ToHexFunction<uhugeint_t, HexUhugeIntOperator>));
 	return to_hex;

package/src/duckdb/src/core_functions/scalar/string/repeat.cpp

@@ -1,34 +1,25 @@
-#include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/binary_executor.hpp"
 #include "duckdb/core_functions/scalar/string_functions.hpp"
 
-#include <ctype.h>
-#include <string.h>
-
 namespace duckdb {
 
-static string_t RepeatScalarFunction(const string_t &str, const int64_t cnt, vector<char> &result) {
-	// Get information about the repeated string
-	auto input_str = str.GetData();
-	auto size_str = str.GetSize();
-
-	//  Reuse the buffer
-	result.clear();
-	for (auto remaining = cnt; remaining-- > 0;) {
-		result.insert(result.end(), input_str, input_str + size_str);
-	}
-
-	return string_t(result.data(), UnsafeNumericCast<uint32_t>(result.size()));
-}
-
-static void RepeatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void RepeatFunction(DataChunk &args, ExpressionState &, Vector &result) {
 	auto &str_vector = args.data[0];
 	auto &cnt_vector = args.data[1];
 
-	vector<char> buffer;
 	BinaryExecutor::Execute<string_t, int64_t, string_t>(
 	    str_vector, cnt_vector, result, args.size(), [&](string_t str, int64_t cnt) {
-		    return StringVector::AddString(result, RepeatScalarFunction(str, cnt, buffer));
+		    auto input_str = str.GetData();
+		    auto size_str = str.GetSize();
+
+		    idx_t copy_count = cnt <= 0 || size_str == 0 ? 0 : idx_t(cnt);
+		    auto result_str = StringVector::EmptyString(result, size_str * copy_count);
+		    auto result_data = result_str.GetDataWriteable();
+		    for (idx_t i = 0; i < copy_count; i++) {
+			    memcpy(result_data + i * size_str, input_str, size_str);
+		    }
+		    result_str.Finalize();
+		    return result_str;
 	    });
 }
 

package/src/duckdb/src/execution/column_binding_resolver.cpp

@@ -162,17 +162,9 @@ unique_ptr<Expression> ColumnBindingResolver::VisitReplace(BoundColumnRefExpress
 	// LCOV_EXCL_START
 	// could not bind the column reference, this should never happen and indicates a bug in the code
 	// generate an error message
-	string bound_columns = "[";
-	for (idx_t i = 0; i < bindings.size(); i++) {
-		if (i != 0) {
-			bound_columns += " ";
-		}
-		bound_columns += to_string(bindings[i].table_index) + "." + to_string(bindings[i].column_index);
-	}
-	bound_columns += "]";
-
 	throw InternalException("Failed to bind column reference \"%s\" [%d.%d] (bindings: %s)", expr.alias,
-	                        expr.binding.table_index, expr.binding.column_index, bound_columns);
+	                        expr.binding.table_index, expr.binding.column_index,
+	                        LogicalOperator::ColumnBindingsToString(bindings));
 	// LCOV_EXCL_STOP
 }
 

package/src/duckdb/src/execution/expression_executor/execute_comparison.cpp

@@ -58,48 +58,87 @@ void ExpressionExecutor::Execute(const BoundComparisonExpression &expr, Expressi
 	}
 }
 
+static void UpdateNullMask(Vector &vec, optional_ptr<const SelectionVector> sel, idx_t count, ValidityMask &null_mask) {
+	UnifiedVectorFormat vdata;
+	vec.ToUnifiedFormat(count, vdata);
+
+	if (vdata.validity.AllValid()) {
+		return;
+	}
+
+	if (!sel) {
+		sel = FlatVector::IncrementalSelectionVector();
+	}
+
+	for (idx_t i = 0; i < count; ++i) {
+		const auto ridx = sel->get_index(i);
+		const auto vidx = vdata.sel->get_index(i);
+		if (!vdata.validity.RowIsValid(vidx)) {
+			null_mask.SetInvalid(ridx);
+		}
+	}
+}
+
 template <typename OP>
-static idx_t NestedSelectOperation(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                   SelectionVector *true_sel, SelectionVector *false_sel);
+static idx_t NestedSelectOperation(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
+                                   optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
+                                   optional_ptr<ValidityMask> null_mask);
 
 template <class OP>
-static idx_t TemplatedSelectOperation(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                      SelectionVector *true_sel, SelectionVector *false_sel) {
-	// the inplace loops take the result as the last parameter
+static idx_t TemplatedSelectOperation(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
+                                      optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
+                                      optional_ptr<ValidityMask> null_mask) {
+	if (null_mask) {
+		UpdateNullMask(left, sel, count, *null_mask);
+		UpdateNullMask(right, sel, count, *null_mask);
+	}
 	switch (left.GetType().InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
-		return BinaryExecutor::Select<int8_t, int8_t, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<int8_t, int8_t, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                  false_sel.get());
 	case PhysicalType::INT16:
-		return BinaryExecutor::Select<int16_t, int16_t, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<int16_t, int16_t, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                    false_sel.get());
 	case PhysicalType::INT32:
-		return BinaryExecutor::Select<int32_t, int32_t, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<int32_t, int32_t, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                    false_sel.get());
 	case PhysicalType::INT64:
-		return BinaryExecutor::Select<int64_t, int64_t, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<int64_t, int64_t, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                    false_sel.get());
 	case PhysicalType::UINT8:
-		return BinaryExecutor::Select<uint8_t, uint8_t, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<uint8_t, uint8_t, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                    false_sel.get());
 	case PhysicalType::UINT16:
-		return BinaryExecutor::Select<uint16_t, uint16_t, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<uint16_t, uint16_t, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                      false_sel.get());
 	case PhysicalType::UINT32:
-		return BinaryExecutor::Select<uint32_t, uint32_t, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<uint32_t, uint32_t, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                      false_sel.get());
 	case PhysicalType::UINT64:
-		return BinaryExecutor::Select<uint64_t, uint64_t, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<uint64_t, uint64_t, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                      false_sel.get());
 	case PhysicalType::INT128:
-		return BinaryExecutor::Select<hugeint_t, hugeint_t, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<hugeint_t, hugeint_t, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                        false_sel.get());
 	case PhysicalType::UINT128:
-		return BinaryExecutor::Select<uhugeint_t, uhugeint_t, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<uhugeint_t, uhugeint_t, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                          false_sel.get());
 	case PhysicalType::FLOAT:
-		return BinaryExecutor::Select<float, float, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<float, float, OP>(left, right, sel.get(), count, true_sel.get(), false_sel.get());
 	case PhysicalType::DOUBLE:
-		return BinaryExecutor::Select<double, double, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<double, double, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                  false_sel.get());
 	case PhysicalType::INTERVAL:
-		return BinaryExecutor::Select<interval_t, interval_t, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<interval_t, interval_t, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                          false_sel.get());
 	case PhysicalType::VARCHAR:
-		return BinaryExecutor::Select<string_t, string_t, OP>(left, right, sel, count, true_sel, false_sel);
+		return BinaryExecutor::Select<string_t, string_t, OP>(left, right, sel.get(), count, true_sel.get(),
+		                                                      false_sel.get());
 	case PhysicalType::LIST:
 	case PhysicalType::STRUCT:
 	case PhysicalType::ARRAY:
-		return NestedSelectOperation<OP>(left, right, sel, count, true_sel, false_sel);
+		return NestedSelectOperation<OP>(left, right, sel, count, true_sel, false_sel, null_mask);
 	default:
 		throw InternalException("Invalid type for comparison");
 	}
@@ -109,52 +148,66 @@ struct NestedSelector {
 	// Select the matching rows for the values of a nested type that are not both NULL.
 	// Those semantics are the same as the corresponding non-distinct comparator
 	template <typename OP>
-	static idx_t Select(Vector &left, Vector &right, const SelectionVector &sel, idx_t count, SelectionVector *true_sel,
-	                    SelectionVector *false_sel) {
+	static idx_t Select(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
+	                    optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
+	                    optional_ptr<ValidityMask> null_mask) {
 		throw InvalidTypeException(left.GetType(), "Invalid operation for nested SELECT");
 	}
 };
 
 template <>
-idx_t NestedSelector::Select<duckdb::Equals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                             SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::NestedEquals(left, right, sel, count, true_sel, false_sel);
+idx_t NestedSelector::Select<duckdb::Equals>(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
+                                             idx_t count, optional_ptr<SelectionVector> true_sel,
+                                             optional_ptr<SelectionVector> false_sel,
+                                             optional_ptr<ValidityMask> null_mask) {
+	return VectorOperations::NestedEquals(left, right, sel, count, true_sel, false_sel, null_mask);
 }
 
 template <>
-idx_t NestedSelector::Select<duckdb::NotEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                                SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::NestedNotEquals(left, right, sel, count, true_sel, false_sel);
+idx_t NestedSelector::Select<duckdb::NotEquals>(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
+                                                idx_t count, optional_ptr<SelectionVector> true_sel,
+                                                optional_ptr<SelectionVector> false_sel,
+                                                optional_ptr<ValidityMask> null_mask) {
+	return VectorOperations::NestedNotEquals(left, right, sel, count, true_sel, false_sel, null_mask);
 }
 
 template <>
-idx_t NestedSelector::Select<duckdb::LessThan>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                               SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThan(left, right, &sel, count, true_sel, false_sel);
+idx_t NestedSelector::Select<duckdb::LessThan>(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
+                                               idx_t count, optional_ptr<SelectionVector> true_sel,
+                                               optional_ptr<SelectionVector> false_sel,
+                                               optional_ptr<ValidityMask> null_mask) {
+	return VectorOperations::DistinctLessThan(left, right, sel, count, true_sel, false_sel, null_mask);
 }
 
 template <>
-idx_t NestedSelector::Select<duckdb::LessThanEquals>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                     idx_t count, SelectionVector *true_sel,
-                                                     SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThanEquals(left, right, &sel, count, true_sel, false_sel);
+idx_t NestedSelector::Select<duckdb::LessThanEquals>(Vector &left, Vector &right,
+                                                     optional_ptr<const SelectionVector> sel, idx_t count,
+                                                     optional_ptr<SelectionVector> true_sel,
+                                                     optional_ptr<SelectionVector> false_sel,
+                                                     optional_ptr<ValidityMask> null_mask) {
+	return VectorOperations::DistinctLessThanEquals(left, right, sel, count, true_sel, false_sel, null_mask);
 }
 
 template <>
-idx_t NestedSelector::Select<duckdb::GreaterThan>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                                  SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctGreaterThan(left, right, &sel, count, true_sel, false_sel);
+idx_t NestedSelector::Select<duckdb::GreaterThan>(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
+                                                  idx_t count, optional_ptr<SelectionVector> true_sel,
+                                                  optional_ptr<SelectionVector> false_sel,
+                                                  optional_ptr<ValidityMask> null_mask) {
+	return VectorOperations::DistinctGreaterThan(left, right, sel, count, true_sel, false_sel, null_mask);
 }
 
 template <>
-idx_t NestedSelector::Select<duckdb::GreaterThanEquals>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                        idx_t count, SelectionVector *true_sel,
-                                                        SelectionVector *false_sel) {
-	return VectorOperations::DistinctGreaterThanEquals(left, right, &sel, count, true_sel, false_sel);
+idx_t NestedSelector::Select<duckdb::GreaterThanEquals>(Vector &left, Vector &right,
+                                                        optional_ptr<const SelectionVector> sel, idx_t count,
+                                                        optional_ptr<SelectionVector> true_sel,
+                                                        optional_ptr<SelectionVector> false_sel,
+                                                        optional_ptr<ValidityMask> null_mask) {
+	return VectorOperations::DistinctGreaterThanEquals(left, right, sel, count, true_sel, false_sel, null_mask);
 }
 
 static inline idx_t SelectNotNull(Vector &left, Vector &right, const idx_t count, const SelectionVector &sel,
-                                  SelectionVector &maybe_vec, OptionalSelection &false_opt) {
+                                  SelectionVector &maybe_vec, OptionalSelection &false_opt,
+                                  optional_ptr<ValidityMask> null_mask) {
 
 	UnifiedVectorFormat lvdata, rvdata;
 	left.ToUnifiedFormat(count, lvdata);
@@ -183,6 +236,9 @@ static inline idx_t SelectNotNull(Vector &left, Vector &right, const idx_t count
 		const auto lidx = lvdata.sel->get_index(i);
 		const auto ridx = rvdata.sel->get_index(i);
 		if (!lmask.RowIsValid(lidx) || !rmask.RowIsValid(ridx)) {
+			if (null_mask) {
+				null_mask->SetInvalid(result_idx);
+			}
 			false_opt.Append(false_count, result_idx);
 		} else {
 			//	Neither is NULL, distinguish values.
@@ -200,7 +256,8 @@ static inline idx_t SelectNotNull(Vector &left, Vector &right, const idx_t count
 	return remaining;
 }
 
-static void ScatterSelection(SelectionVector *target, const idx_t count, const SelectionVector &dense_vec) {
+static void ScatterSelection(optional_ptr<SelectionVector> target, const idx_t count,
+                             const SelectionVector &dense_vec) {
 	if (target) {
 		for (idx_t i = 0; i < count; ++i) {
 			target->set_index(i, dense_vec.get_index(i));
@@ -209,8 +266,9 @@ static void ScatterSelection(SelectionVector *target, const idx_t count, const S
 }
 
 template <typename OP>
-static idx_t NestedSelectOperation(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                   SelectionVector *true_sel, SelectionVector *false_sel) {
+static idx_t NestedSelectOperation(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
+                                   optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
+                                   optional_ptr<ValidityMask> null_mask) {
 	// The Select operations all use a dense pair of input vectors to partition
 	// a selection vector in a single pass. But to implement progressive comparisons,
 	// we have to make multiple passes, so we need to keep track of the original input positions
@@ -233,12 +291,14 @@ static idx_t NestedSelectOperation(Vector &left, Vector &right, const SelectionV
 	Vector l_not_null(left);
 	Vector r_not_null(right);
 
-	auto match_count = SelectNotNull(l_not_null, r_not_null, count, *sel, maybe_vec, false_opt);
+	auto match_count = SelectNotNull(l_not_null, r_not_null, count, *sel, maybe_vec, false_opt, null_mask);
 	auto no_match_count = count - match_count;
 	count = match_count;
 
 	//	Now that we have handled the NULLs, we can use the recursive nested comparator for the rest.
-	match_count = NestedSelector::Select<OP>(l_not_null, r_not_null, maybe_vec, count, true_opt, false_opt);
+	match_count =
+	    NestedSelector::Select<OP>(l_not_null, r_not_null, &maybe_vec, count, optional_ptr<SelectionVector>(true_opt),
+	                               optional_ptr<SelectionVector>(false_opt), null_mask);
 	no_match_count += (count - match_count);
 
 	// Copy the buffered selections to the output selections
@@ -248,34 +308,41 @@ static idx_t NestedSelectOperation(Vector &left, Vector &right, const SelectionV
 	return match_count;
 }
 
-idx_t VectorOperations::Equals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                               SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::Equals>(left, right, sel, count, true_sel, false_sel);
+idx_t VectorOperations::Equals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
+                               optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
+                               optional_ptr<ValidityMask> null_mask) {
+	return TemplatedSelectOperation<duckdb::Equals>(left, right, sel, count, true_sel, false_sel, null_mask);
 }
 
-idx_t VectorOperations::NotEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                  SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::NotEquals>(left, right, sel, count, true_sel, false_sel);
+idx_t VectorOperations::NotEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
+                                  optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
+                                  optional_ptr<ValidityMask> null_mask) {
+	return TemplatedSelectOperation<duckdb::NotEquals>(left, right, sel, count, true_sel, false_sel, null_mask);
 }
 
-idx_t VectorOperations::GreaterThan(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                    SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::GreaterThan>(left, right, sel, count, true_sel, false_sel);
+idx_t VectorOperations::GreaterThan(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
+                                    optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
+                                    optional_ptr<ValidityMask> null_mask) {
+	return TemplatedSelectOperation<duckdb::GreaterThan>(left, right, sel, count, true_sel, false_sel, null_mask);
 }
 
-idx_t VectorOperations::GreaterThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                          SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::GreaterThanEquals>(left, right, sel, count, true_sel, false_sel);
+idx_t VectorOperations::GreaterThanEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
+                                          idx_t count, optional_ptr<SelectionVector> true_sel,
+                                          optional_ptr<SelectionVector> false_sel,
+                                          optional_ptr<ValidityMask> null_mask) {
+	return TemplatedSelectOperation<duckdb::GreaterThanEquals>(left, right, sel, count, true_sel, false_sel, null_mask);
 }
 
-idx_t VectorOperations::LessThan(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                 SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::GreaterThan>(right, left, sel, count, true_sel, false_sel);
+idx_t VectorOperations::LessThan(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel, idx_t count,
+                                 optional_ptr<SelectionVector> true_sel, optional_ptr<SelectionVector> false_sel,
+                                 optional_ptr<ValidityMask> null_mask) {
+	return TemplatedSelectOperation<duckdb::GreaterThan>(right, left, sel, count, true_sel, false_sel, null_mask);
 }
 
-idx_t VectorOperations::LessThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                       SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::GreaterThanEquals>(right, left, sel, count, true_sel, false_sel);
+idx_t VectorOperations::LessThanEquals(Vector &left, Vector &right, optional_ptr<const SelectionVector> sel,
+                                       idx_t count, optional_ptr<SelectionVector> true_sel,
+                                       optional_ptr<SelectionVector> false_sel, optional_ptr<ValidityMask> null_mask) {
+	return TemplatedSelectOperation<duckdb::GreaterThanEquals>(right, left, sel, count, true_sel, false_sel, null_mask);
 }
 
 idx_t ExpressionExecutor::Select(const BoundComparisonExpression &expr, ExpressionState *state,

package/src/duckdb/src/execution/expression_executor/execute_function.cpp

@@ -74,10 +74,8 @@ void ExpressionExecutor::Execute(const BoundFunctionExpression &expr, Expression
 	arguments.SetCardinality(count);
 	arguments.Verify();
 
-	state->profiler.BeginSample();
 	D_ASSERT(expr.function.function);
 	expr.function.function(arguments, *state, result);
-	state->profiler.EndSample(NumericCast<int>(count));
 
 	VerifyNullHandling(expr, arguments, result);
 	D_ASSERT(result.GetType() == expr.return_type);