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

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

@@ -26,7 +26,7 @@ struct RegrSlopeOperation {
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
 	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, y, x,idata);
+		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, y, x, idata);
 		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, x);
 	}
 

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

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/core_functions/aggregate/sort_key_helpers.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/core_functions/create_sort_key.hpp"
+
+namespace duckdb {
+
+struct AggregateSortKeyHelpers {
+	template <class STATE, class OP, OrderType ORDER_TYPE = OrderType::ASCENDING, bool IGNORE_NULLS = true>
+	static void UnaryUpdate(Vector inputs[], AggregateInputData &input_data, idx_t input_count, Vector &state_vector,
+	                        idx_t count) {
+		D_ASSERT(input_count == 1);
+		auto &input = inputs[0];
+
+		Vector sort_key(LogicalType::BLOB);
+		auto modifiers = OrderModifiers(ORDER_TYPE, OrderByNullType::NULLS_LAST);
+		CreateSortKeyHelpers::CreateSortKey(input, count, modifiers, sort_key);
+
+		UnifiedVectorFormat idata;
+		if (IGNORE_NULLS) {
+			input.ToUnifiedFormat(count, idata);
+		}
+
+		UnifiedVectorFormat kdata;
+		sort_key.ToUnifiedFormat(count, kdata);
+
+		UnifiedVectorFormat sdata;
+		state_vector.ToUnifiedFormat(count, sdata);
+
+		auto key_data = UnifiedVectorFormat::GetData<string_t>(kdata);
+		auto states = UnifiedVectorFormat::GetData<STATE *>(sdata);
+		for (idx_t i = 0; i < count; i++) {
+			const auto sidx = sdata.sel->get_index(i);
+			if (IGNORE_NULLS) {
+				auto idx = idata.sel->get_index(i);
+				if (!idata.validity.RowIsValid(idx)) {
+					continue;
+				}
+			}
+			const auto key_idx = kdata.sel->get_index(i);
+			auto &state = *states[sidx];
+			OP::template Execute<string_t, STATE, OP>(state, key_data[key_idx], input_data);
+		}
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/array_kernels.hpp

@@ -0,0 +1,107 @@
+#pragma once
+#include "duckdb/common/typedefs.hpp"
+#include "duckdb/common/algorithm.hpp"
+#include <cmath>
+
+namespace duckdb {
+
+//-------------------------------------------------------------------------
+// Folding Operations
+//-------------------------------------------------------------------------
+struct InnerProductOp {
+	static constexpr bool ALLOW_EMPTY = true;
+
+	template <class TYPE>
+	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
+
+		TYPE result = 0;
+
+		auto lhs_ptr = lhs_data;
+		auto rhs_ptr = rhs_data;
+
+		for (idx_t i = 0; i < count; i++) {
+			const auto x = *lhs_ptr++;
+			const auto y = *rhs_ptr++;
+			result += x * y;
+		}
+
+		return result;
+	}
+};
+
+struct NegativeInnerProductOp {
+	static constexpr bool ALLOW_EMPTY = true;
+
+	template <class TYPE>
+	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
+		return -InnerProductOp::Operation(lhs_data, rhs_data, count);
+	}
+};
+
+struct CosineSimilarityOp {
+	static constexpr bool ALLOW_EMPTY = false;
+
+	template <class TYPE>
+	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
+
+		TYPE distance = 0;
+		TYPE norm_l = 0;
+		TYPE norm_r = 0;
+
+		auto l_ptr = lhs_data;
+		auto r_ptr = rhs_data;
+
+		for (idx_t i = 0; i < count; i++) {
+			const auto x = *l_ptr++;
+			const auto y = *r_ptr++;
+			distance += x * y;
+			norm_l += x * x;
+			norm_r += y * y;
+		}
+
+		auto similarity = distance / std::sqrt(norm_l * norm_r);
+		return std::max(static_cast<TYPE>(-1.0), std::min(similarity, static_cast<TYPE>(1.0)));
+	}
+};
+
+struct CosineDistanceOp {
+	static constexpr bool ALLOW_EMPTY = false;
+
+	template <class TYPE>
+	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
+		return static_cast<TYPE>(1.0) - CosineSimilarityOp::Operation(lhs_data, rhs_data, count);
+	}
+};
+
+struct DistanceSquaredOp {
+	static constexpr bool ALLOW_EMPTY = true;
+
+	template <class TYPE>
+	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
+
+		TYPE distance = 0;
+
+		auto l_ptr = lhs_data;
+		auto r_ptr = rhs_data;
+
+		for (idx_t i = 0; i < count; i++) {
+			const auto x = *l_ptr++;
+			const auto y = *r_ptr++;
+			const auto diff = x - y;
+			distance += diff * diff;
+		}
+
+		return distance;
+	}
+};
+
+struct DistanceOp {
+	static constexpr bool ALLOW_EMPTY = true;
+
+	template <class TYPE>
+	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
+		return std::sqrt(DistanceSquaredOp::Operation(lhs_data, rhs_data, count));
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/create_sort_key.hpp

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/core_functions/create_sort_key.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/function_set.hpp"
+
+namespace duckdb {
+
+struct OrderModifiers {
+	OrderModifiers(OrderType order_type, OrderByNullType null_type) : order_type(order_type), null_type(null_type) {
+	}
+
+	OrderType order_type;
+	OrderByNullType null_type;
+
+	bool operator==(const OrderModifiers &other) const {
+		return order_type == other.order_type && null_type == other.null_type;
+	}
+
+	static OrderModifiers Parse(const string &val) {
+		auto lcase = StringUtil::Replace(StringUtil::Lower(val), "_", " ");
+		OrderType order_type;
+		if (StringUtil::StartsWith(lcase, "asc")) {
+			order_type = OrderType::ASCENDING;
+		} else if (StringUtil::StartsWith(lcase, "desc")) {
+			order_type = OrderType::DESCENDING;
+		} else {
+			throw BinderException("create_sort_key modifier must start with either ASC or DESC");
+		}
+		OrderByNullType null_type;
+		if (StringUtil::EndsWith(lcase, "nulls first")) {
+			null_type = OrderByNullType::NULLS_FIRST;
+		} else if (StringUtil::EndsWith(lcase, "nulls last")) {
+			null_type = OrderByNullType::NULLS_LAST;
+		} else {
+			throw BinderException("create_sort_key modifier must end with either NULLS FIRST or NULLS LAST");
+		}
+		return OrderModifiers(order_type, null_type);
+	}
+};
+
+struct CreateSortKeyHelpers {
+	static void CreateSortKey(Vector &input, idx_t input_count, OrderModifiers modifiers, Vector &result);
+	static void DecodeSortKey(string_t sort_key, Vector &result, idx_t result_idx, OrderModifiers modifiers);
+	static void CreateSortKeyWithValidity(Vector &input, Vector &result, const OrderModifiers &modifiers,
+	                                      const idx_t count);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/lambda_functions.hpp

@@ -104,7 +104,6 @@ public:
 			// get the list column entries
 			list_column.ToUnifiedFormat(row_count, list_column_format);
 			list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_column_format);
-
 			child_vector = &ListVector::GetEntry(list_column);
 
 			// get the lambda column data for all other input vectors
@@ -126,7 +125,7 @@ public:
 	};
 
 	static vector<ColumnInfo> GetColumnInfo(DataChunk &args, const idx_t row_count);
-	static vector<reference<ColumnInfo>> GetInconstantColumnInfo(vector<ColumnInfo> &data);
+	static vector<reference<ColumnInfo>> GetMutableColumnInfo(vector<ColumnInfo> &data);
 };
 
 } // namespace duckdb

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

