duckdb 1.1.3 → 1.1.4-dev9.0

package/src/duckdb/{src/include/duckdb → extension/core_functions/include}/core_functions/aggregate/quantile_sort_tree.hpp

@@ -8,10 +8,15 @@
 
 #pragma once
 
-#include "duckdb/core_functions/aggregate/quantile_helpers.hpp"
+#include "duckdb/common/sort/sort.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
+#include "duckdb/common/types/row/row_layout.hpp"
+#include "core_functions/aggregate/quantile_helpers.hpp"
 #include "duckdb/execution/merge_sort_tree.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/operator/multiply.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/function/window/window_index_tree.hpp"
 #include <algorithm>
 #include <numeric>
 #include <stdlib.h>
@@ -19,6 +24,64 @@
 
 namespace duckdb {
 
+// Paged access
+template <typename INPUT_TYPE>
+struct QuantileCursor {
+	explicit QuantileCursor(const WindowPartitionInput &partition) : inputs(*partition.inputs) {
+		D_ASSERT(partition.column_ids.size() == 1);
+		inputs.InitializeScan(scan, partition.column_ids);
+		inputs.InitializeScanChunk(scan, page);
+
+		D_ASSERT(partition.all_valid.size() == 1);
+		all_valid = partition.all_valid[0];
+	}
+
+	inline sel_t RowOffset(idx_t row_idx) const {
+		D_ASSERT(RowIsVisible(row_idx));
+		return UnsafeNumericCast<sel_t>(row_idx - scan.current_row_index);
+	}
+
+	inline bool RowIsVisible(idx_t row_idx) const {
+		return (row_idx < scan.next_row_index && scan.current_row_index <= row_idx);
+	}
+
+	inline idx_t Seek(idx_t row_idx) {
+		if (!RowIsVisible(row_idx)) {
+			inputs.Seek(row_idx, scan, page);
+			data = FlatVector::GetData<INPUT_TYPE>(page.data[0]);
+			validity = &FlatVector::Validity(page.data[0]);
+		}
+		return RowOffset(row_idx);
+	}
+
+	inline const INPUT_TYPE &operator[](idx_t row_idx) {
+		const auto offset = Seek(row_idx);
+		return data[offset];
+	}
+
+	inline bool RowIsValid(idx_t row_idx) {
+		const auto offset = Seek(row_idx);
+		return validity->RowIsValid(offset);
+	}
+
+	inline bool AllValid() {
+		return all_valid;
+	}
+
+	//! Windowed paging
+	const ColumnDataCollection &inputs;
+	//! The state used for reading the collection on this thread
+	ColumnDataScanState scan;
+	//! The data chunk paged into into
+	DataChunk page;
+	//! The data pointer
+	const INPUT_TYPE *data = nullptr;
+	//! The validity mask
+	const ValidityMask *validity = nullptr;
+	//! Paged chunks do not track this but it is really necessary for performance
+	bool all_valid;
+};
+
 // Direct access
 template <typename T>
 struct QuantileDirect {
@@ -35,12 +98,13 @@ template <typename T>
 struct QuantileIndirect {
 	using INPUT_TYPE = idx_t;
 	using RESULT_TYPE = T;
-	const RESULT_TYPE *data;
+	using CURSOR = QuantileCursor<RESULT_TYPE>;
+	CURSOR &data;
 
-	explicit QuantileIndirect(const RESULT_TYPE *data_p) : data(data_p) {
+	explicit QuantileIndirect(CURSOR &data_p) : data(data_p) {
 	}
 
-	inline RESULT_TYPE operator()(const idx_t &input) const {
+	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
 		return data[input];
 	}
 };
@@ -66,14 +130,23 @@ struct QuantileComposed {
 template <typename ACCESSOR>
 struct QuantileCompare {
 	using INPUT_TYPE = typename ACCESSOR::INPUT_TYPE;
-	const ACCESSOR &accessor;
+	const ACCESSOR &accessor_l;
+	const ACCESSOR &accessor_r;
 	const bool desc;
-	explicit QuantileCompare(const ACCESSOR &accessor_p, bool desc_p) : accessor(accessor_p), desc(desc_p) {
+
+	// Single cursor for linear operations
+	explicit QuantileCompare(const ACCESSOR &accessor, bool desc_p)
+	    : accessor_l(accessor), accessor_r(accessor), desc(desc_p) {
+	}
+
+	// Independent cursors for sorting
+	explicit QuantileCompare(const ACCESSOR &accessor_l, const ACCESSOR &accessor_r, bool desc_p)
+	    : accessor_l(accessor_l), accessor_r(accessor_r), desc(desc_p) {
 	}
 
 	inline bool operator()(const INPUT_TYPE &lhs, const INPUT_TYPE &rhs) const {
-		const auto lval = accessor(lhs);
-		const auto rval = accessor(rhs);
+		const auto lval = accessor_l(lhs);
+		const auto rval = accessor_r(rhs);
 
 		return desc ? (rval < lval) : (lval < rval);
 	}
@@ -143,12 +216,12 @@ struct Interpolator {
 	}
 
 	template <class INPUT_TYPE, class TARGET_TYPE>
-	inline TARGET_TYPE Extract(const INPUT_TYPE **dest, Vector &result) const {
+	inline TARGET_TYPE Extract(const INPUT_TYPE *dest, Vector &result) const {
 		if (CRN == FRN) {
-			return CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(*dest[0], result);
+			return CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
 		} else {
-			auto lo = CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(*dest[0], result);
-			auto hi = CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(*dest[1], result);
+			auto lo = CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
+			auto hi = CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(dest[1], result);
 			return CastInterpolation::Interpolate<TARGET_TYPE>(lo, RN - FRN, hi);
 		}
 	}
@@ -212,8 +285,8 @@ struct Interpolator<true> {
 	}
 
 	template <class INPUT_TYPE, class TARGET_TYPE>
-	TARGET_TYPE Extract(const INPUT_TYPE **dest, Vector &result) const {
-		return CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(*dest[0], result);
+	TARGET_TYPE Extract(const INPUT_TYPE *dest, Vector &result) const {
+		return CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
 	}
 
 	const bool desc;
@@ -224,75 +297,84 @@ struct Interpolator<true> {
 	idx_t end;
 };
 
+template <typename INPUT_TYPE>
 struct QuantileIncluded {
-	inline explicit QuantileIncluded(const ValidityMask &fmask_p, const ValidityMask &dmask_p)
+	using CURSOR_TYPE = QuantileCursor<INPUT_TYPE>;
+
+	inline explicit QuantileIncluded(const ValidityMask &fmask_p, CURSOR_TYPE &dmask_p)
 	    : fmask(fmask_p), dmask(dmask_p) {
 	}
 
-	inline bool operator()(const idx_t &idx) const {
+	inline bool operator()(const idx_t &idx) {
 		return fmask.RowIsValid(idx) && dmask.RowIsValid(idx);
 	}
 
-	inline bool AllValid() const {
+	inline bool AllValid() {
 		return fmask.AllValid() && dmask.AllValid();
 	}
 
 	const ValidityMask &fmask;
-	const ValidityMask &dmask;
+	CURSOR_TYPE &dmask;
 };
 
-template <typename IDX>
-struct QuantileSortTree : public MergeSortTree<IDX, IDX> {
+struct QuantileSortTree {
 
-	using BaseTree = MergeSortTree<IDX, IDX>;
-	using Elements = typename BaseTree::Elements;
+	unique_ptr<WindowIndexTree> index_tree;
 
-	explicit QuantileSortTree(Elements &&lowest_level) {
-		BaseTree::Allocate(lowest_level.size());
-		BaseTree::LowestLevel() = std::move(lowest_level);
-	}
+	QuantileSortTree(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition) {
+		// TODO: Two pass parallel sorting using Build
+		auto &inputs = *partition.inputs;
+		ColumnDataScanState scan;
+		DataChunk sort;
+		inputs.InitializeScan(scan, partition.column_ids);
+		inputs.InitializeScanChunk(scan, sort);
 
-	template <class INPUT_TYPE>
-	static unique_ptr<QuantileSortTree> WindowInit(const INPUT_TYPE *data, AggregateInputData &aggr_input_data,
-	                                               const ValidityMask &data_mask, const ValidityMask &filter_mask,
-	                                               idx_t count) {
-		//	Build the indirection array
-		using ElementType = typename QuantileSortTree::ElementType;
-		vector<ElementType> sorted(count);
-		if (filter_mask.AllValid() && data_mask.AllValid()) {
-			std::iota(sorted.begin(), sorted.end(), 0);
-		} else {
-			size_t valid = 0;
-			QuantileIncluded included(filter_mask, data_mask);
-			for (ElementType i = 0; i < count; ++i) {
-				if (included(i)) {
-					sorted[valid++] = i;
+		// Sort on the single argument
+		auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
+		auto order_expr = make_uniq<BoundConstantExpression>(Value(sort.GetTypes()[0]));
+		auto order_type = bind_data.desc ? OrderType::DESCENDING : OrderType::ASCENDING;
+		BoundOrderModifier order_bys;
+		order_bys.orders.emplace_back(BoundOrderByNode(order_type, OrderByNullType::NULLS_LAST, std::move(order_expr)));
+		vector<column_t> sort_idx(1, 0);
+		const auto count = partition.count;
+
+		index_tree = make_uniq<WindowIndexTree>(partition.context, order_bys, sort_idx, count);
+		auto index_state = index_tree->GetLocalState();
+		auto &local_state = index_state->Cast<WindowIndexTreeLocalState>();
+
+		//	Build the indirection array by scanning the valid indices
+		const auto &filter_mask = partition.filter_mask;
+		SelectionVector filter_sel(STANDARD_VECTOR_SIZE);
+		while (inputs.Scan(scan, sort)) {
+			const auto row_idx = scan.current_row_index;
+			if (!filter_mask.AllValid() || !partition.all_valid[0]) {
+				auto &key = sort.data[0];
+				auto &validity = FlatVector::Validity(key);
+				idx_t filtered = 0;
+				for (sel_t i = 0; i < sort.size(); ++i) {
+					if (filter_mask.RowIsValid(i + row_idx) && validity.RowIsValid(i)) {
+						filter_sel[filtered++] = i;
+					}
 				}
+				local_state.SinkChunk(sort, row_idx, filter_sel, filtered);
+			} else {
+				local_state.SinkChunk(sort, row_idx, nullptr, 0);
 			}
-			sorted.resize(valid);
 		}
-
-		//	Sort it
-		auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
-		using Accessor = QuantileIndirect<INPUT_TYPE>;
-		Accessor indirect(data);
-		QuantileCompare<Accessor> cmp(indirect, bind_data.desc);
-		std::sort(sorted.begin(), sorted.end(), cmp);
-
-		return make_uniq<QuantileSortTree>(std::move(sorted));
+		local_state.Sort();
 	}
 
-	inline IDX SelectNth(const SubFrames &frames, size_t n) const {
-		return BaseTree::NthElement(BaseTree::SelectNth(frames, n));
+	inline idx_t SelectNth(const SubFrames &frames, size_t n) const {
+		return index_tree->SelectNth(frames, n);
 	}
 
 	template <typename INPUT_TYPE, typename RESULT_TYPE, bool DISCRETE>
-	RESULT_TYPE WindowScalar(const INPUT_TYPE *data, const SubFrames &frames, const idx_t n, Vector &result,
+	RESULT_TYPE WindowScalar(QuantileCursor<INPUT_TYPE> &data, const SubFrames &frames, const idx_t n, Vector &result,
 	                         const QuantileValue &q) {
 		D_ASSERT(n > 0);
 
 		//	Thread safe and idempotent.
-		BaseTree::Build();
+		index_tree->Build();
 
 		//	Find the interpolated indicies within the frame
 		Interpolator<DISCRETE> interp(q, n, false);
@@ -309,12 +391,12 @@ struct QuantileSortTree : public MergeSortTree<IDX, IDX> {
 	}
 
 	template <typename INPUT_TYPE, typename CHILD_TYPE, bool DISCRETE>
-	void WindowList(const INPUT_TYPE *data, const SubFrames &frames, const idx_t n, Vector &list, const idx_t lidx,
-	                const QuantileBindData &bind_data) {
+	void WindowList(QuantileCursor<INPUT_TYPE> &data, const SubFrames &frames, const idx_t n, Vector &list,
+	                const idx_t lidx, const QuantileBindData &bind_data) {
 		D_ASSERT(n > 0);
 
 		//	Thread safe and idempotent.
-		BaseTree::Build();
+		index_tree->Build();
 
 		// Result is a constant LIST<CHILD_TYPE> with a fixed length
 		auto ldata = FlatVector::GetData<list_entry_t>(list);

package/src/duckdb/{src/include/duckdb → extension/core_functions/include}/core_functions/aggregate/quantile_state.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/core_functions/aggregate/quantile_sort_tree.hpp"
+#include "core_functions/aggregate/quantile_sort_tree.hpp"
 #include "SkipList.h"
 
 namespace duckdb {
@@ -52,11 +52,8 @@ struct QuantileOperation {
 	template <class STATE, class INPUT_TYPE>
 	static void WindowInit(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition,
 	                       data_ptr_t g_state) {
-		D_ASSERT(partition.input_count == 1);
+		D_ASSERT(partition.inputs);
 
-		auto inputs = partition.inputs;
-		const auto count = partition.count;
-		const auto &filter_mask = partition.filter_mask;
 		const auto &stats = partition.stats;
 
 		//	If frames overlap significantly, then use local skip lists.
@@ -70,22 +67,14 @@ struct QuantileOperation {
 			}
 		}
 
-		const auto data = FlatVector::GetData<const INPUT_TYPE>(inputs[0]);
-		const auto &data_mask = FlatVector::Validity(inputs[0]);
-
 		//	Build the tree
 		auto &state = *reinterpret_cast<STATE *>(g_state);
 		auto &window_state = state.GetOrCreateWindowState();
-		if (count < std::numeric_limits<uint32_t>::max()) {
-			window_state.qst32 = QuantileSortTree<uint32_t>::WindowInit<INPUT_TYPE>(data, aggr_input_data, data_mask,
-			                                                                        filter_mask, count);
-		} else {
-			window_state.qst64 = QuantileSortTree<uint64_t>::WindowInit<INPUT_TYPE>(data, aggr_input_data, data_mask,
-			                                                                        filter_mask, count);
-		}
+		window_state.qst = make_uniq<QuantileSortTree>(aggr_input_data, partition);
 	}
 
-	static idx_t FrameSize(const QuantileIncluded &included, const SubFrames &frames) {
+	template <class INPUT_TYPE>
+	static idx_t FrameSize(QuantileIncluded<INPUT_TYPE> &included, const SubFrames &frames) {
 		//	Count the number of valid values
 		idx_t n = 0;
 		if (included.AllValid()) {
@@ -106,31 +95,31 @@ struct QuantileOperation {
 };
 
 template <class T>
-struct PointerLess {
+struct SkipLess {
 	inline bool operator()(const T &lhi, const T &rhi) const {
-		return *lhi < *rhi;
+		return lhi.second < rhi.second;
 	}
 };
 
 template <typename INPUT_TYPE>
 struct WindowQuantileState {
 	// Windowed Quantile merge sort trees
-	using QuantileSortTree32 = QuantileSortTree<uint32_t>;
-	using QuantileSortTree64 = QuantileSortTree<uint64_t>;
-	unique_ptr<QuantileSortTree32> qst32;
-	unique_ptr<QuantileSortTree64> qst64;
+	unique_ptr<QuantileSortTree> qst;
 
 	// Windowed Quantile skip lists
-	using PointerType = const INPUT_TYPE *;
-	using SkipListType = duckdb_skiplistlib::skip_list::HeadNode<PointerType, PointerLess<PointerType>>;
+	using SkipType = pair<idx_t, INPUT_TYPE>;
+	using SkipListType = duckdb_skiplistlib::skip_list::HeadNode<SkipType, SkipLess<SkipType>>;
 	SubFrames prevs;
 	unique_ptr<SkipListType> s;
-	mutable vector<PointerType> dest;
+	mutable vector<SkipType> skips;
 
 	// Windowed MAD indirection
 	idx_t count;
 	vector<idx_t> m;
 
+	using IncludedType = QuantileIncluded<INPUT_TYPE>;
+	using CursorType = QuantileCursor<INPUT_TYPE>;
+
 	WindowQuantileState() : count(0) {
 	}
 
@@ -151,10 +140,10 @@ struct WindowQuantileState {
 
 	struct SkipListUpdater {
 		SkipListType &skip;
-		const INPUT_TYPE *data;
-		const QuantileIncluded &included;
+		CursorType &data;
+		IncludedType &included;
 
-		inline SkipListUpdater(SkipListType &skip, const INPUT_TYPE *data, const QuantileIncluded &included)
+		inline SkipListUpdater(SkipListType &skip, CursorType &data, IncludedType &included)
 		    : skip(skip), data(data), included(included) {
 		}
 
@@ -164,7 +153,7 @@ struct WindowQuantileState {
 		inline void Left(idx_t begin, idx_t end) {
 			for (; begin < end; ++begin) {
 				if (included(begin)) {
-					skip.remove(data + begin);
+					skip.remove(SkipType(begin, data[begin]));
 				}
 			}
 		}
@@ -172,7 +161,7 @@ struct WindowQuantileState {
 		inline void Right(idx_t begin, idx_t end) {
 			for (; begin < end; ++begin) {
 				if (included(begin)) {
-					skip.insert(data + begin);
+					skip.insert(SkipType(begin, data[begin]));
 				}
 			}
 		}
@@ -181,14 +170,14 @@ struct WindowQuantileState {
 		}
 	};
 
-	void UpdateSkip(const INPUT_TYPE *data, const SubFrames &frames, const QuantileIncluded &included) {
+	void UpdateSkip(CursorType &data, const SubFrames &frames, IncludedType &included) {
 		//	No overlap, or no data
 		if (!s || prevs.back().end <= frames.front().start || frames.back().end <= prevs.front().start) {
 			auto &skip = GetSkipList(true);
 			for (const auto &frame : frames) {
 				for (auto i = frame.start; i < frame.end; ++i) {
 					if (included(i)) {
-						skip.insert(data + i);
+						skip.insert(SkipType(i, data[i]));
 					}
 				}
 			}
@@ -199,23 +188,26 @@ struct WindowQuantileState {
 		}
 	}
 
-	bool HasTrees() const {
-		return qst32 || qst64;
+	bool HasTree() const {
+		return qst.get();
 	}
 
 	template <typename RESULT_TYPE, bool DISCRETE>
-	RESULT_TYPE WindowScalar(const INPUT_TYPE *data, const SubFrames &frames, const idx_t n, Vector &result,
+	RESULT_TYPE WindowScalar(CursorType &data, const SubFrames &frames, const idx_t n, Vector &result,
 	                         const QuantileValue &q) const {
 		D_ASSERT(n > 0);
-		if (qst32) {
-			return qst32->WindowScalar<INPUT_TYPE, RESULT_TYPE, DISCRETE>(data, frames, n, result, q);
-		} else if (qst64) {
-			return qst64->WindowScalar<INPUT_TYPE, RESULT_TYPE, DISCRETE>(data, frames, n, result, q);
+		if (qst) {
+			return qst->WindowScalar<INPUT_TYPE, RESULT_TYPE, DISCRETE>(data, frames, n, result, q);
 		} else if (s) {
 			// Find the position(s) needed
 			try {
 				Interpolator<DISCRETE> interp(q, s->size(), false);
-				s->at(interp.FRN, interp.CRN - interp.FRN + 1, dest);
+				s->at(interp.FRN, interp.CRN - interp.FRN + 1, skips);
+				array<INPUT_TYPE, 2> dest;
+				dest[0] = skips[0].second;
+				if (skips.size() > 1) {
+					dest[1] = skips[1].second;
+				}
 				return interp.template Extract<INPUT_TYPE, RESULT_TYPE>(dest.data(), result);
 			} catch (const duckdb_skiplistlib::skip_list::IndexError &idx_err) {
 				throw InternalException(idx_err.message());
@@ -226,7 +218,7 @@ struct WindowQuantileState {
 	}
 
 	template <typename CHILD_TYPE, bool DISCRETE>
-	void WindowList(const INPUT_TYPE *data, const SubFrames &frames, const idx_t n, Vector &list, const idx_t lidx,
+	void WindowList(CursorType &data, const SubFrames &frames, const idx_t n, Vector &list, const idx_t lidx,
 	                const QuantileBindData &bind_data) const {
 		D_ASSERT(n > 0);
 		// Result is a constant LIST<CHILD_TYPE> with a fixed length
@@ -269,19 +261,21 @@ struct QuantileStringType {
 template <typename INPUT_TYPE, class TYPE_OP>
 struct QuantileState {
 	using InputType = INPUT_TYPE;
+	using CursorType = QuantileCursor<INPUT_TYPE>;
 
 	// Regular aggregation
 	vector<INPUT_TYPE> v;
 
 	// Window Quantile State
 	unique_ptr<WindowQuantileState<INPUT_TYPE>> window_state;
+	unique_ptr<CursorType> window_cursor;
 
 	void AddElement(INPUT_TYPE element, AggregateInputData &aggr_input) {
 		v.emplace_back(TYPE_OP::Operation(element, aggr_input));
 	}
 
-	bool HasTrees() const {
-		return window_state && window_state->HasTrees();
+	bool HasTree() const {
+		return window_state && window_state->HasTree();
 	}
 	WindowQuantileState<INPUT_TYPE> &GetOrCreateWindowState() {
 		if (!window_state) {
@@ -295,6 +289,19 @@ struct QuantileState {
 	const WindowQuantileState<INPUT_TYPE> &GetWindowState() const {
 		return *window_state;
 	}
+
+	CursorType &GetOrCreateWindowCursor(const WindowPartitionInput &partition) {
+		if (!window_cursor) {
+			window_cursor = make_uniq<CursorType>(partition);
+		}
+		return *window_cursor;
+	}
+	CursorType &GetWindowCursor() {
+		return *window_cursor;
+	}
+	const CursorType &GetWindowCursor() const {
+		return *window_cursor;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/{src/include/duckdb → extension/core_functions/include}/core_functions/aggregate/regression/regr_count.hpp

@@ -10,8 +10,8 @@
 #pragma once
 
 #include "duckdb/function/aggregate_function.hpp"
-#include "duckdb/core_functions/aggregate/algebraic/covar.hpp"
-#include "duckdb/core_functions/aggregate/algebraic/stddev.hpp"
+#include "core_functions/aggregate/algebraic/covar.hpp"
+#include "core_functions/aggregate/algebraic/stddev.hpp"
 
 namespace duckdb {
 

package/src/duckdb/{src/include/duckdb → extension/core_functions/include}/core_functions/aggregate/regression/regr_slope.hpp

@@ -7,8 +7,8 @@
 //! Output : Double
 
 #pragma once
-#include "duckdb/core_functions/aggregate/algebraic/stddev.hpp"
-#include "duckdb/core_functions/aggregate/algebraic/covar.hpp"
+#include "core_functions/aggregate/algebraic/stddev.hpp"
+#include "core_functions/aggregate/algebraic/covar.hpp"
 
 namespace duckdb {
 
@@ -46,11 +46,7 @@ struct RegrSlopeOperation {
 			if (!Value::DoubleIsFinite(var_pop)) {
 				throw OutOfRangeException("VARPOP is out of range!");
 			}
-			if (var_pop == 0) {
-				finalize_data.ReturnNull();
-				return;
-			}
-			target = cov / var_pop;
+			target = var_pop != 0 ? cov / var_pop : NAN;
 		}
 	}
 

package/src/duckdb/{src/include/duckdb → extension/core_functions/include}/core_functions/aggregate/regression_functions.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/core_functions/aggregate/regression_functions.hpp
+// core_functions/aggregate/regression_functions.hpp
 //
 //
 //===----------------------------------------------------------------------===//

package/src/duckdb/{src/include/duckdb → extension/core_functions/include}/core_functions/scalar/array_functions.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/core_functions/scalar/array_functions.hpp
+// core_functions/scalar/array_functions.hpp
 //
 //
 //===----------------------------------------------------------------------===//

package/src/duckdb/{src/include/duckdb → extension/core_functions/include}/core_functions/scalar/bit_functions.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/core_functions/scalar/bit_functions.hpp
+// core_functions/scalar/bit_functions.hpp
 //
 //
 //===----------------------------------------------------------------------===//

package/src/duckdb/{src/include/duckdb → extension/core_functions/include}/core_functions/scalar/blob_functions.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/core_functions/scalar/blob_functions.hpp
+// core_functions/scalar/blob_functions.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -57,13 +57,4 @@ struct Base64Fun {
 	static constexpr const char *Name = "base64";
 };
 
-struct CreateSortKeyFun {
-	static constexpr const char *Name = "create_sort_key";
-	static constexpr const char *Parameters = "parameters...";
-	static constexpr const char *Description = "Constructs a binary-comparable sort key based on a set of input parameters and sort qualifiers";
-	static constexpr const char *Example = "create_sort_key('A', 'DESC')";
-
-	static ScalarFunction GetFunction();
-};
-
 } // namespace duckdb