duckdb 0.8.1-dev96.0 → 0.8.1

package/src/duckdb/src/include/duckdb/core_functions/aggregate/algebraic/stddev.hpp

@@ -23,46 +23,50 @@ struct StddevState {
 // method, DOI: 10.2307/1266577
 struct STDDevBaseOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->count = 0;
-		state->mean = 0;
-		state->dsquared = 0;
+	static void Initialize(STATE &state) {
+		state.count = 0;
+		state.mean = 0;
+		state.dsquared = 0;
 	}
 
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, const INPUT_TYPE *input_data, ValidityMask &mask, idx_t idx) {
+	template <class INPUT_TYPE, class STATE>
+	static void Execute(STATE &state, const INPUT_TYPE &input) {
 		// update running mean and d^2
-		state->count++;
-		const double input = input_data[idx];
-		const double mean_differential = (input - state->mean) / state->count;
-		const double new_mean = state->mean + mean_differential;
-		const double dsquared_increment = (input - new_mean) * (input - state->mean);
-		const double new_dsquared = state->dsquared + dsquared_increment;
-
-		state->mean = new_mean;
-		state->dsquared = new_dsquared;
+		state.count++;
+		const double mean_differential = (input - state.mean) / state.count;
+		const double new_mean = state.mean + mean_differential;
+		const double dsquared_increment = (input - new_mean) * (input - state.mean);
+		const double new_dsquared = state.dsquared + dsquared_increment;
+
+		state.mean = new_mean;
+		state.dsquared = new_dsquared;
+
+	}
+
+	template <class INPUT_TYPE, class STATE, class OP>
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &) {
+		Execute(state, input);
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input_data,
-	                              ValidityMask &mask, idx_t count) {
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input_data, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 		}
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (target->count == 0) {
-			*target = source;
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		if (target.count == 0) {
+			target = source;
 		} else if (source.count > 0) {
-			const auto count = target->count + source.count;
-			const auto mean = (source.count * source.mean + target->count * target->mean) / count;
-			const auto delta = source.mean - target->mean;
-			target->dsquared =
-			    source.dsquared + target->dsquared + delta * delta * source.count * target->count / count;
-			target->mean = mean;
-			target->count = count;
+			const auto count = target.count + source.count;
+			const auto mean = (source.count * source.mean + target.count * target.mean) / count;
+			const auto delta = source.mean - target.mean;
+			target.dsquared =
+			    source.dsquared + target.dsquared + delta * delta * source.count * target.count / count;
+			target.mean = mean;
+			target.count = count;
 		}
 	}
 
@@ -73,12 +77,12 @@ struct STDDevBaseOperation {
 
 struct VarSampOperation : public STDDevBaseOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count <= 1) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count <= 1) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = state->dsquared / (state->count - 1);
-			if (!Value::DoubleIsFinite(target[idx])) {
+			target = state.dsquared / (state.count - 1);
+			if (!Value::DoubleIsFinite(target)) {
 				throw OutOfRangeException("VARSAMP is out of range!");
 			}
 		}
@@ -87,12 +91,12 @@ struct VarSampOperation : public STDDevBaseOperation {
 
 struct VarPopOperation : public STDDevBaseOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = state->count > 1 ? (state->dsquared / state->count) : 0;
-			if (!Value::DoubleIsFinite(target[idx])) {
+			target = state.count > 1 ? (state.dsquared / state.count) : 0;
+			if (!Value::DoubleIsFinite(target)) {
 				throw OutOfRangeException("VARPOP is out of range!");
 			}
 		}
@@ -101,12 +105,12 @@ struct VarPopOperation : public STDDevBaseOperation {
 
 struct STDDevSampOperation : public STDDevBaseOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count <= 1) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count <= 1) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = sqrt(state->dsquared / (state->count - 1));
-			if (!Value::DoubleIsFinite(target[idx])) {
+			target = sqrt(state.dsquared / (state.count - 1));
+			if (!Value::DoubleIsFinite(target)) {
 				throw OutOfRangeException("STDDEV_SAMP is out of range!");
 			}
 		}
