duckdb 1.3.3-dev0.0 → 1.3.3-dev4.0

package/src/duckdb/extension/core_functions/include/core_functions/aggregate/distributive_functions.hpp

@@ -29,7 +29,7 @@ struct ArgMinFun {
 	static constexpr const char *Name = "arg_min";
 	static constexpr const char *Parameters = "arg,val";
 	static constexpr const char *Description = "Finds the row with the minimum val. Calculates the non-NULL arg expression at that row.";
-	static constexpr const char *Example = "arg_min(A,B)";
+	static constexpr const char *Example = "arg_min(A, B)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunctionSet GetFunctions();
@@ -51,7 +51,7 @@ struct ArgMinNullFun {
 	static constexpr const char *Name = "arg_min_null";
 	static constexpr const char *Parameters = "arg,val";
 	static constexpr const char *Description = "Finds the row with the minimum val. Calculates the arg expression at that row.";
-	static constexpr const char *Example = "arg_min_null(A,B)";
+	static constexpr const char *Example = "arg_min_null(A, B)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunctionSet GetFunctions();
@@ -61,7 +61,7 @@ struct ArgMaxFun {
 	static constexpr const char *Name = "arg_max";
 	static constexpr const char *Parameters = "arg,val";
 	static constexpr const char *Description = "Finds the row with the maximum val. Calculates the non-NULL arg expression at that row.";
-	static constexpr const char *Example = "arg_max(A,B)";
+	static constexpr const char *Example = "arg_max(A, B)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunctionSet GetFunctions();
@@ -83,7 +83,7 @@ struct ArgMaxNullFun {
 	static constexpr const char *Name = "arg_max_null";
 	static constexpr const char *Parameters = "arg,val";
 	static constexpr const char *Description = "Finds the row with the maximum val. Calculates the arg expression at that row.";
-	static constexpr const char *Example = "arg_max_null(A,B)";
+	static constexpr const char *Example = "arg_max_null(A, B)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunctionSet GetFunctions();

package/src/duckdb/extension/core_functions/include/core_functions/aggregate/holistic_functions.hpp

@@ -85,7 +85,7 @@ struct ReservoirQuantileFun {
 	static constexpr const char *Name = "reservoir_quantile";
 	static constexpr const char *Parameters = "x,quantile,sample_size";
 	static constexpr const char *Description = "Gives the approximate quantile using reservoir sampling, the sample size is optional and uses 8192 as a default size.";
-	static constexpr const char *Example = "reservoir_quantile(A,0.5,1024)";
+	static constexpr const char *Example = "reservoir_quantile(A, 0.5, 1024)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunctionSet GetFunctions();

package/src/duckdb/extension/core_functions/include/core_functions/aggregate/quantile_sort_tree.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "core_functions/aggregate/quantile_helpers.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/operator/interpolate.hpp"
 #include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/function/window/window_index_tree.hpp"
@@ -148,37 +149,22 @@ struct QuantileCompare {
 	}
 };
 
-struct CastInterpolation {
+struct QuantileCast {
 	template <class INPUT_TYPE, class TARGET_TYPE>
-	static inline TARGET_TYPE Cast(const INPUT_TYPE &src, Vector &result) {
+	static inline TARGET_TYPE Operation(const INPUT_TYPE &src, Vector &result) {
 		return Cast::Operation<INPUT_TYPE, TARGET_TYPE>(src);
 	}
-	template <typename TARGET_TYPE>
-	static inline TARGET_TYPE Interpolate(const TARGET_TYPE &lo, const double d, const TARGET_TYPE &hi) {
-		const auto delta = hi - lo;
-		return LossyNumericCast<TARGET_TYPE>(lo + delta * d);
-	}
 };
 
 template <>
-interval_t CastInterpolation::Cast(const dtime_t &src, Vector &result);
-template <>
-double CastInterpolation::Interpolate(const double &lo, const double d, const double &hi);
-template <>
-dtime_t CastInterpolation::Interpolate(const dtime_t &lo, const double d, const dtime_t &hi);
-template <>
-timestamp_t CastInterpolation::Interpolate(const timestamp_t &lo, const double d, const timestamp_t &hi);
-template <>
-hugeint_t CastInterpolation::Interpolate(const hugeint_t &lo, const double d, const hugeint_t &hi);
-template <>
-interval_t CastInterpolation::Interpolate(const interval_t &lo, const double d, const interval_t &hi);
+interval_t QuantileCast::Operation(const dtime_t &src, Vector &result);
 template <>
-string_t CastInterpolation::Cast(const string_t &src, Vector &result);
+string_t QuantileCast::Operation(const string_t &src, Vector &result);
 
 // Continuous interpolation
 template <bool DISCRETE>
-struct Interpolator {
-	Interpolator(const QuantileValue &q, const idx_t n_p, const bool desc_p)
+struct QuantileInterpolator {
+	QuantileInterpolator(const QuantileValue &q, const idx_t n_p, const bool desc_p)
 	    : desc(desc_p), RN((double)(n_p - 1) * q.dbl), FRN(ExactNumericCast<idx_t>(floor(RN))),
 	      CRN(ExactNumericCast<idx_t>(ceil(RN))), begin(0), end(n_p) {
 	}
@@ -187,11 +173,11 @@ struct Interpolator {
 	TARGET_TYPE Interpolate(INPUT_TYPE lidx, INPUT_TYPE hidx, Vector &result, const ACCESSOR &accessor) const {
 		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
 		if (lidx == hidx) {
-			return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
+			return QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
 		} else {
-			auto lo = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
-			auto hi = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(hidx), result);
-			return CastInterpolation::Interpolate<TARGET_TYPE>(lo, RN - FRN, hi);
+			auto lo = QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
+			auto hi = QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(hidx), result);
+			return InterpolateOperator::Operation<TARGET_TYPE>(lo, RN - FRN, hi);
 		}
 	}
 
@@ -201,24 +187,24 @@ struct Interpolator {
 		QuantileCompare<ACCESSOR> comp(accessor, desc);
 		if (CRN == FRN) {
 			std::nth_element(v_t + begin, v_t + FRN, v_t + end, comp);
-			return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
+			return QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
 		} else {
 			std::nth_element(v_t + begin, v_t + FRN, v_t + end, comp);
 			std::nth_element(v_t + FRN, v_t + CRN, v_t + end, comp);
-			auto lo = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
-			auto hi = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[CRN]), result);
-			return CastInterpolation::Interpolate<TARGET_TYPE>(lo, RN - FRN, hi);
+			auto lo = QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
+			auto hi = QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[CRN]), result);
+			return InterpolateOperator::Operation<TARGET_TYPE>(lo, RN - FRN, hi);
 		}
 	}
 
 	template <class INPUT_TYPE, class TARGET_TYPE>
 	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 QuantileCast::Operation<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);
-			return CastInterpolation::Interpolate<TARGET_TYPE>(lo, RN - FRN, hi);
+			auto lo = QuantileCast::Operation<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
+			auto hi = QuantileCast::Operation<INPUT_TYPE, TARGET_TYPE>(dest[1], result);
+			return InterpolateOperator::Operation<TARGET_TYPE>(lo, RN - FRN, hi);
 		}
 	}
 