@@ -42,6 +42,15 @@ struct ArrayCosineSimilarityFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
+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 ScalarFunctionSet GetFunctions();
+};
+
 struct ArrayDistanceFun {
 	static constexpr const char *Name = "array_distance";
 	static constexpr const char *Parameters = "array1,array2";
@@ -66,4 +75,19 @@ struct ArrayDotProductFun {
 	static constexpr const char *Name = "array_dot_product";
 };
 
+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 ScalarFunctionSet GetFunctions();
+};
+
+struct ArrayNegativeDotProductFun {
+	using ALIAS = ArrayNegativeInnerProductFun;
+
+	static constexpr const char *Name = "array_negative_dot_product";
+};
+
 } // namespace duckdb

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

@@ -363,6 +363,15 @@ struct MonthNameFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
+struct NanosecondsFun {
+	static constexpr const char *Name = "nanosecond";
+	static constexpr const char *Parameters = "tsns";
+	static constexpr const char *Description = "Extract the nanosecond component from a date or timestamp";
+	static constexpr const char *Example = "nanosecond(timestamp_ns '2021-08-03 11:59:44.123456789') => 44123456789";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
 struct QuarterFun {
 	static constexpr const char *Name = "quarter";
 	static constexpr const char *Parameters = "ts";

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

@@ -87,6 +87,15 @@ struct TypeOfFun {
 	static ScalarFunction GetFunction();
 };
 
+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 ScalarFunction GetFunction();
+};
+
 struct CurrentQueryFun {
 	static constexpr const char *Name = "current_query";
 	static constexpr const char *Parameters = "";
@@ -150,4 +159,22 @@ struct VersionFun {
 	static ScalarFunction GetFunction();
 };
 
+struct EquiWidthBinsFun {
+	static constexpr const char *Name = "equi_width_bins";
+	static constexpr const char *Parameters = "min,max,bin_count,nice_rounding";
+	static constexpr const char *Description = "Generates bin_count equi-width bins between the min and max. If enabled nice_rounding makes the numbers more readable/less jagged";
+	static constexpr const char *Example = "equi_width_bins(0, 10, 2, true)";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct IsHistogramOtherBinFun {
+	static constexpr const char *Name = "is_histogram_other_bin";
+	static constexpr const char *Parameters = "val";
+	static constexpr const char *Description = "Whether or not the provided value is the histogram \"other\" bin (used for values not belonging to any provided bin)";
+	static constexpr const char *Example = "is_histogram_other_bin(v)";
+
+	static ScalarFunction GetFunction();
+};
+
 } // namespace duckdb

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

@@ -261,21 +261,30 @@ struct ListRangeFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
-struct ListCosineSimilarityFun {
-	static constexpr const char *Name = "list_cosine_similarity";
+struct ListCosineDistanceFun {
+	static constexpr const char *Name = "list_cosine_distance";
 	static constexpr const char *Parameters = "list1,list2";
-	static constexpr const char *Description = "Compute the cosine similarity between two lists";
-	static constexpr const char *Example = "list_cosine_similarity([1, 2, 3], [1, 2, 3])";
+	static constexpr const char *Description = "Compute the cosine distance between two lists";
+	static constexpr const char *Example = "list_cosine_distance([1, 2, 3], [1, 2, 3])";
 
 	static ScalarFunctionSet GetFunctions();
 };
 
-struct ListCosineSimilarityFunAlias {
-	using ALIAS = ListCosineSimilarityFun;
+struct ListCosineDistanceFunAlias {
+	using ALIAS = ListCosineDistanceFun;
 
 	static constexpr const char *Name = "<=>";
 };
 
+struct ListCosineSimilarityFun {
+	static constexpr const char *Name = "list_cosine_similarity";
+	static constexpr const char *Parameters = "list1,list2";
+	static constexpr const char *Description = "Compute the cosine similarity between two lists";
+	static constexpr const char *Example = "list_cosine_similarity([1, 2, 3], [1, 2, 3])";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
 struct ListDistanceFun {
 	static constexpr const char *Name = "list_distance";
 	static constexpr const char *Parameters = "list1,list2";
@@ -306,8 +315,23 @@ struct ListDotProductFun {
 	static constexpr const char *Name = "list_dot_product";
 };
 
-struct ListInnerProductFunAlias {
-	using ALIAS = ListInnerProductFun;
+struct ListNegativeInnerProductFun {
+	static constexpr const char *Name = "list_negative_inner_product";
+	static constexpr const char *Parameters = "list1,list2";
+	static constexpr const char *Description = "Compute the negative inner product between two lists";
+	static constexpr const char *Example = "list_negative_inner_product([1, 2, 3], [1, 2, 3])";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct ListNegativeDotProductFun {
+	using ALIAS = ListNegativeInnerProductFun;
+
+	static constexpr const char *Name = "list_negative_dot_product";
+};
+
+struct ListNegativeInnerProductFunAlias {
+	using ALIAS = ListNegativeInnerProductFun;
 
 	static constexpr const char *Name = "<#>";
 };
@@ -321,4 +345,52 @@ struct UnpivotListFun {
 	static ScalarFunction GetFunction();
 };
 
+struct ListHasAnyFun {
+	static constexpr const char *Name = "list_has_any";
+	static constexpr const char *Parameters = "l1, l2";
+	static constexpr const char *Description = "Returns true if the lists have any element in common. NULLs are ignored.";
+	static constexpr const char *Example = "list_has_any([1, 2, 3], [2, 3, 4])";
+
+	static ScalarFunction GetFunction();
+};
+
+struct ArrayHasAnyFun {
+	using ALIAS = ListHasAnyFun;
+
+	static constexpr const char *Name = "array_has_any";
+};
+
+struct ListHasAnyFunAlias {
+	using ALIAS = ListHasAnyFun;
+
+	static constexpr const char *Name = "&&";
+};
+
+struct ListHasAllFun {
+	static constexpr const char *Name = "list_has_all";
+	static constexpr const char *Parameters = "l1, l2";
+	static constexpr const char *Description = "Returns true if all elements of l2 are in l1. NULLs are ignored.";
+	static constexpr const char *Example = "list_has_all([1, 2, 3], [2, 3])";
+
+	static ScalarFunction GetFunction();
+};
+
+struct ArrayHasAllFun {
+	using ALIAS = ListHasAllFun;
+
+	static constexpr const char *Name = "array_has_all";
+};
+
+struct ListHasAllFunAlias {
+	using ALIAS = ListHasAllFun;
+
+	static constexpr const char *Name = "@>";
+};
+
+struct ListHasAllFunAlias2 {
+	using ALIAS = ListHasAllFun;
+
+	static constexpr const char *Name = "<@";
+};
+
 } // namespace duckdb

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

@@ -93,4 +93,13 @@ struct MapValuesFun {
 	static ScalarFunction GetFunction();
 };
 
+struct MapContainsFun {
+	static constexpr const char *Name = "map_contains";
+	static constexpr const char *Parameters = "map,key";
+	static constexpr const char *Description = "Returns true if the map contains the key, false otherwise";
+	static constexpr const char *Example = "map_contains(map(['key'], ['val']), 'key')";
+
+	static ScalarFunction GetFunction();
+};
+
 } // namespace duckdb

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

@@ -396,4 +396,58 @@ struct TruncFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
+struct CoshFun {
+	static constexpr const char *Name = "cosh";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Computes the hyperbolic cos of x";
+	static constexpr const char *Example = "cosh(1)";
+
+	static ScalarFunction GetFunction();
+};
+
+struct SinhFun {
+	static constexpr const char *Name = "sinh";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Computes the hyperbolic sin of x";
+	static constexpr const char *Example = "sinh(1)";
+
+	static ScalarFunction GetFunction();
+};
+
+struct TanhFun {
+	static constexpr const char *Name = "tanh";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Computes the hyperbolic tan of x";
+	static constexpr const char *Example = "tanh(1)";
+
+	static ScalarFunction GetFunction();
+};
+
+struct AcoshFun {
+	static constexpr const char *Name = "acosh";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Computes the inverse hyperbolic cos of x";
+	static constexpr const char *Example = "acosh(0.5)";
+
+	static ScalarFunction GetFunction();
+};
+
+struct AsinhFun {
+	static constexpr const char *Name = "asinh";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Computes the inverse hyperbolic sin of x";
+	static constexpr const char *Example = "asinh(0.5)";
+
+	static ScalarFunction GetFunction();
+};
+
+struct AtanhFun {
+	static constexpr const char *Name = "atanh";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Computes the inverse hyperbolic tan of x";
+	static constexpr const char *Example = "atanh(0.5)";
+
+	static ScalarFunction GetFunction();
+};
+
 } // namespace duckdb

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

@@ -249,7 +249,7 @@ struct MD5Fun {
 	static constexpr const char *Description = "Returns the MD5 hash of the value as a string";
 	static constexpr const char *Example = "md5('123')";
 
-	static ScalarFunction GetFunction();
+	static ScalarFunctionSet GetFunctions();
 };
 
 struct MD5NumberFun {
@@ -258,25 +258,7 @@ struct MD5NumberFun {
 	static constexpr const char *Description = "Returns the MD5 hash of the value as an INT128";
 	static constexpr const char *Example = "md5_number('123')";
 
-	static ScalarFunction GetFunction();
-};
-
-struct MD5NumberLowerFun {
-	static constexpr const char *Name = "md5_number_lower";
-	static constexpr const char *Parameters = "value";
-	static constexpr const char *Description = "Returns the MD5 hash of the value as an INT128";
-	static constexpr const char *Example = "md5_number_lower('123')";
-
-	static ScalarFunction GetFunction();
-};
-
-struct MD5NumberUpperFun {
-	static constexpr const char *Name = "md5_number_upper";
-	static constexpr const char *Parameters = "value";
-	static constexpr const char *Description = "Returns the MD5 hash of the value as an INT128";
-	static constexpr const char *Example = "md5_number_upper('123')";
-
-	static ScalarFunction GetFunction();
+	static ScalarFunctionSet GetFunctions();
 };
 
 struct ParseDirnameFun {
@@ -387,13 +369,22 @@ struct RtrimFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
+struct SHA1Fun {
+	static constexpr const char *Name = "sha1";
+	static constexpr const char *Parameters = "value";
+	static constexpr const char *Description = "Returns the SHA1 hash of the value";
+	static constexpr const char *Example = "sha1('hello')";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
 struct SHA256Fun {
 	static constexpr const char *Name = "sha256";
 	static constexpr const char *Parameters = "value";
 	static constexpr const char *Description = "Returns the SHA256 hash of the value";
 	static constexpr const char *Example = "sha256('hello')";
 
-	static ScalarFunction GetFunction();
+	static ScalarFunctionSet GetFunctions();
 };
 
 struct StringSplitFun {
@@ -525,4 +516,22 @@ struct RegexpEscapeFun {
 	static ScalarFunction GetFunction();
 };
 
+struct UrlEncodeFun {
+	static constexpr const char *Name = "url_encode";
+	static constexpr const char *Parameters = "input";
+	static constexpr const char *Description = "Escapes the input string by encoding it so that it can be included in a URL query parameter.";
+	static constexpr const char *Example = "url_encode('this string has/ special+ characters>')";
+
+	static ScalarFunction GetFunction();
+};
+
+struct UrlDecodeFun {
+	static constexpr const char *Name = "url_decode";
+	static constexpr const char *Parameters = "input";
+	static constexpr const char *Description = "Unescapes the URL encoded input.";
+	static constexpr const char *Example = "url_decode('this%20string%20is%2BFencoded')";
+
+	static ScalarFunction GetFunction();
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/adaptive_filter.hpp

@@ -8,31 +8,42 @@
 
 #pragma once
 
-#include "duckdb/planner/expression/list.hpp"
 #include "duckdb/planner/table_filter.hpp"
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/chrono.hpp"
+#include "duckdb/common/random_engine.hpp"
 
-#include <random>
 namespace duckdb {
 
+struct AdaptiveFilterState {
+	time_point<high_resolution_clock> start_time;
+};
+
 class AdaptiveFilter {
 public:
 	explicit AdaptiveFilter(const Expression &expr);
-	explicit AdaptiveFilter(TableFilterSet *table_filters);
-	void AdaptRuntimeStatistics(double duration);
+	explicit AdaptiveFilter(const TableFilterSet &table_filters);
+
 	vector<idx_t> permutation;
 
+public:
+	void AdaptRuntimeStatistics(double duration);
+
+	AdaptiveFilterState BeginFilter() const;
+	void EndFilter(AdaptiveFilterState state);
+
 private:
 	//! used for adaptive expression reordering
-	idx_t iteration_count;
-	idx_t swap_idx;
-	idx_t right_random_border;
-	idx_t observe_interval;
-	idx_t execute_interval;
-	double runtime_sum;
-	double prev_mean;
-	bool observe;
-	bool warmup;
+	idx_t iteration_count = 0;
+	idx_t swap_idx = 0;
+	idx_t right_random_border = 0;
+	idx_t observe_interval = 0;
+	idx_t execute_interval = 0;
+	double runtime_sum = 0;
+	double prev_mean = 0;
+	bool observe = false;
+	bool warmup = false;
 	vector<idx_t> swap_likeliness;
-	std::default_random_engine generator;
+	RandomEngine generator;
 };
 } // namespace duckdb