duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

package/src/duckdb/src/include/duckdb/function/aggregate_function.hpp

@@ -16,6 +16,8 @@
 
 namespace duckdb {
 
+class BufferManager;
+
 //! A half-open range of frame boundary values _relative to the current row_
 //! This is why they are signed values.
 struct FrameDelta {
@@ -29,14 +31,21 @@ struct FrameDelta {
 using FrameStats = array<FrameDelta, 2>;
 
 //! The partition data for custom window functions
+//! Note that if the inputs is nullptr then the column count is 0,
+//! but the row count will still be valid
+class ColumnDataCollection;
 struct WindowPartitionInput {
-	WindowPartitionInput(const Vector inputs[], idx_t input_count, idx_t count, const ValidityMask &filter_mask,
+	WindowPartitionInput(ClientContext &context, const ColumnDataCollection *inputs, idx_t count,
+	                     vector<column_t> &column_ids, vector<bool> &all_valid, const ValidityMask &filter_mask,
 	                     const FrameStats &stats)
-	    : inputs(inputs), input_count(input_count), count(count), filter_mask(filter_mask), stats(stats) {
+	    : context(context), inputs(inputs), count(count), column_ids(column_ids), all_valid(all_valid),
+	      filter_mask(filter_mask), stats(stats) {
 	}
-	const Vector *inputs;
-	idx_t input_count;
+	ClientContext &context;
+	const ColumnDataCollection *inputs;
 	idx_t count;
+	vector<column_t> column_ids;
+	vector<bool> all_valid;
 	const ValidityMask &filter_mask;
 	const FrameStats stats;
 };
@@ -94,6 +103,13 @@ struct AggregateFunctionInfo {
 	}
 };
 
+enum class AggregateDestructorType {
+	STANDARD,
+	// legacy destructors allow non-trivial destructors in aggregate states
+	// these might not be trivial to off-load to disk
+	LEGACY
+};
+
 class AggregateFunction : public BaseScalarFunction { // NOLINT: work-around bug in clang-tidy
 public:
 	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
@@ -108,7 +124,8 @@ public:
 	                         LogicalType(LogicalTypeId::INVALID), null_handling),
 	      state_size(state_size), initialize(initialize), update(update), combine(combine), finalize(finalize),
 	      simple_update(simple_update), window(window), bind(bind), destructor(destructor), statistics(statistics),
-	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
+	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT),
+	      distinct_dependent(AggregateDistinctDependent::DISTINCT_DEPENDENT) {
 	}
 
 	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
@@ -122,7 +139,8 @@ public:
 	                         LogicalType(LogicalTypeId::INVALID)),
 	      state_size(state_size), initialize(initialize), update(update), combine(combine), finalize(finalize),
 	      simple_update(simple_update), window(window), bind(bind), destructor(destructor), statistics(statistics),
-	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
+	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT),
+	      distinct_dependent(AggregateDistinctDependent::DISTINCT_DEPENDENT) {
 	}
 
 	AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type, aggregate_size_t state_size,
@@ -177,6 +195,8 @@ public:
 	aggregate_deserialize_t deserialize;
 	//! Whether or not the aggregate is order dependent
 	AggregateOrderDependent order_dependent;
+	//! Whether or not the aggregate is affect by distinct modifiers
+	AggregateDistinctDependent distinct_dependent;
 	//! Additional function info, passed to the bind
 	shared_ptr<AggregateFunctionInfo> function_info;
 
@@ -197,29 +217,33 @@ public:
 		    AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>, AggregateFunction::NullaryUpdate<STATE, OP>);
 	}
 
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
+	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP,
+	          AggregateDestructorType destructor_type = AggregateDestructorType::STANDARD>
 	static AggregateFunction
 	UnaryAggregate(const LogicalType &input_type, LogicalType return_type,
 	               FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING) {
-		return AggregateFunction(
-		    {input_type}, return_type, AggregateFunction::StateSize<STATE>,
-		    AggregateFunction::StateInitialize<STATE, OP>, AggregateFunction::UnaryScatterUpdate<STATE, INPUT_TYPE, OP>,
-		    AggregateFunction::StateCombine<STATE, OP>, AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>,
-		    null_handling, AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>);
+		return AggregateFunction({input_type}, return_type, AggregateFunction::StateSize<STATE>,
+		                         AggregateFunction::StateInitialize<STATE, OP, destructor_type>,
+		                         AggregateFunction::UnaryScatterUpdate<STATE, INPUT_TYPE, OP>,
+		                         AggregateFunction::StateCombine<STATE, OP>,
+		                         AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>, null_handling,
+		                         AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>);
 	}
 
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
+	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP,
+	          AggregateDestructorType destructor_type = AggregateDestructorType::STANDARD>
 	static AggregateFunction UnaryAggregateDestructor(LogicalType input_type, LogicalType return_type) {
-		auto aggregate = UnaryAggregate<STATE, INPUT_TYPE, RESULT_TYPE, OP>(input_type, return_type);
+		auto aggregate = UnaryAggregate<STATE, INPUT_TYPE, RESULT_TYPE, OP, destructor_type>(input_type, return_type);
 		aggregate.destructor = AggregateFunction::StateDestroy<STATE, OP>;
 		return aggregate;
 	}
 