@@ -233,7 +219,7 @@ struct Interpolator {
 
 // Discrete "interpolation"
 template <>
-struct Interpolator<true> {
+struct QuantileInterpolator<true> {
 	static inline idx_t Index(const QuantileValue &q, const idx_t n) {
 		idx_t floored;
 		switch (q.val.type().id()) {
@@ -257,14 +243,14 @@ struct Interpolator<true> {
 		return MaxValue<idx_t>(1, n - floored) - 1;
 	}
 
-	Interpolator(const QuantileValue &q, const idx_t n_p, bool desc_p)
+	QuantileInterpolator(const QuantileValue &q, const idx_t n_p, bool desc_p)
 	    : desc(desc_p), FRN(Index(q, n_p)), CRN(FRN), begin(0), end(n_p) {
 	}
 
 	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
 	TARGET_TYPE Interpolate(INPUT_TYPE lidx, INPUT_TYPE hidx, Vector &result, const ACCESSOR &accessor) const {
 		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
-		return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
+		return QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(accessor(lidx), result);
 	}
 
 	template <class INPUT_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
@@ -277,12 +263,12 @@ struct Interpolator<true> {
 	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
 	TARGET_TYPE Operation(INPUT_TYPE *v_t, Vector &result, const ACCESSOR &accessor = ACCESSOR()) const {
 		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
-		return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(InterpolateInternal(v_t, accessor), result);
+		return QuantileCast::Operation<ACCESS_TYPE, TARGET_TYPE>(InterpolateInternal(v_t, accessor), result);
 	}
 
 	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);
+		return QuantileCast::Operation<INPUT_TYPE, TARGET_TYPE>(dest[0], result);
 	}
 
 	const bool desc;
@@ -320,6 +306,7 @@ struct QuantileSortTree {
 	QuantileSortTree(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition) {
 		// TODO: Two pass parallel sorting using Build
 		auto &inputs = *partition.inputs;
+		auto &interrupt = partition.interrupt_state;
 		ColumnDataScanState scan;
 		DataChunk sort;
 		inputs.InitializeScan(scan, partition.column_ids);
@@ -334,8 +321,8 @@ struct QuantileSortTree {
 		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();
+		index_tree = make_uniq<WindowIndexTree>(partition.context.client, order_bys, sort_idx, count);
+		auto index_state = index_tree->GetLocalState(partition.context);
 		auto &local_state = index_state->Cast<WindowIndexTreeLocalState>();
 
 		//	Build the indirection array by scanning the valid indices
@@ -352,12 +339,12 @@ struct QuantileSortTree {
 						filter_sel[filtered++] = i;
 					}
 				}
-				local_state.SinkChunk(sort, row_idx, filter_sel, filtered);
+				local_state.Sink(partition.context, sort, row_idx, filter_sel, filtered, interrupt);
 			} else {
-				local_state.SinkChunk(sort, row_idx, nullptr, 0);
+				local_state.Sink(partition.context, sort, row_idx, nullptr, 0, interrupt);
 			}
 		}
-		local_state.Sort();
+		local_state.Finalize(partition.context, interrupt);
 	}
 
 	inline idx_t SelectNth(const SubFrames &frames, size_t n) const {
@@ -373,7 +360,7 @@ struct QuantileSortTree {
 		index_tree->Build();
 
 		//	Find the interpolated indicies within the frame
-		Interpolator<DISCRETE> interp(q, n, false);
+		QuantileInterpolator<DISCRETE> interp(q, n, false);
 		const auto lo_data = SelectNth(frames, interp.FRN);
 		auto hi_data = lo_data;
 		if (interp.CRN != interp.FRN) {
@@ -409,7 +396,7 @@ struct QuantileSortTree {
 		ID indirect(data);
 		for (const auto &q : bind_data.order) {
 			const auto &quantile = bind_data.quantiles[q];
-			Interpolator<DISCRETE> interp(quantile, n, false);
+			QuantileInterpolator<DISCRETE> interp(quantile, n, false);
 
 			const auto lo_data = SelectNth(frames, interp.FRN);
 			auto hi_data = lo_data;

package/src/duckdb/extension/core_functions/include/core_functions/aggregate/quantile_state.hpp

@@ -201,7 +201,7 @@ struct WindowQuantileState {
 		} else if (s) {
 			// Find the position(s) needed
 			try {
-				Interpolator<DISCRETE> interp(q, s->size(), false);
+				QuantileInterpolator<DISCRETE> interp(q, s->size(), false);
 				s->at(interp.FRN, interp.CRN - interp.FRN + 1, skips);
 				array<INPUT_TYPE, 2> dest;
 				dest[0] = skips[0].second;

package/src/duckdb/extension/core_functions/include/core_functions/aggregate/regression_functions.hpp

@@ -18,7 +18,7 @@ namespace duckdb {
 struct RegrAvgxFun {
 	static constexpr const char *Name = "regr_avgx";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the average of the independent variable for non-null pairs in a group, where x is the independent variable and y is the dependent variable.";
+	static constexpr const char *Description = "Returns the average of the independent variable for non-NULL pairs in a group, where x is the independent variable and y is the dependent variable.";
 	static constexpr const char *Example = "";
 	static constexpr const char *Categories = "";
 
@@ -28,7 +28,7 @@ struct RegrAvgxFun {
 struct RegrAvgyFun {
 	static constexpr const char *Name = "regr_avgy";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the average of the dependent variable for non-null pairs in a group, where x is the independent variable and y is the dependent variable.";
+	static constexpr const char *Description = "Returns the average of the dependent variable for non-NULL pairs in a group, where x is the independent variable and y is the dependent variable.";
 	static constexpr const char *Example = "";
 	static constexpr const char *Categories = "";
 
@@ -38,7 +38,7 @@ struct RegrAvgyFun {
 struct RegrCountFun {
 	static constexpr const char *Name = "regr_count";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the number of non-null number pairs in a group.";
+	static constexpr const char *Description = "Returns the number of non-NULL number pairs in a group.";
 	static constexpr const char *Example = "(SUM(x*y) - SUM(x) * SUM(y) / COUNT(*)) / COUNT(*)";
 	static constexpr const char *Categories = "";
 
@@ -48,8 +48,8 @@ struct RegrCountFun {
 struct RegrInterceptFun {
 	static constexpr const char *Name = "regr_intercept";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the intercept of the univariate linear regression line for non-null pairs in a group.";
-	static constexpr const char *Example = "AVG(y)-REGR_SLOPE(y,x)*AVG(x)";
+	static constexpr const char *Description = "Returns the intercept of the univariate linear regression line for non-NULL pairs in a group.";
+	static constexpr const char *Example = "AVG(y)-REGR_SLOPE(y, x)*AVG(x)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunction GetFunction();
@@ -58,7 +58,7 @@ struct RegrInterceptFun {
 struct RegrR2Fun {
 	static constexpr const char *Name = "regr_r2";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the coefficient of determination for non-null pairs in a group.";
+	static constexpr const char *Description = "Returns the coefficient of determination for non-NULL pairs in a group.";
 	static constexpr const char *Example = "";
 	static constexpr const char *Categories = "";
 
@@ -68,8 +68,8 @@ struct RegrR2Fun {
 struct RegrSlopeFun {
 	static constexpr const char *Name = "regr_slope";
 	static constexpr const char *Parameters = "y,x";
-	static constexpr const char *Description = "Returns the slope of the linear regression line for non-null pairs in a group.";
-	static constexpr const char *Example = "COVAR_POP(x,y) / VAR_POP(x)";
+	static constexpr const char *Description = "Returns the slope of the linear regression line for non-NULL pairs in a group.";
+	static constexpr const char *Example = "COVAR_POP(x, y) / VAR_POP(x)";
 	static constexpr const char *Categories = "";
 
 	static AggregateFunction GetFunction();

package/src/duckdb/extension/core_functions/include/core_functions/aggregate/sum_helpers.hpp

@@ -30,6 +30,7 @@ struct SumState {
 
 	void Initialize() {
 		this->isset = false;
+		this->value = 0;
 	}
 
 	void Combine(const SumState<T> &other) {
@@ -182,7 +183,6 @@ struct BaseSumOperation {
 		STATEOP::template AddValues<STATE>(state, count);
 		ADDOP::template AddConstant<STATE, INPUT_TYPE>(state, input, count);
 	}
-
 	static bool IgnoreNull() {
 		return true;
 	}

package/src/duckdb/extension/core_functions/include/core_functions/scalar/array_functions.hpp

@@ -18,19 +18,19 @@ namespace duckdb {
 struct ArrayValueFun {
 	static constexpr const char *Name = "array_value";
 	static constexpr const char *Parameters = "any,...";
-	static constexpr const char *Description = "Create an ARRAY containing the argument values.";
-	static constexpr const char *Example = "array_value(4, 5, 6)";
-	static constexpr const char *Categories = "";
+	static constexpr const char *Description = "Creates an `ARRAY` containing the argument values.";
+	static constexpr const char *Example = "array_value(1.0::FLOAT, 2.0::FLOAT, 3.0::FLOAT)";
+	static constexpr const char *Categories = "array";
 
 	static ScalarFunction GetFunction();
 };
 
 struct ArrayCrossProductFun {
 	static constexpr const char *Name = "array_cross_product";
-	static constexpr const char *Parameters = "array, array";
-	static constexpr const char *Description = "Compute the cross product of two arrays of size 3. The array elements can not be NULL.";
-	static constexpr const char *Example = "array_cross_product([1, 2, 3], [1, 2, 3])";
-	static constexpr const char *Categories = "";
+	static constexpr const char *Parameters = "array,array";
+	static constexpr const char *Description = "Computes the cross product of two arrays of size 3. The array elements can not be `NULL`.";
+	static constexpr const char *Example = "array_cross_product(array_value(1.0::FLOAT, 2.0::FLOAT, 3.0::FLOAT), array_value(2.0::FLOAT, 3.0::FLOAT, 4.0::FLOAT))";
+	static constexpr const char *Categories = "array";
 
 	static ScalarFunctionSet GetFunctions();
 };
@@ -38,9 +38,9 @@ struct ArrayCrossProductFun {
 struct ArrayCosineSimilarityFun {
 	static constexpr const char *Name = "array_cosine_similarity";
 	static constexpr const char *Parameters = "array1,array2";
-	static constexpr const char *Description = "Compute the cosine similarity between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
-	static constexpr const char *Example = "array_cosine_similarity([1, 2, 3], [1, 2, 3])";
-	static constexpr const char *Categories = "";
+	static constexpr const char *Description = "Computes the cosine similarity between two arrays of the same size. The array elements can not be `NULL`. The arrays can have any size as long as the size is the same for both arguments.";
+	static constexpr const char *Example = "array_cosine_similarity(array_value(1.0::FLOAT, 2.0::FLOAT, 3.0::FLOAT), array_value(2.0::FLOAT, 3.0::FLOAT, 4.0::FLOAT))";
+	static constexpr const char *Categories = "array";
 
 	static ScalarFunctionSet GetFunctions();
 };
@@ -48,9 +48,9 @@ struct ArrayCosineSimilarityFun {
 struct ArrayCosineDistanceFun {
 	static constexpr const char *Name = "array_cosine_distance";
 	static constexpr const char *Parameters = "array1,array2";
-	static constexpr const char *Description = "Compute the cosine distance between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
-	static constexpr const char *Example = "array_cosine_distance([1, 2, 3], [1, 2, 3])";
-	static constexpr const char *Categories = "";
+	static constexpr const char *Description = "Computes the cosine distance between two arrays of the same size. The array elements can not be `NULL`. The arrays can have any size as long as the size is the same for both arguments.";
+	static constexpr const char *Example = "array_cosine_distance(array_value(1.0::FLOAT, 2.0::FLOAT, 3.0::FLOAT), array_value(2.0::FLOAT, 3.0::FLOAT, 4.0::FLOAT))";
+	static constexpr const char *Categories = "array";
 
 	static ScalarFunctionSet GetFunctions();
 };
@@ -58,9 +58,9 @@ struct ArrayCosineDistanceFun {
 struct ArrayDistanceFun {
 	static constexpr const char *Name = "array_distance";
 	static constexpr const char *Parameters = "array1,array2";
-	static constexpr const char *Description = "Compute the distance between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
-	static constexpr const char *Example = "array_distance([1, 2, 3], [1, 2, 3])";
-	static constexpr const char *Categories = "";
+	static constexpr const char *Description = "Computes the distance between two arrays of the same size. The array elements can not be `NULL`. The arrays can have any size as long as the size is the same for both arguments.";
+	static constexpr const char *Example = "array_distance(array_value(1.0::FLOAT, 2.0::FLOAT, 3.0::FLOAT), array_value(2.0::FLOAT, 3.0::FLOAT, 4.0::FLOAT))";
+	static constexpr const char *Categories = "array";
 
 	static ScalarFunctionSet GetFunctions();
 };
@@ -68,9 +68,9 @@ struct ArrayDistanceFun {
 struct ArrayInnerProductFun {
 	static constexpr const char *Name = "array_inner_product";
 	static constexpr const char *Parameters = "array1,array2";
-	static constexpr const char *Description = "Compute the inner product between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
-	static constexpr const char *Example = "array_inner_product([1, 2, 3], [1, 2, 3])";
-	static constexpr const char *Categories = "";
+	static constexpr const char *Description = "Computes the inner product between two arrays of the same size. The array elements can not be `NULL`. The arrays can have any size as long as the size is the same for both arguments.";
+	static constexpr const char *Example = "array_inner_product(array_value(1.0::FLOAT, 2.0::FLOAT, 3.0::FLOAT), array_value(2.0::FLOAT, 3.0::FLOAT, 4.0::FLOAT))";
+	static constexpr const char *Categories = "array";
 
 	static ScalarFunctionSet GetFunctions();
 };
@@ -84,9 +84,9 @@ struct ArrayDotProductFun {
 struct ArrayNegativeInnerProductFun {
 	static constexpr const char *Name = "array_negative_inner_product";
 	static constexpr const char *Parameters = "array1,array2";
-	static constexpr const char *Description = "Compute the negative inner product between two arrays of the same size. The array elements can not be NULL. The arrays can have any size as long as the size is the same for both arguments.";
-	static constexpr const char *Example = "array_negative_inner_product([1, 2, 3], [1, 2, 3])";
-	static constexpr const char *Categories = "";
+	static constexpr const char *Description = "Computes the negative inner product between two arrays of the same size. The array elements can not be `NULL`. The arrays can have any size as long as the size is the same for both arguments.";
+	static constexpr const char *Example = "array_negative_inner_product(array_value(1.0::FLOAT, 2.0::FLOAT, 3.0::FLOAT), array_value(2.0::FLOAT, 3.0::FLOAT, 4.0::FLOAT))";
+	static constexpr const char *Categories = "array";
 
 	static ScalarFunctionSet GetFunctions();
 };

package/src/duckdb/extension/core_functions/include/core_functions/scalar/blob_functions.hpp

@@ -48,8 +48,8 @@ struct FromBase64Fun {
 struct ToBase64Fun {
 	static constexpr const char *Name = "to_base64";
 	static constexpr const char *Parameters = "blob";
-	static constexpr const char *Description = "Converts a `blob` to a base64 encoded `string`.";
-	static constexpr const char *Example = "base64('A'::BLOB)";
+	static constexpr const char *Description = "Converts a `blob` to a base64 encoded string.";
+	static constexpr const char *Example = "to_base64('A'::BLOB)";
 	static constexpr const char *Categories = "string,blob";
 
 	static ScalarFunction GetFunction();

package/src/duckdb/extension/core_functions/include/core_functions/scalar/date_functions.hpp

@@ -283,10 +283,10 @@ struct LastDayFun {
 
 struct MakeDateFun {
 	static constexpr const char *Name = "make_date";
-	static constexpr const char *Parameters = "year,month,day\1date-struct::STRUCT(year BIGINT, month BIGINT, day BIGINT)";
-	static constexpr const char *Description = "The date for the given parts\1The date for the given struct.";
-	static constexpr const char *Example = "make_date(1992, 9, 20)\1make_date({'year': 2024, 'month': 11, 'day': 14})";
-	static constexpr const char *Categories = "\1";
+	static constexpr const char *Parameters = "year,month,day\001date-struct::STRUCT(year BIGINT, month BIGINT, day BIGINT)";
+	static constexpr const char *Description = "The date for the given parts.\001The date for the given struct.";
+	static constexpr const char *Example = "make_date(1992, 9, 20)\001make_date({'year': 2024, 'month': 11, 'day': 14})";
+	static constexpr const char *Categories = "\001";
 
 	static ScalarFunctionSet GetFunctions();
 };
@@ -311,11 +311,21 @@ struct MakeTimestampFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
+struct MakeTimestampMsFun {
+	static constexpr const char *Name = "make_timestamp_ms";
+	static constexpr const char *Parameters = "nanos";
+	static constexpr const char *Description = "The timestamp for the given microseconds since the epoch";
+	static constexpr const char *Example = "make_timestamp_ms(1732117793000000)";
+	static constexpr const char *Categories = "";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
 struct MakeTimestampNsFun {
 	static constexpr const char *Name = "make_timestamp_ns";
 	static constexpr const char *Parameters = "nanos";
 	static constexpr const char *Description = "The timestamp for the given nanoseconds since epoch";
-	static constexpr const char *Example = "make_timestamp(1732117793000000000)";
+	static constexpr const char *Example = "make_timestamp_ns(1732117793000000000)";
 	static constexpr const char *Categories = "";
 
 	static ScalarFunctionSet GetFunctions();

package/src/duckdb/extension/core_functions/include/core_functions/scalar/generic_functions.hpp

@@ -37,30 +37,30 @@ struct CurrentSettingFun {
 
 struct HashFun {
 	static constexpr const char *Name = "hash";
-	static constexpr const char *Parameters = "param";
-	static constexpr const char *Description = "Returns an integer with the hash of the value. Note that this is not a cryptographic hash";
+	static constexpr const char *Parameters = "value";
+	static constexpr const char *Description = "Returns a `UBIGINT` with the hash of the `value`. Note that this is not a cryptographic hash.";
 	static constexpr const char *Example = "hash('🦆')";
-	static constexpr const char *Categories = "";
+	static constexpr const char *Categories = "string";
 
 	static ScalarFunction GetFunction();
 };
 
 struct LeastFun {
 	static constexpr const char *Name = "least";
-	static constexpr const char *Parameters = "arg1, arg2, ...";
-	static constexpr const char *Description = "Returns the lowest value of the set of input parameters";
-	static constexpr const char *Example = "least(42, 84)";
-	static constexpr const char *Categories = "";
+	static constexpr const char *Parameters = "arg1,arg2,...";
+	static constexpr const char *Description = "Returns the smallest value. For strings lexicographical ordering is used. Note that uppercase characters are considered “smaller” than lowercase characters, and collations are not supported.";
+	static constexpr const char *Example = "least(42, 84)\002least('abc', 'bcd', 'cde', 'EFG')";
+	static constexpr const char *Categories = "string,numeric,date,timestamp,aggregate";
 
 	static ScalarFunctionSet GetFunctions();
 };
 
 struct GreatestFun {
 	static constexpr const char *Name = "greatest";
-	static constexpr const char *Parameters = "arg1, arg2, ...";
-	static constexpr const char *Description = "Returns the highest value of the set of input parameters";
-	static constexpr const char *Example = "greatest(42, 84)";
-	static constexpr const char *Categories = "";
+	static constexpr const char *Parameters = "arg1,arg2,...";
+	static constexpr const char *Description = "Returns the largest value. For strings lexicographical ordering is used. Note that lowercase characters are considered “larger” than uppercase characters and collations are not supported.";
+	static constexpr const char *Example = "greatest(42, 84)\002greatest('abc', 'bcd', 'cde', 'EFG')";
+	static constexpr const char *Categories = "string,numeric,date,timestamp,aggregate";
 
 	static ScalarFunctionSet GetFunctions();
 };
@@ -89,7 +89,7 @@ struct CanCastImplicitlyFun {
 	static constexpr const char *Name = "can_cast_implicitly";
 	static constexpr const char *Parameters = "source_type,target_type";
 	static constexpr const char *Description = "Whether or not we can implicitly cast from the source type to the other type";
-	static constexpr const char *Example = "can_implicitly_cast(NULL::INTEGER, NULL::BIGINT)";
+	static constexpr const char *Example = "can_cast_implicitly(NULL::INTEGER, NULL::BIGINT)";
 	static constexpr const char *Categories = "";
 
 	static ScalarFunction GetFunction();
@@ -195,4 +195,14 @@ struct CastToTypeFun {
 	static ScalarFunction GetFunction();
 };
 
+struct ReplaceTypeFun {
+	static constexpr const char *Name = "replace_type";
+	static constexpr const char *Parameters = "param,type1,type2";
+	static constexpr const char *Description = "Casts all fields of type1 to type2";
+	static constexpr const char *Example = "replace_type({duck: 3.141592653589793::DOUBLE}, NULL::DOUBLE, NULL::DECIMAL(15,2))";
+	static constexpr const char *Categories = "";
+
+	static ScalarFunction GetFunction();
+};
+
 } // namespace duckdb