@@ -115,12 +119,12 @@ struct STDDevSampOperation : public STDDevBaseOperation {
 
 struct STDDevPopOperation : public STDDevBaseOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = state->count > 1 ? sqrt(state->dsquared / state->count) : 0;
-			if (!Value::DoubleIsFinite(target[idx])) {
+			target = state.count > 1 ? sqrt(state.dsquared / state.count) : 0;
+			if (!Value::DoubleIsFinite(target)) {
 				throw OutOfRangeException("STDDEV_POP is out of range!");
 			}
 		}
@@ -129,12 +133,12 @@ struct STDDevPopOperation : public STDDevBaseOperation {
 
 struct StandardErrorOfTheMeanOperation : public STDDevBaseOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = sqrt(state->dsquared / state->count) / sqrt((state->count));
-			if (!Value::DoubleIsFinite(target[idx])) {
+			target = sqrt(state.dsquared / state.count) / sqrt((state.count));
+			if (!Value::DoubleIsFinite(target)) {
 				throw OutOfRangeException("SEM is out of range!");
 			}
 		}

package/src/duckdb/src/include/duckdb/core_functions/aggregate/regression/regr_count.hpp

@@ -16,26 +16,25 @@ namespace duckdb {
 
 struct RegrCountFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		*state = 0;
+	static void Initialize(STATE &state) {
+		state = 0;
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		*target += source;
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		target += source;
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		target[idx] = *state;
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		target = state;
 	}
 	static bool IgnoreNull() {
 		return true;
 	}
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, const A_TYPE *x_data, const B_TYPE *y_data, ValidityMask &amask,
-	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		*state += 1;
+	static void Operation(STATE &state, const A_TYPE &, const B_TYPE &, AggregateBinaryInput &) {
+		state += 1;
 	}
 };
 

package/src/duckdb/src/include/duckdb/core_functions/aggregate/regression/regr_slope.hpp

@@ -19,40 +19,38 @@ struct RegrSlopeState {
 
 struct RegrSlopeOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		CovarOperation::Initialize<CovarState>(&state->cov_pop);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop);
+	static void Initialize(STATE &state) {
+		CovarOperation::Initialize<CovarState>(state.cov_pop);
+		STDDevBaseOperation::Initialize<StddevState>(state.var_pop);
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const A_TYPE *x_data, const B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(&state->cov_pop, aggr_input_data, y_data, x_data,
-		                                                          bmask, amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, aggr_input_data, y_data, bmask, yidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, x, y, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, y);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, &target->cov_pop, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, &target->var_pop, aggr_input_data);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
+		CovarOperation::Combine<CovarState, OP>(source.cov_pop, target.cov_pop, aggr_input_data);
+		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, target.var_pop, aggr_input_data);
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->cov_pop.count == 0 || state->var_pop.count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.cov_pop.count == 0 || state.var_pop.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			auto cov = state->cov_pop.co_moment / state->cov_pop.count;
-			auto var_pop = state->var_pop.count > 1 ? (state->var_pop.dsquared / state->var_pop.count) : 0;
+			auto cov = state.cov_pop.co_moment / state.cov_pop.count;
+			auto var_pop = state.var_pop.count > 1 ? (state.var_pop.dsquared / state.var_pop.count) : 0;
 			if (!Value::DoubleIsFinite(var_pop)) {
 				throw OutOfRangeException("VARPOP is out of range!");
 			}
 			if (var_pop == 0) {
-				mask.SetInvalid(idx);
+				finalize_data.ReturnNull();
 				return;
 			}
-			target[idx] = cov / var_pop;
+			target = cov / var_pop;
 		}
 	}
 

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