-	template <class STATE, class A_TYPE, class B_TYPE, class RESULT_TYPE, class OP>
+	template <class STATE, class A_TYPE, class B_TYPE, class RESULT_TYPE, class OP,
+	          AggregateDestructorType destructor_type = AggregateDestructorType::STANDARD>
 	static AggregateFunction BinaryAggregate(const LogicalType &a_type, const LogicalType &b_type,
 	                                         LogicalType return_type) {
 		return AggregateFunction({a_type, b_type}, return_type, AggregateFunction::StateSize<STATE>,
-		                         AggregateFunction::StateInitialize<STATE, OP>,
+		                         AggregateFunction::StateInitialize<STATE, OP, destructor_type>,
 		                         AggregateFunction::BinaryScatterUpdate<STATE, A_TYPE, B_TYPE, OP>,
 		                         AggregateFunction::StateCombine<STATE, OP>,
 		                         AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>,
@@ -232,8 +256,14 @@ public:
 		return sizeof(STATE);
 	}
 
-	template <class STATE, class OP>
+	template <class STATE, class OP, AggregateDestructorType destructor_type = AggregateDestructorType::STANDARD>
 	static void StateInitialize(const AggregateFunction &, data_ptr_t state) {
+		// FIXME: we should remove the "destructor_type" option in the future
+#if !defined(__GNUC__) || (__GNUC__ >= 5)
+		static_assert(std::is_trivially_move_constructible<STATE>::value ||
+		                  destructor_type == AggregateDestructorType::LEGACY,
+		              "Aggregate state must be trivially move constructible");
+#endif
 		OP::Initialize(*reinterpret_cast<STATE *>(state));
 	}
 
@@ -265,16 +295,6 @@ public:
 		AggregateExecutor::UnaryUpdate<STATE, INPUT_TYPE, OP>(inputs[0], aggr_input_data, state, count);
 	}
 
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void UnaryWindow(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition,
-	                        const_data_ptr_t g_state, data_ptr_t l_state, const SubFrames &subframes, Vector &result,
-	                        idx_t rid) {
-
-		D_ASSERT(partition.input_count == 1);
-		AggregateExecutor::UnaryWindow<STATE, INPUT_TYPE, RESULT_TYPE, OP>(
-		    partition.inputs[0], partition.filter_mask, aggr_input_data, l_state, subframes, result, rid, g_state);
-	}
-
 	template <class STATE, class A_TYPE, class B_TYPE, class OP>
 	static void BinaryScatterUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
 	                                Vector &states, idx_t count) {

package/src/duckdb/src/include/duckdb/function/aggregate_state.hpp

@@ -17,6 +17,8 @@ namespace duckdb {
 enum class AggregateType : uint8_t { NON_DISTINCT = 1, DISTINCT = 2 };
 //! Whether or not the input order influences the result of the aggregate
 enum class AggregateOrderDependent : uint8_t { ORDER_DEPENDENT = 1, NOT_ORDER_DEPENDENT = 2 };
+//! Whether or not the input distinctness influences the result of the aggregate
+enum class AggregateDistinctDependent : uint8_t { DISTINCT_DEPENDENT = 1, NOT_DISTINCT_DEPENDENT = 2 };
 //! Whether or not the combiner needs to preserve the source
 enum class AggregateCombineType : uint8_t { PRESERVE_INPUT = 1, ALLOW_DESTRUCTIVE = 2 };
 

package/src/duckdb/src/include/duckdb/function/built_in_functions.hpp

@@ -54,19 +54,12 @@ private:
 	void RegisterArrowFunctions();
 	void RegisterSnifferFunction();
 
-	// aggregates
-	void RegisterDistributiveAggregates();
-
-	// scalar functions
-	void RegisterCompressedMaterializationFunctions();
-	void RegisterGenericFunctions();
-	void RegisterOperators();
-	void RegisterStringFunctions();
-	void RegisterNestedFunctions();
-	void RegisterSequenceFunctions();
+	void RegisterExtensionOverloads();
 
 	// pragmas
 	void RegisterPragmaFunctions();
+
+	void AddExtensionFunction(ScalarFunctionSet set);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/cast/bound_cast_data.hpp

@@ -48,21 +48,27 @@ struct ListCast {
 };
 
 struct StructBoundCastData : public BoundCastData {
-	StructBoundCastData(vector<BoundCastInfo> child_casts, LogicalType target_p, vector<idx_t> child_member_map_p)
+	StructBoundCastData(vector<BoundCastInfo> child_casts, LogicalType target_p, vector<idx_t> source_indexes_p,
+	                    vector<idx_t> target_indexes_p, vector<idx_t> target_null_indexes_p)
 	    : child_cast_info(std::move(child_casts)), target(std::move(target_p)),
-	      child_member_map(std::move(child_member_map_p)) {
-		D_ASSERT(child_cast_info.size() == child_member_map.size());
+	      source_indexes(std::move(source_indexes_p)), target_indexes(std::move(target_indexes_p)),
+	      target_null_indexes(std::move(target_null_indexes_p)) {
+		D_ASSERT(child_cast_info.size() == source_indexes.size());
+		D_ASSERT(source_indexes.size() == target_indexes.size());
 	}
 	StructBoundCastData(vector<BoundCastInfo> child_casts, LogicalType target_p)
 	    : child_cast_info(std::move(child_casts)), target(std::move(target_p)) {
 		for (idx_t i = 0; i < child_cast_info.size(); i++) {
-			child_member_map.push_back(i);
+			source_indexes.push_back(i);
+			target_indexes.push_back(i);
 		}
 	}
 
 	vector<BoundCastInfo> child_cast_info;
 	LogicalType target;
-	vector<idx_t> child_member_map;
+	vector<idx_t> source_indexes;
+	vector<idx_t> target_indexes;
+	vector<idx_t> target_null_indexes;
 
 	static unique_ptr<BoundCastData> BindStructToStructCast(BindCastInput &input, const LogicalType &source,
 	                                                        const LogicalType &target);
@@ -74,7 +80,8 @@ public:
 		for (auto &info : child_cast_info) {
 			copy_info.push_back(info.Copy());
 		}
-		return make_uniq<StructBoundCastData>(std::move(copy_info), target, child_member_map);
+		return make_uniq<StructBoundCastData>(std::move(copy_info), target, source_indexes, target_indexes,
+		                                      target_null_indexes);
 	}
 };
 

package/src/duckdb/src/include/duckdb/function/compression/compression.hpp

@@ -63,4 +63,19 @@ struct FSSTFun {
 	static bool TypeIsSupported(const PhysicalType physical_type);
 };
 
+struct ZSTDFun {
+	static CompressionFunction GetFunction(PhysicalType type);
+	static bool TypeIsSupported(PhysicalType type);
+};
+
+struct RoaringCompressionFun {
+	static CompressionFunction GetFunction(PhysicalType type);
+	static bool TypeIsSupported(const PhysicalType physical_type);
+};
+
+struct EmptyValidityCompressionFun {
+	static CompressionFunction GetFunction(PhysicalType type);
+	static bool TypeIsSupported(const PhysicalType physical_type);
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/compression_function.hpp

@@ -19,9 +19,10 @@
 namespace duckdb {
 class DatabaseInstance;
 class ColumnData;
-class ColumnDataCheckpointer;
+struct ColumnDataCheckpointData;
 class ColumnSegment;
 class SegmentStatistics;
+class TableFilter;
 struct ColumnSegmentState;
 
 struct ColumnFetchState;
@@ -95,6 +96,11 @@ struct CompressedSegmentState {
 		return "";
 	} // LCOV_EXCL_STOP
 
+	//! Get the block ids of additional pages created by the segment
+	virtual vector<block_id_t> GetAdditionalBlocks() const { // LCOV_EXCL_START
+		return vector<block_id_t>();
+	} // LCOV_EXCL_STOP
+
 	template <class TARGET>
 	TARGET &Cast() {
 		DynamicCastCheck<TARGET>(this);
@@ -146,7 +152,7 @@ typedef idx_t (*compression_final_analyze_t)(AnalyzeState &state);
 //===--------------------------------------------------------------------===//
 // Compress
 //===--------------------------------------------------------------------===//
-typedef unique_ptr<CompressionState> (*compression_init_compression_t)(ColumnDataCheckpointer &checkpointer,
+typedef unique_ptr<CompressionState> (*compression_init_compression_t)(ColumnDataCheckpointData &checkpoint_data,
                                                                        unique_ptr<AnalyzeState> state);
 typedef void (*compression_compress_data_t)(CompressionState &state, Vector &scan_vector, idx_t count);
 typedef void (*compression_compress_finalize_t)(CompressionState &state);
@@ -163,6 +169,12 @@ typedef void (*compression_scan_vector_t)(ColumnSegment &segment, ColumnScanStat
 //! Function prototype used for reading an arbitrary ('scan_count') number of values
 typedef void (*compression_scan_partial_t)(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
                                            Vector &result, idx_t result_offset);
+//! Function prototype used for reading a subset of the values of a vector indicated by a selection vector
+typedef void (*compression_select_t)(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result,
+                                     const SelectionVector &sel, idx_t sel_count);
+//! Function prototype used for applying a filter to a vector while scanning that vector
+typedef void (*compression_filter_t)(ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result,
+                                     SelectionVector &sel, idx_t &sel_count, const TableFilter &filter);
 //! Function prototype used for reading a single value
 typedef void (*compression_fetch_row_t)(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
                                         idx_t result_idx);
@@ -191,6 +203,8 @@ typedef unique_ptr<ColumnSegmentState> (*compression_deserialize_state_t)(Deseri
 //! Function prototype for cleaning up the segment state when the column data is dropped
 typedef void (*compression_cleanup_state_t)(ColumnSegment &segment);
 
+enum class CompressionValidity : uint8_t { REQUIRES_VALIDITY, NO_VALIDITY_REQUIRED };
+
 class CompressionFunction {
 public:
 	CompressionFunction(CompressionType type, PhysicalType data_type, compression_init_analyze_t init_analyze,
@@ -206,13 +220,14 @@ public:
 	                    compression_serialize_state_t serialize_state = nullptr,
 	                    compression_deserialize_state_t deserialize_state = nullptr,
 	                    compression_cleanup_state_t cleanup_state = nullptr,
-	                    compression_init_prefetch_t init_prefetch = nullptr)
+	                    compression_init_prefetch_t init_prefetch = nullptr, compression_select_t select = nullptr,
+	                    compression_filter_t filter = nullptr)
 	    : type(type), data_type(data_type), init_analyze(init_analyze), analyze(analyze), final_analyze(final_analyze),
 	      init_compression(init_compression), compress(compress), compress_finalize(compress_finalize),
 	      init_prefetch(init_prefetch), init_scan(init_scan), scan_vector(scan_vector), scan_partial(scan_partial),
-	      fetch_row(fetch_row), skip(skip), init_segment(init_segment), init_append(init_append), append(append),
-	      finalize_append(finalize_append), revert_append(revert_append), serialize_state(serialize_state),
-	      deserialize_state(deserialize_state), cleanup_state(cleanup_state) {
+	      select(select), filter(filter), fetch_row(fetch_row), skip(skip), init_segment(init_segment),
+	      init_append(init_append), append(append), finalize_append(finalize_append), revert_append(revert_append),
+	      serialize_state(serialize_state), deserialize_state(deserialize_state), cleanup_state(cleanup_state) {
 	}
 
 	//! Compression type
@@ -251,6 +266,10 @@ public:
 	//! this can request > vector_size as well
 	//! this is used if a vector crosses segment boundaries, or for child columns of lists
 	compression_scan_partial_t scan_partial;
+	//! scan a subset of a vector
+	compression_select_t select;
+	//! Scan and apply a filter to a vector while scanning
+	compression_filter_t filter;
 	//! fetch an individual row from the compressed vector
 	//! used for index lookups
 	compression_fetch_row_t fetch_row;
@@ -280,6 +299,10 @@ public:
 	compression_deserialize_state_t deserialize_state;
 	//! Cleanup the segment state (optional)
 	compression_cleanup_state_t cleanup_state;
+
+	//! Whether the validity mask should be separately compressed
+	//! or this compression function can also be used to decompress the validity
+	CompressionValidity validity = CompressionValidity::REQUIRES_VALIDITY;
 };
 
 //! The set of compression functions

package/src/duckdb/src/include/duckdb/{core_functions → function}/create_sort_key.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/core_functions/create_sort_key.hpp
+// duckdb/function/create_sort_key.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -46,8 +46,11 @@ struct OrderModifiers {
 };
 
 struct CreateSortKeyHelpers {
+	static void CreateSortKey(DataChunk &input, const vector<OrderModifiers> &modifiers, Vector &result);
 	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 DecodeSortKey(string_t sort_key, DataChunk &result, idx_t result_idx,
+	                          const vector<OrderModifiers> &modifiers);
 	static void CreateSortKeyWithValidity(Vector &input, Vector &result, const OrderModifiers &modifiers,
 	                                      const idx_t count);
 };

package/src/duckdb/src/include/duckdb/function/encoding_function.hpp

@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/encoding_function.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/enums/compression_type.hpp"
+#include "duckdb/common/map.hpp"
+#include "duckdb/common/mutex.hpp"
+#include "duckdb/function/function.hpp"
+#include "duckdb/storage/data_pointer.hpp"
+#include "duckdb/storage/storage_info.hpp"
+
+namespace duckdb {
+
+struct DBConfig;
+
+//! Decode function, basically takes information about the decoded and the encoded buffers.
+typedef void (*encode_t)(const char *encoded_buffer, idx_t &encoded_buffer_current_position,
+                         const idx_t encoded_buffer_size, char *decoded_buffer, idx_t &decoded_buffer_current_position,
+                         const idx_t decoded_buffer_size, char *remaining_bytes_buffer, idx_t &remaining_bytes_size);
+
+class EncodingFunction {
+public:
+	EncodingFunction() : encode_function(nullptr), ratio(0), bytes_per_iteration(0) {
+	}
+
+	EncodingFunction(const string &encode_type, encode_t encode_function, const idx_t ratio,
+	                 const idx_t bytes_per_iteration)
+	    : encoding_type(encode_type), encode_function(encode_function), ratio(ratio),
+	      bytes_per_iteration(bytes_per_iteration) {
+		D_ASSERT(ratio > 0);
+		D_ASSERT(encode_function);
+		D_ASSERT(bytes_per_iteration > 0);
+	};
+
+	~EncodingFunction() {};
+
+	string GetType() const {
+		return encoding_type;
+	}
+	encode_t GetFunction() const {
+		return encode_function;
+	}
+	idx_t GetRatio() const {
+		return ratio;
+	}
+	idx_t GetBytesPerIteration() const {
+		return bytes_per_iteration;
+	}
+
+private:
+	//! The encoding type of this function (e.g., utf-8)
+	string encoding_type;
+	//! The actual encoding function
+	encode_t encode_function;
+	//! Ratio of the max size this encoded buffer could ever reach on a decoded buffer
+	idx_t ratio;
+	//! How many bytes in the decoded buffer one iteration of the encoded function can cause.
+	//! e.g., one iteration of Latin-1 to UTF-8 can generate max 2 bytes.
+	//! However, one iteration of UTF-16 to UTF-8, can generate up to 3 UTF-8 bytes.
+	idx_t bytes_per_iteration;
+};
+
+//! The set of encoding functions
+struct EncodingFunctionSet {
+	EncodingFunctionSet() {};
+	static void Initialize(DBConfig &config);
+	mutex lock;
+	case_insensitive_map_t<EncodingFunction> functions;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/function/function.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/common/unordered_set.hpp"
 #include "duckdb/main/external_dependencies.hpp"
 #include "duckdb/parser/column_definition.hpp"
+#include "duckdb/common/enums/function_errors.hpp"
 
 namespace duckdb {
 class CatalogEntry;
@@ -44,6 +45,16 @@ enum class FunctionNullHandling : uint8_t { DEFAULT_NULL_HANDLING = 0, SPECIAL_H
 //! VOLATILE                -> the result of this function might change per row (e.g. RANDOM())
 enum class FunctionStability : uint8_t { CONSISTENT = 0, VOLATILE = 1, CONSISTENT_WITHIN_QUERY = 2 };
 
+//! How to handle collations
+//! PROPAGATE_COLLATIONS        -> this function combines collation from its inputs and emits them again (default)
+//! PUSH_COMBINABLE_COLLATIONS  -> combinable collations are executed for the input arguments
+//! IGNORE_COLLATIONS           -> collations are completely ignored by the function
+enum class FunctionCollationHandling : uint8_t {
+	PROPAGATE_COLLATIONS = 0,
+	PUSH_COMBINABLE_COLLATIONS = 1,
+	IGNORE_COLLATIONS = 2
+};
+
 struct FunctionData {
 	DUCKDB_API virtual ~FunctionData();
 
@@ -150,7 +161,8 @@ public:
 	DUCKDB_API BaseScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
 	                              FunctionStability stability,
 	                              LogicalType varargs = LogicalType(LogicalTypeId::INVALID),
-	                              FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING);
+	                              FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING,
+	                              FunctionErrors errors = FunctionErrors::CANNOT_ERROR);
 	DUCKDB_API ~BaseScalarFunction() override;
 
 	//! Return type of the function
@@ -159,6 +171,15 @@ public:
 	FunctionStability stability;
 	//! How this function handles NULL values
 	FunctionNullHandling null_handling;
+	//! Whether or not this function can throw an error
+	FunctionErrors errors;
+	//! Collation handling of the function
+	FunctionCollationHandling collation_handling;
+
+	static BaseScalarFunction SetReturnsError(BaseScalarFunction &function) {
+		function.errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR;
+		return function;
+	}
 
 public:
 	DUCKDB_API hash_t Hash() const;

package/src/duckdb/src/include/duckdb/function/function_binder.hpp

@@ -21,8 +21,10 @@ namespace duckdb {
 //! The FunctionBinder class is responsible for binding functions
 class FunctionBinder {
 public:
+	DUCKDB_API explicit FunctionBinder(Binder &binder);
 	DUCKDB_API explicit FunctionBinder(ClientContext &context);
 
+	optional_ptr<Binder> binder;
 	ClientContext &context;
 
 public:
@@ -69,6 +71,7 @@ public:
 
 	DUCKDB_API static void BindSortedAggregate(ClientContext &context, BoundAggregateExpression &expr,
 	                                           const vector<unique_ptr<Expression>> &groups);
+	DUCKDB_API static void BindSortedAggregate(ClientContext &context, BoundWindowExpression &expr);
 
 private:
 	//! Cast a set of expressions to the arguments of this function

package/src/duckdb/src/include/duckdb/function/function_list.hpp

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/function_list.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb.hpp"
+
+namespace duckdb {
+
+typedef ScalarFunction (*get_scalar_function_t)();
+typedef ScalarFunctionSet (*get_scalar_function_set_t)();
+typedef AggregateFunction (*get_aggregate_function_t)();
+typedef AggregateFunctionSet (*get_aggregate_function_set_t)();
+
+struct StaticFunctionDefinition {
+	const char *name;
+	const char *parameters;
+	const char *description;
+	const char *example;
+	get_scalar_function_t get_function;
+	get_scalar_function_set_t get_function_set;
+	get_aggregate_function_t get_aggregate_function;
+	get_aggregate_function_set_t get_aggregate_function_set;
+};
+
+class Catalog;
+struct CatalogTransaction;
+
+struct FunctionList {
+	static const StaticFunctionDefinition *GetInternalFunctionList();
+	static void RegisterFunctions(Catalog &catalog, CatalogTransaction transaction);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/function/function_set.hpp

@@ -41,23 +41,29 @@ public:
 		D_ASSERT(offset < functions.size());
 		return functions[offset];
 	}
-	bool MergeFunctionSet(FunctionSet<T> new_functions) {
+	bool MergeFunctionSet(FunctionSet<T> new_functions, bool override = false) {
 		D_ASSERT(!new_functions.functions.empty());
-		bool need_rewrite_entry = false;
 		for (auto &new_func : new_functions.functions) {
-			bool can_add = true;
+			bool overwritten = false;
 			for (auto &func : functions) {
 				if (new_func.Equal(func)) {
-					can_add = false;
+					// function overload already exists
+					if (override) {
+						// override it
+						overwritten = true;
+						func = new_func;
+					} else {
+						// throw an error
+						return false;
+					}
 					break;
 				}
 			}
-			if (can_add) {
+			if (!overwritten) {
 				functions.push_back(new_func);
-				need_rewrite_entry = true;
 			}
 		}
-		return need_rewrite_entry;
+		return true;
 	}
 };
 

package/src/duckdb/src/include/duckdb/{core_functions → function}/lambda_functions.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/core_functions/lambda_functions.hpp
+// duckdb/function/lambda_functions.hpp
 //
 //
 //===----------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/function/partition_stats.hpp

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/partition_stats.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+
+//! How a table is partitioned by a given set of columns
+enum class TablePartitionInfo : uint8_t {
+	NOT_PARTITIONED,         // the table is not partitioned by the given set of columns
+	SINGLE_VALUE_PARTITIONS, // each partition has exactly one unique value (e.g. bounds = [1,1][2,2][3,3])
+	OVERLAPPING_PARTITIONS,  // the partitions overlap **only** at the boundaries (e.g. bounds = [1,2][2,3][3,4]
+	DISJOINT_PARTITIONS      // the partitions are disjoint (e.g. bounds = [1,2][3,4][5,6])
+};
+
+enum class CountType { COUNT_EXACT, COUNT_APPROXIMATE };
+
+struct PartitionStatistics {
+	PartitionStatistics();
+
+	//! The row id start
+	idx_t row_start;
+	//! The amount of rows in the partition
+	idx_t count;
+	//! Whether or not the count is exact or approximate
+	CountType count_type;
+};
+
+} // namespace duckdb