@@ -133,27 +133,26 @@ struct HugeintAdd {
 template <class STATEOP, class ADDOP>
 struct BaseSumOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->value = 0;
+	static void Initialize(STATE &state) {
+		state.value = 0;
 		STATEOP::template Initialize<STATE>(state);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
 		STATEOP::template Combine<STATE>(source, target, aggr_input_data);
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, const INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &) {
 		STATEOP::template AddValues<STATE>(state, 1);
-		ADDOP::template AddNumber<STATE, INPUT_TYPE>(*state, input[idx]);
+		ADDOP::template AddNumber<STATE, INPUT_TYPE>(state, input);
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &, const INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &, idx_t count) {
 		STATEOP::template AddValues<STATE>(state, count);
-		ADDOP::template AddConstant<STATE, INPUT_TYPE>(*state, *input, count);
+		ADDOP::template AddConstant<STATE, INPUT_TYPE>(state, input, count);
 	}
 
 	static bool IgnoreNull() {

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

@@ -121,6 +121,15 @@ struct CurrentDatabaseFun {
 	static ScalarFunction GetFunction();
 };
 
+struct InSearchPathFun {
+	static constexpr const char *Name = "in_search_path";
+	static constexpr const char *Parameters = "database_name,schema_name";
+	static constexpr const char *Description = "Returns whether or not the database/schema are in the search path.";
+	static constexpr const char *Example = "in_search_path('memory', 'main')";
+
+	static ScalarFunction GetFunction();
+};
+
 struct CurrentTransactionIdFun {
 	static constexpr const char *Name = "txid_current";
 	static constexpr const char *Parameters = "";

package/src/duckdb/src/include/duckdb/core_functions/scalar/map_functions.hpp

@@ -43,10 +43,7 @@ struct MapEntriesFun {
 struct MapExtractFun {
 	static constexpr const char *Name = "map_extract";
 	static constexpr const char *Parameters = "map,key";
-	static constexpr const char *Description =
-	    "Return a list containing the value for a given key or an empty list if the key is not contained in the map. "
-	    "The type of the key provided in the second parameter must match the type of the map’s keys else an error is "
-	    "returned.";
+	static constexpr const char *Description = "Return a list containing the value for a given key or an empty list if the key is not contained in the map. The type of the key provided in the second parameter must match the type of the map’s keys else an error is returned.";
 	static constexpr const char *Example = "map_extract(map(['key'], ['val']), 'key')";
 
 	static ScalarFunction GetFunction();
@@ -70,8 +67,7 @@ struct MapFromEntriesFun {
 struct MapConcatFun {
 	static constexpr const char *Name = "map_concat";
 	static constexpr const char *Parameters = "any,...";
-	static constexpr const char *Description = "Returns a map created from merging the input maps, on key collision "
-	                                           "the value is taken from the last map with that key";
+	static constexpr const char *Description = "Returns a map created from merging the input maps, on key collision the value is taken from the last map with that key";
 	static constexpr const char *Example = "map_concat(map([1,2], ['a', 'b']), map([2,3], ['c', 'd']));";
 
 	static ScalarFunction GetFunction();

package/src/duckdb/src/include/duckdb/core_functions/scalar/string_functions.hpp

@@ -31,8 +31,7 @@ struct StartsWithFun {
 struct ASCIIFun {
 	static constexpr const char *Name = "ascii";
 	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description =
-	    "Returns an integer that represents the Unicode code point of the first character of the string.";
+	static constexpr const char *Description = "Returns an integer that represents the Unicode code point of the first character of the string.";
 	static constexpr const char *Example = "ascii('Ω')";
 
 	static ScalarFunction GetFunction();
@@ -41,8 +40,7 @@ struct ASCIIFun {
 struct BarFun {
 	static constexpr const char *Name = "bar";
 	static constexpr const char *Parameters = "x,min,max,width";
-	static constexpr const char *Description = "Draw a band whose width is proportional to (x - min) and equal to "
-	                                           "width characters when x = max. width defaults to 80.";
+	static constexpr const char *Description = "Draw a band whose width is proportional to (x - min) and equal to width characters when x = max. width defaults to 80.";
 	static constexpr const char *Example = "bar(5, 0, 20, 10)";
 
 	static ScalarFunctionSet GetFunctions();
@@ -66,8 +64,7 @@ struct ToBinaryFun {
 struct ChrFun {
 	static constexpr const char *Name = "chr";
 	static constexpr const char *Parameters = "code_point";
-	static constexpr const char *Description =
-	    "returns a character which is corresponding the ASCII code value or Unicode code point";
+	static constexpr const char *Description = "returns a character which is corresponding the ASCII code value or Unicode code point";
 	static constexpr const char *Example = "chr(65)";
 
 	static ScalarFunction GetFunction();
@@ -76,10 +73,7 @@ struct ChrFun {
 struct DamerauLevenshteinFun {
 	static constexpr const char *Name = "damerau_levenshtein";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description =
-	    "Extension of Levenshtein distance to also include transposition of adjacent characters as an allowed edit "
-	    "operation. In other words, the minimum number of edit operations (insertions, deletions, substitutions or "
-	    "transpositions) required to change one string to another. Different case is considered different.";
+	static constexpr const char *Description = "Extension of Levenshtein distance to also include transposition of adjacent characters as an allowed edit operation. In other words, the minimum number of edit operations (insertions, deletions, substitutions or transpositions) required to change one string to another. Different case is considered different.";
 	static constexpr const char *Example = "damerau_levenshtein('hello', 'world')";
 
 	static ScalarFunction GetFunction();
@@ -112,8 +106,7 @@ struct FormatreadabledecimalsizeFun {
 struct HammingFun {
 	static constexpr const char *Name = "hamming";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The number of positions with different characters for 2 strings of "
-	                                           "equal length. Different case is considered different.";
+	static constexpr const char *Description = "The number of positions with different characters for 2 strings of equal length. Different case is considered different.";
 	static constexpr const char *Example = "hamming('duck','luck')";
 
 	static ScalarFunction GetFunction();
@@ -143,8 +136,7 @@ struct ToHexFun {
 struct InstrFun {
 	static constexpr const char *Name = "instr";
 	static constexpr const char *Parameters = "haystack,needle";
-	static constexpr const char *Description =
-	    "Return location of first occurrence of needle in haystack, counting from 1. Returns 0 if no match found.";
+	static constexpr const char *Description = "Return location of first occurrence of needle in haystack, counting from 1. Returns 0 if no match found.";
 	static constexpr const char *Example = "instr('test test','es')";
 
 	static ScalarFunction GetFunction();
@@ -165,8 +157,7 @@ struct PositionFun {
 struct JaccardFun {
 	static constexpr const char *Name = "jaccard";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaccard similarity between two strings. Different case is "
-	                                           "considered different. Returns a number between 0 and 1.";
+	static constexpr const char *Description = "The Jaccard similarity between two strings. Different case is considered different. Returns a number between 0 and 1.";
 	static constexpr const char *Example = "jaccard('duck','luck')";
 
 	static ScalarFunction GetFunction();
@@ -175,8 +166,7 @@ struct JaccardFun {
 struct JaroSimilarityFun {
 	static constexpr const char *Name = "jaro_similarity";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaro similarity between two strings. Different case is considered "
-	                                           "different. Returns a number between 0 and 1.";
+	static constexpr const char *Description = "The Jaro similarity between two strings. Different case is considered different. Returns a number between 0 and 1.";
 	static constexpr const char *Example = "jaro_similarity('duck','duckdb')";
 
 	static ScalarFunction GetFunction();
@@ -185,8 +175,7 @@ struct JaroSimilarityFun {
 struct JaroWinklerSimilarityFun {
 	static constexpr const char *Name = "jaro_winkler_similarity";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaro-Winkler similarity between two strings. Different case is "
-	                                           "considered different. Returns a number between 0 and 1.";
+	static constexpr const char *Description = "The Jaro-Winkler similarity between two strings. Different case is considered different. Returns a number between 0 and 1.";
 	static constexpr const char *Example = "jaro_winkler_similarity('duck','duckdb')";
 
 	static ScalarFunction GetFunction();
@@ -213,9 +202,7 @@ struct LeftGraphemeFun {
 struct LevenshteinFun {
 	static constexpr const char *Name = "levenshtein";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description =
-	    "The minimum number of single-character edits (insertions, deletions or substitutions) required to change one "
-	    "string to the other. Different case is considered different.";
+	static constexpr const char *Description = "The minimum number of single-character edits (insertions, deletions or substitutions) required to change one string to the other. Different case is considered different.";
 	static constexpr const char *Example = "levenshtein('duck','db')";
 
 	static ScalarFunction GetFunction();
@@ -230,8 +217,7 @@ struct Editdist3Fun {
 struct LpadFun {
 	static constexpr const char *Name = "lpad";
 	static constexpr const char *Parameters = "string,count,character";
-	static constexpr const char *Description =
-	    "Pads the string with the character from the left until it has count characters";
+	static constexpr const char *Description = "Pads the string with the character from the left until it has count characters";
 	static constexpr const char *Example = "lpad('hello', 10, '>')";
 
 	static ScalarFunction GetFunction();
@@ -240,8 +226,7 @@ struct LpadFun {
 struct LtrimFun {
 	static constexpr const char *Name = "ltrim";
 	static constexpr const char *Parameters = "string,characters";
-	static constexpr const char *Description =
-	    "Removes any occurrences of any of the characters from the left side of the string";
+	static constexpr const char *Description = "Removes any occurrences of any of the characters from the left side of the string";
 	static constexpr const char *Example = "ltrim('>>>>test<<', '><')";
 
 	static ScalarFunctionSet GetFunctions();
@@ -340,8 +325,7 @@ struct RightGraphemeFun {
 struct RpadFun {
 	static constexpr const char *Name = "rpad";
 	static constexpr const char *Parameters = "string,count,character";
-	static constexpr const char *Description =
-	    "Pads the string with the character from the right until it has count characters";
+	static constexpr const char *Description = "Pads the string with the character from the right until it has count characters";
 	static constexpr const char *Example = "rpad('hello', 10, '<')";
 
 	static ScalarFunction GetFunction();
@@ -350,8 +334,7 @@ struct RpadFun {
 struct RtrimFun {
 	static constexpr const char *Name = "rtrim";
 	static constexpr const char *Parameters = "string,characters";
-	static constexpr const char *Description =
-	    "Removes any occurrences of any of the characters from the right side of the string";
+	static constexpr const char *Description = "Removes any occurrences of any of the characters from the right side of the string";
 	static constexpr const char *Example = "rtrim('>>>>test<<', '><')";
 
 	static ScalarFunctionSet GetFunctions();
@@ -408,9 +391,7 @@ struct RegexpSplitToArrayFun {
 struct TranslateFun {
 	static constexpr const char *Name = "translate";
 	static constexpr const char *Parameters = "string,from,to";
-	static constexpr const char *Description =
-	    "Replaces each character in string that matches a character in the from set with the corresponding character "
-	    "in the to set. If from is longer than to, occurrences of the extra characters in from are deleted.";
+	static constexpr const char *Description = "Replaces each character in string that matches a character in the from set with the corresponding character in the to set. If from is longer than to, occurrences of the extra characters in from are deleted.";
 	static constexpr const char *Example = "translate('12345', '143', 'ax')";
 
 	static ScalarFunction GetFunction();
@@ -419,8 +400,7 @@ struct TranslateFun {
 struct TrimFun {
 	static constexpr const char *Name = "trim";
 	static constexpr const char *Parameters = "string,characters";
-	static constexpr const char *Description =
-	    "Removes any occurrences of any of the characters from either side of the string";
+	static constexpr const char *Description = "Removes any occurrences of any of the characters from either side of the string";
 	static constexpr const char *Example = "trim('>>>>test<<', '><')";
 
 	static ScalarFunctionSet GetFunctions();

package/src/duckdb/src/include/duckdb/execution/index/art/art.hpp

@@ -97,8 +97,11 @@ public:
 	//! Performs constraint checking for a chunk of input data
 	void CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) override;
 
-	//! Returns the string representation of the ART
-	string ToString() override;
+	//! Returns the string representation of the ART, or only traverses and verifies the index
+	string VerifyAndToString(IndexLock &state, const bool only_verify) override;
+
+	//! Find the node with a matching key, or return nullptr if not found
+	Node Lookup(Node node, const ARTKey &key, idx_t depth);
 
 private:
 	//! Insert a row ID into a leaf
@@ -107,8 +110,7 @@ private:
 	bool Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
 	//! Erase a key from the tree (if a leaf has more than one value) or erase the leaf itself
 	void Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
-	//! Find the node with a matching key, or return nullptr if not found
-	Node Lookup(Node node, const ARTKey &key, idx_t depth);
+
 	//! Returns all row IDs belonging to a key greater (or equal) than the search key
 	bool SearchGreater(ARTIndexScanState &state, ARTKey &key, bool inclusive, idx_t max_count,
 	                   vector<row_t> &result_ids);
@@ -129,6 +131,10 @@ private:
 	//! Finalizes a vacuum operation by calling the finalize operation of all qualifying
 	//! fixed size allocators
 	void FinalizeVacuum(const ARTFlags &flags);
+
+	//! Internal function to return the string representation of the ART,
+	//! or only traverses and verifies the index
+	string VerifyAndToStringInternal(const bool only_verify);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/art/fixed_size_allocator.hpp

@@ -100,6 +100,9 @@ public:
 	//! Vacuums a pointer
 	SwizzleablePointer VacuumPointer(const SwizzleablePointer ptr);
 
+	//! Verify that the allocation counts match the existing positions on the buffers
+	void Verify() const;
+
 private:
 	//! Returns the data_ptr_t of a pointer
 	inline data_ptr_t Get(const SwizzleablePointer ptr) const {

package/src/duckdb/src/include/duckdb/execution/index/art/leaf.hpp

@@ -73,7 +73,7 @@ public:
 	uint32_t FindRowId(const ART &art, Node &ptr, const row_t row_id) const;
 
 	//! Returns the string representation of a leaf
-	string ToString(const ART &art) const;
+	string VerifyAndToString(const ART &art, const bool only_verify) const;
 
 	//! Serialize this leaf
 	BlockPointer Serialize(const ART &art, MetaBlockWriter &writer) const;

package/src/duckdb/src/include/duckdb/execution/index/art/leaf_segment.hpp

@@ -26,6 +26,8 @@ public:
 	static inline LeafSegment &Get(const ART &art, const Node ptr) {
 		return *Node::GetAllocator(art, NType::LEAF_SEGMENT).Get<LeafSegment>(ptr);
 	}
+	//! Free the leaf segment and any subsequent ones
+	static void Free(ART &art, Node &node);
 
 	//! Append a row ID to the current segment, or create a new segment containing that row ID
 	LeafSegment &Append(ART &art, uint32_t &count, const row_t row_id);

package/src/duckdb/src/include/duckdb/execution/index/art/node.hpp

@@ -65,13 +65,23 @@ public:
 	//! Free the node (and its subtree)
 	static void Free(ART &art, Node &node);
 
+	inline bool operator==(const Node &node) const {
+		return swizzle_flag == node.swizzle_flag && type == node.type && offset == node.offset &&
+		       buffer_id == node.buffer_id;
+	}
+
 	//! Retrieve the node type from the leftmost byte
 	inline NType DecodeARTNodeType() const {
+		D_ASSERT(!IsSwizzled());
+		D_ASSERT(type >= (uint8_t)NType::PREFIX_SEGMENT);
+		D_ASSERT(type <= (uint8_t)NType::NODE_256);
 		return NType(type);
 	}
 
 	//! Set the pointer
 	inline void SetPtr(const SwizzleablePointer ptr) {
+		swizzle_flag = ptr.swizzle_flag;
+		type = ptr.type;
 		offset = ptr.offset;
 		buffer_id = ptr.buffer_id;
 	}
@@ -86,15 +96,15 @@ public:
 	//! Get the child for the respective byte in the node
 	optional_ptr<Node> GetChild(ART &art, const uint8_t byte) const;
 	//! Get the first child that is greater or equal to the specific byte
-	optional_ptr<Node> GetNextChild(ART &art, uint8_t &byte) const;
+	optional_ptr<Node> GetNextChild(ART &art, uint8_t &byte, const bool deserialize = true) const;
 
 	//! Serialize the node
 	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
 	//! Deserialize the node
 	void Deserialize(ART &art);
 
-	//! Returns the string representation of the node
-	string ToString(ART &art) const;
+	//! Returns the string representation of the node, or only traverses and verifies the node and its subtree
+	string VerifyAndToString(ART &art, const bool only_verify);
 	//! Returns the capacity of the node
 	idx_t GetCapacity() const;
 	//! Returns a pointer to the prefix of the node

package/src/duckdb/src/include/duckdb/execution/index/art/node48.hpp

@@ -59,6 +59,7 @@ public:
 	//! Get the child for the respective byte in the node
 	inline optional_ptr<Node> GetChild(const uint8_t byte) {
 		if (child_index[byte] != Node::EMPTY_MARKER) {
+			D_ASSERT(children[child_index[byte]].IsSet());
 			return &children[child_index[byte]];
 		}
 		return nullptr;