duckdb 0.9.3-dev0.0 → 0.9.3-dev12.0

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

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/common/array.hpp"
 #include "duckdb/common/vector_operations/aggregate_executor.hpp"
 #include "duckdb/function/aggregate_state.hpp"
 #include "duckdb/planner/bound_result_modifier.hpp"
@@ -15,6 +16,31 @@
 
 namespace duckdb {
 
+//! A half-open range of frame boundary values _relative to the current row_
+//! This is why they are signed values.
+struct FrameDelta {
+	FrameDelta() : begin(0), end(0) {};
+	FrameDelta(int64_t begin, int64_t end) : begin(begin), end(end) {};
+	int64_t begin = 0;
+	int64_t end = 0;
+};
+
+//! The half-open ranges of frame boundary values relative to the current row
+using FrameStats = array<FrameDelta, 2>;
+
+//! The partition data for custom window functions
+struct WindowPartitionInput {
+	WindowPartitionInput(const Vector inputs[], idx_t input_count, idx_t count, const ValidityMask &filter_mask,
+	                     const FrameStats &stats)
+	    : inputs(inputs), input_count(input_count), count(count), filter_mask(filter_mask), stats(stats) {
+	}
+	const Vector *inputs;
+	idx_t input_count;
+	idx_t count;
+	const ValidityMask &filter_mask;
+	const FrameStats stats;
+};
+
 //! The type used for sizing hashed aggregate function states
 typedef idx_t (*aggregate_size_t)();
 //! The type used for initializing hashed aggregate function states
@@ -40,11 +66,14 @@ typedef void (*aggregate_destructor_t)(Vector &state, AggregateInputData &aggr_i
 typedef void (*aggregate_simple_update_t)(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
                                           data_ptr_t state, idx_t count);
 
-//! The type used for updating complex windowed aggregate functions (optional)
-typedef void (*aggregate_window_t)(Vector inputs[], const ValidityMask &filter_mask,
-                                   AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
-                                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid,
-                                   idx_t bias);
+//! The type used for computing complex/custom windowed aggregate functions (optional)
+typedef void (*aggregate_window_t)(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);
+
+//! The type used for initializing shared complex/custom windowed aggregate state (optional)
+typedef void (*aggregate_wininit_t)(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition,
+                                    data_ptr_t g_state);
 
 typedef void (*aggregate_serialize_t)(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
                                       const AggregateFunction &function);
@@ -60,7 +89,7 @@ public:
 	                  aggregate_destructor_t destructor = nullptr, aggregate_statistics_t statistics = nullptr,
 	                  aggregate_window_t window = nullptr, aggregate_serialize_t serialize = nullptr,
 	                  aggregate_deserialize_t deserialize = nullptr)
-	    : BaseScalarFunction(name, arguments, return_type, FunctionSideEffects::NO_SIDE_EFFECTS,
+	    : BaseScalarFunction(name, arguments, return_type, FunctionStability::CONSISTENT,
 	                         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),
@@ -74,7 +103,7 @@ public:
 	                  aggregate_destructor_t destructor = nullptr, aggregate_statistics_t statistics = nullptr,
 	                  aggregate_window_t window = nullptr, aggregate_serialize_t serialize = nullptr,
 	                  aggregate_deserialize_t deserialize = nullptr)
-	    : BaseScalarFunction(name, arguments, return_type, FunctionSideEffects::NO_SIDE_EFFECTS,
+	    : BaseScalarFunction(name, arguments, return_type, FunctionStability::CONSISTENT,
 	                         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),
@@ -116,8 +145,10 @@ public:
 	aggregate_finalize_t finalize;
 	//! The simple aggregate update function (may be null)
 	aggregate_simple_update_t simple_update;
-	//! The windowed aggregate frame update function (may be null)
+	//! The windowed aggregate custom function (may be null)
 	aggregate_window_t window;
+	//! The windowed aggregate custom initialization function (may be null)
+	aggregate_wininit_t window_init = nullptr;
 
 	//! The bind function (may be null)
 	bind_aggregate_function_t bind;
@@ -218,12 +249,13 @@ public:
 	}
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void UnaryWindow(Vector inputs[], const ValidityMask &filter_mask, AggregateInputData &aggr_input_data,
-	                        idx_t input_count, data_ptr_t state, const FrameBounds &frame, const FrameBounds &prev,
-	                        Vector &result, idx_t rid, idx_t bias) {
-		D_ASSERT(input_count == 1);
-		AggregateExecutor::UnaryWindow<STATE, INPUT_TYPE, RESULT_TYPE, OP>(inputs[0], filter_mask, aggr_input_data,
-		                                                                   state, frame, prev, result, rid, bias);
+	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>

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

@@ -17,15 +17,19 @@ 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 combiner needs to preserve the source
+enum class AggregateCombineType : uint8_t { PRESERVE_INPUT = 1, ALLOW_DESTRUCTIVE = 2 };
 
 class BoundAggregateExpression;
 
 struct AggregateInputData {
-	AggregateInputData(optional_ptr<FunctionData> bind_data_p, ArenaAllocator &allocator_p)
-	    : bind_data(bind_data_p), allocator(allocator_p) {
+	AggregateInputData(optional_ptr<FunctionData> bind_data_p, ArenaAllocator &allocator_p,
+	                   AggregateCombineType combine_type_p = AggregateCombineType::PRESERVE_INPUT)
+	    : bind_data(bind_data_p), allocator(allocator_p), combine_type(combine_type_p) {
 	}
 	optional_ptr<FunctionData> bind_data;
 	ArenaAllocator &allocator;
+	AggregateCombineType combine_type;
 };
 
 struct AggregateUnaryInput {

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

@@ -52,6 +52,7 @@ private:
 	void RegisterReadFunctions();
 	void RegisterTableFunctions();
 	void RegisterArrowFunctions();
+	void RegisterSnifferFunction();
 
 	// aggregates
 	void RegisterDistributiveAggregates();

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

@@ -27,17 +27,42 @@ public:
 	}
 };
 
+struct ArrayBoundCastData : public BoundCastData {
+	explicit ArrayBoundCastData(BoundCastInfo child_cast) : child_cast_info(std::move(child_cast)) {
+	}
+
+	BoundCastInfo child_cast_info;
+
+	static unique_ptr<BoundCastData> BindArrayToArrayCast(BindCastInput &input, const LogicalType &source,
+	                                                      const LogicalType &target);
+	static unique_ptr<FunctionLocalState> InitArrayLocalState(CastLocalStateParameters &parameters);
+
+public:
+	unique_ptr<BoundCastData> Copy() const override {
+		return make_uniq<ArrayBoundCastData>(child_cast_info.Copy());
+	}
+};
+
 struct ListCast {
 	static bool ListToListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
 };
 
 struct StructBoundCastData : public BoundCastData {
+	StructBoundCastData(vector<BoundCastInfo> child_casts, LogicalType target_p, vector<idx_t> child_member_map_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());
+	}
 	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);
+		}
 	}
 
 	vector<BoundCastInfo> child_cast_info;
 	LogicalType target;
+	vector<idx_t> child_member_map;
 
 	static unique_ptr<BoundCastData> BindStructToStructCast(BindCastInput &input, const LogicalType &source,
 	                                                        const LogicalType &target);
@@ -49,7 +74,7 @@ public:
 		for (auto &info : child_cast_info) {
 			copy_info.push_back(info.Copy());
 		}
-		return make_uniq<StructBoundCastData>(std::move(copy_info), target);
+		return make_uniq<StructBoundCastData>(std::move(copy_info), target, child_member_map);
 	}
 };
 

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

@@ -13,6 +13,7 @@
 namespace duckdb {
 struct MapCastInfo;
 struct MapCastNode;
+struct DBConfig;
 
 typedef BoundCastInfo (*bind_cast_function_t)(BindCastInput &input, const LogicalType &source,
                                               const LogicalType &target);
@@ -38,6 +39,7 @@ struct BindCastFunction {
 class CastFunctionSet {
 public:
 	CastFunctionSet();
+	CastFunctionSet(DBConfig &config);
 
 public:
 	DUCKDB_API static CastFunctionSet &Get(ClientContext &context);
@@ -57,6 +59,7 @@ public:
 	                                     bind_cast_function_t bind, int64_t implicit_cast_cost = -1);
 
 private:
+	optional_ptr<DBConfig> config;
 	vector<BindCastFunction> bind_functions;
 	//! If any custom cast functions have been defined using RegisterCastFunction, this holds the map
 	optional_ptr<MapCastInfo> map_info;

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

@@ -135,6 +135,7 @@ private:
 	static BoundCastInfo EnumCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo IntervalCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo ListCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo ArrayCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo NumericCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo MapCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo PointerCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);

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

@@ -206,9 +206,15 @@ struct VectorStringToList {
 	                                       const SelectionVector *sel);
 };
 
+struct VectorStringToArray {
+	static bool StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask, Vector &result,
+	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
+	                                       const SelectionVector *sel);
+};
+
 struct VectorStringToStruct {
 	static bool SplitStruct(const string_t &input, vector<unique_ptr<Vector>> &varchar_vectors, idx_t &row_idx,
-	                        string_map_t<idx_t> &child_names, vector<ValidityMask *> &child_masks);
+	                        string_map_t<idx_t> &child_names, vector<reference<ValidityMask>> &child_masks);
 	static bool StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask, Vector &result,
 	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
 	                                       const SelectionVector *sel);

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

@@ -48,6 +48,16 @@ struct PatasCompressionFun {
 	static bool TypeIsSupported(PhysicalType type);
 };
 
+struct AlpCompressionFun {
+	static CompressionFunction GetFunction(PhysicalType type);
+	static bool TypeIsSupported(PhysicalType type);
+};
+
+struct AlpRDCompressionFun {
+	static CompressionFunction GetFunction(PhysicalType type);
+	static bool TypeIsSupported(PhysicalType type);
+};
+
 struct FSSTFun {
 	static CompressionFunction GetFunction(PhysicalType type);
 	static bool TypeIsSupported(PhysicalType type);

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

@@ -68,10 +68,19 @@ struct PreparedBatchData {
 	}
 };
 
+struct CopyFunctionBindInput {
+	const CopyInfo &info;
+
+	string file_extension;
+
+	CopyFunctionBindInput(const CopyInfo &info_p) : info(info_p) {
+	}
+};
+
 enum class CopyFunctionExecutionMode { REGULAR_COPY_TO_FILE, PARALLEL_COPY_TO_FILE, BATCH_COPY_TO_FILE };
 
 typedef BoundStatement (*copy_to_plan_t)(Binder &binder, CopyStatement &stmt);
-typedef unique_ptr<FunctionData> (*copy_to_bind_t)(ClientContext &context, const CopyInfo &info,
+typedef unique_ptr<FunctionData> (*copy_to_bind_t)(ClientContext &context, CopyFunctionBindInput &input,
                                                    const vector<string> &names, const vector<LogicalType> &sql_types);
 typedef unique_ptr<LocalFunctionData> (*copy_to_initialize_local_t)(ExecutionContext &context, FunctionData &bind_data);
 typedef unique_ptr<GlobalFunctionData> (*copy_to_initialize_global_t)(ClientContext &context, FunctionData &bind_data,
@@ -99,18 +108,20 @@ typedef void (*copy_flush_batch_t)(ClientContext &context, FunctionData &bind_da
                                    PreparedBatchData &batch);
 typedef idx_t (*copy_desired_batch_size_t)(ClientContext &context, FunctionData &bind_data);
 
+typedef idx_t (*copy_file_size_bytes_t)(GlobalFunctionData &gstate);
+
 enum class CopyTypeSupport { SUPPORTED, LOSSY, UNSUPPORTED };
 
 typedef CopyTypeSupport (*copy_supports_type_t)(const LogicalType &type);
 
 class CopyFunction : public Function {
 public:
-	explicit CopyFunction(string name)
+	explicit CopyFunction(const string &name)
 	    : Function(name), plan(nullptr), copy_to_bind(nullptr), copy_to_initialize_local(nullptr),
 	      copy_to_initialize_global(nullptr), copy_to_sink(nullptr), copy_to_combine(nullptr),
 	      copy_to_finalize(nullptr), execution_mode(nullptr), prepare_batch(nullptr), flush_batch(nullptr),
-	      desired_batch_size(nullptr), serialize(nullptr), deserialize(nullptr), supports_type(nullptr),
-	      copy_from_bind(nullptr) {
+	      desired_batch_size(nullptr), file_size_bytes(nullptr), serialize(nullptr), deserialize(nullptr),
+	      supports_type(nullptr), copy_from_bind(nullptr) {
 	}
 
 	//! Plan rewrite copy function
@@ -127,6 +138,7 @@ public:
 	copy_prepare_batch_t prepare_batch;
 	copy_flush_batch_t flush_batch;
 	copy_desired_batch_size_t desired_batch_size;
+	copy_file_size_bytes_t file_size_bytes;
 
 	copy_to_serialize_t serialize;
 	copy_to_deserialize_t deserialize;

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

@@ -37,7 +37,12 @@ struct PragmaInfo;
 
 //! The default null handling is NULL in, NULL out
 enum class FunctionNullHandling : uint8_t { DEFAULT_NULL_HANDLING = 0, SPECIAL_HANDLING = 1 };
-enum class FunctionSideEffects : uint8_t { NO_SIDE_EFFECTS = 0, HAS_SIDE_EFFECTS = 1 };
+//! The stability of the function, used by the optimizer
+//! CONSISTENT              -> this function always returns the same result when given the same input, no variance
+//! CONSISTENT_WITHIN_QUERY -> this function returns the same result WITHIN the same query/transaction
+//!                            but the result might change across queries (e.g. NOW(), CURRENT_TIME)
+//! 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 };
 
 struct FunctionData {
 	DUCKDB_API virtual ~FunctionData();
@@ -96,10 +101,11 @@ public:
 
 public:
 	//! Returns the formatted string name(arg1, arg2, ...)
-	DUCKDB_API static string CallToString(const string &name, const vector<LogicalType> &arguments);
+	DUCKDB_API static string CallToString(const string &name, const vector<LogicalType> &arguments,
+	                                      const LogicalType &varargs = LogicalType::INVALID);
 	//! Returns the formatted string name(arg1, arg2..) -> return_type
 	DUCKDB_API static string CallToString(const string &name, const vector<LogicalType> &arguments,
-	                                      const LogicalType &return_type);
+	                                      const LogicalType &varargs, const LogicalType &return_type);
 	//! Returns the formatted string name(arg1, arg2.., np1=a, np2=b, ...)
 	DUCKDB_API static string CallToString(const string &name, const vector<LogicalType> &arguments,
 	                                      const named_parameter_type_map_t &named_parameters);
@@ -147,16 +153,15 @@ public:
 class BaseScalarFunction : public SimpleFunction {
 public:
 	DUCKDB_API BaseScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
-	                              FunctionSideEffects side_effects,
+	                              FunctionStability stability,
 	                              LogicalType varargs = LogicalType(LogicalTypeId::INVALID),
 	                              FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING);
 	DUCKDB_API ~BaseScalarFunction() override;
 
 	//! Return type of the function
 	LogicalType return_type;
-	//! Whether or not the function has side effects (e.g. sequence increments, random() functions, NOW()). Functions
-	//! with side-effects cannot be constant-folded.
-	FunctionSideEffects side_effects;
+	//! The stability of the function (see FunctionStability enum for more info)
+	FunctionStability stability;
 	//! How this function handles NULL values
 	FunctionNullHandling null_handling;
 

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

@@ -13,6 +13,8 @@
 #include "duckdb/function/scalar_function.hpp"
 #include "duckdb/function/aggregate_function.hpp"
 #include "duckdb/function/function_set.hpp"
+#include "duckdb/common/exception/binder_exception.hpp"
+#include "duckdb/common/error_data.hpp"
 
 namespace duckdb {
 
@@ -27,29 +29,30 @@ public:
 	//! Bind a scalar function from the set of functions and input arguments. Returns the index of the chosen function,
 	//! returns DConstants::INVALID_INDEX and sets error if none could be found
 	DUCKDB_API idx_t BindFunction(const string &name, ScalarFunctionSet &functions,
-	                              const vector<LogicalType> &arguments, string &error);
+	                              const vector<LogicalType> &arguments, ErrorData &error);
 	DUCKDB_API idx_t BindFunction(const string &name, ScalarFunctionSet &functions,
-	                              vector<unique_ptr<Expression>> &arguments, string &error);
+	                              vector<unique_ptr<Expression>> &arguments, ErrorData &error);
 	//! Bind an aggregate function from the set of functions and input arguments. Returns the index of the chosen
 	//! function, returns DConstants::INVALID_INDEX and sets error if none could be found
 	DUCKDB_API idx_t BindFunction(const string &name, AggregateFunctionSet &functions,
-	                              const vector<LogicalType> &arguments, string &error);
+	                              const vector<LogicalType> &arguments, ErrorData &error);
 	DUCKDB_API idx_t BindFunction(const string &name, AggregateFunctionSet &functions,
-	                              vector<unique_ptr<Expression>> &arguments, string &error);
+	                              vector<unique_ptr<Expression>> &arguments, ErrorData &error);
 	//! Bind a table function from the set of functions and input arguments. Returns the index of the chosen
 	//! function, returns DConstants::INVALID_INDEX and sets error if none could be found
 	DUCKDB_API idx_t BindFunction(const string &name, TableFunctionSet &functions, const vector<LogicalType> &arguments,
-	                              string &error);
+	                              ErrorData &error);
 	DUCKDB_API idx_t BindFunction(const string &name, TableFunctionSet &functions,
-	                              vector<unique_ptr<Expression>> &arguments, string &error);
+	                              vector<unique_ptr<Expression>> &arguments, ErrorData &error);
 	//! Bind a pragma function from the set of functions and input arguments
-	DUCKDB_API idx_t BindFunction(const string &name, PragmaFunctionSet &functions, PragmaInfo &info, string &error);
+	DUCKDB_API idx_t BindFunction(const string &name, PragmaFunctionSet &functions, vector<Value> &parameters,
+	                              ErrorData &error);
 
 	DUCKDB_API unique_ptr<Expression> BindScalarFunction(const string &schema, const string &name,
-	                                                     vector<unique_ptr<Expression>> children, string &error,
+	                                                     vector<unique_ptr<Expression>> children, ErrorData &error,
 	                                                     bool is_operator = false, Binder *binder = nullptr);
 	DUCKDB_API unique_ptr<Expression> BindScalarFunction(ScalarFunctionCatalogEntry &function,
-	                                                     vector<unique_ptr<Expression>> children, string &error,
+	                                                     vector<unique_ptr<Expression>> children, ErrorData &error,
 	                                                     bool is_operator = false, Binder *binder = nullptr);
 
 	DUCKDB_API unique_ptr<BoundFunctionExpression> BindScalarFunction(ScalarFunction bound_function,
@@ -72,15 +75,15 @@ private:
 
 	template <class T>
 	vector<idx_t> BindFunctionsFromArguments(const string &name, FunctionSet<T> &functions,
-	                                         const vector<LogicalType> &arguments, string &error);
+	                                         const vector<LogicalType> &arguments, ErrorData &error);
 
 	template <class T>
 	idx_t MultipleCandidateException(const string &name, FunctionSet<T> &functions, vector<idx_t> &candidate_functions,
-	                                 const vector<LogicalType> &arguments, string &error);
+	                                 const vector<LogicalType> &arguments, ErrorData &error);
 
 	template <class T>
 	idx_t BindFunctionFromArguments(const string &name, FunctionSet<T> &functions, const vector<LogicalType> &arguments,
-	                                string &error);
+	                                ErrorData &error);
 
 	vector<LogicalType> GetLogicalTypesFromExpressions(vector<unique_ptr<Expression>> &arguments);
 };

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

@@ -86,9 +86,10 @@ public:
 		} else if (function.bind) {
 			try {
 				bind_data = function.bind(context, function, children);
-			} catch (Exception &ex) {
-				// FIXME
-				throw SerializationException("Error during bind of function in deserialization: %s", ex.what());
+			} catch (std::exception &ex) {
+				ErrorData error(ex);
+				throw SerializationException("Error during bind of function in deserialization: %s",
+				                             error.RawMessage());
 			}
 		}
 		function.return_type = std::move(return_type);

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

@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include "duckdb/parser/query_node.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/query_node.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
 
 namespace duckdb {
 
@@ -28,7 +28,7 @@ public:
 	//! The positional parameters
 	vector<unique_ptr<ParsedExpression>> parameters;
 	//! The default parameters and their associated values
-	unordered_map<string, unique_ptr<ParsedExpression>> default_parameters;
+	case_insensitive_map_t<unique_ptr<ParsedExpression>> default_parameters;
 
 public:
 	virtual ~MacroFunction() {

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

@@ -21,6 +21,9 @@ struct PragmaFunctions {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-string PragmaShow(ClientContext &context, const FunctionParameters &parameters);
+string PragmaShowTables();
+string PragmaShowTablesExpanded();
+string PragmaShowDatabases();
+string PragmaShow(const string &table_name);
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/scalar/list/contains_or_position.hpp

@@ -113,6 +113,9 @@ void ListContainsOrPosition(DataChunk &args, Vector &result) {
 	case PhysicalType::UINT64:
 		TemplatedContainsOrPosition<uint64_t, T, OP, LIST_ACCESSOR>(args, result);
 		break;
+	case PhysicalType::UINT128:
+		TemplatedContainsOrPosition<uhugeint_t, T, OP, LIST_ACCESSOR>(args, result);
+		break;
 	case PhysicalType::FLOAT:
 		TemplatedContainsOrPosition<float, T, OP, LIST_ACCESSOR>(args, result);
 		break;

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

@@ -49,6 +49,10 @@ struct PositionFunctor {
 	}
 };
 
+struct MapUtil {
+	static void ReinterpretMap(Vector &target, Vector &other, idx_t count);
+};
+
 struct VariableReturnBindData : public FunctionData {
 	LogicalType stype;
 
@@ -99,13 +103,29 @@ struct ListPositionFun {
 };
 
 struct ListResizeFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListZipFun {
 	static ScalarFunction GetFunction();
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-struct StructExtractFun {
+struct ListSelectFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListWhereFun {
 	static ScalarFunction GetFunction();
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct StructExtractFun {
+	static ScalarFunction KeyExtractFunction();
+	static ScalarFunction IndexExtractFunction();
+	static ScalarFunctionSet GetFunctions();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 } // namespace duckdb

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

@@ -8,12 +8,34 @@
 
 #pragma once
 
+#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
 #include "duckdb/function/scalar_function.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/function/built_in_functions.hpp"
 
 namespace duckdb {
 
+struct NextvalBindData : public FunctionData {
+	explicit NextvalBindData(optional_ptr<SequenceCatalogEntry> sequence)
+	    : sequence(sequence), create_info(sequence ? sequence->GetInfo() : nullptr) {
+	}
+
+	//! The sequence to use for the nextval computation; only if the sequence is a constant
+	optional_ptr<SequenceCatalogEntry> sequence;
+
+	//! The CreateInfo for the above sequence, if it exists
+	unique_ptr<CreateInfo> create_info;
+
+	unique_ptr<FunctionData> Copy() const override {
+		return make_uniq<NextvalBindData>(sequence);
+	}
+
+	bool Equals(const FunctionData &other_p) const override {
+		auto &other = other_p.Cast<NextvalBindData>();
+		return sequence == other.sequence;
+	}
+};
+
 struct NextvalFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

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

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/function/scalar/strftime.hpp
+// duckdb/function/scalar/strftime_format.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -53,7 +53,13 @@ enum class StrTimeSpecifier : uint8_t {
 	    29, // %c - Locale’s appropriate date and time representation. (Mon Sep 30 07:06:05 2013)
 	LOCALE_APPROPRIATE_DATE = 30, // %x - Locale’s appropriate date representation. (09/30/13)
 	LOCALE_APPROPRIATE_TIME = 31, // %X - Locale’s appropriate time representation. (07:06:05)
-	NANOSECOND_PADDED = 32 // %n - Nanosecond as a decimal number, zero-padded on the left. (000000000 - 999999999)
+	NANOSECOND_PADDED = 32, // %n - Nanosecond as a decimal number, zero-padded on the left. (000000000 - 999999999)
+	// Python 3.6 ISO directives https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes
+	YEAR_ISO =
+	    33, // %G - ISO 8601 year with century representing the year that contains the greater part of the ISO week
+	WEEKDAY_ISO = 34,     // %u - ISO 8601 weekday as a decimal number where 1 is Monday (1..7)
+	WEEK_NUMBER_ISO = 35, // %V - ISO 8601 week as a decimal number with Monday as the first day of the week.
+	                      // Week 01 is the week containing Jan 4. (01..53)
 };
 
 struct StrTimeFormat {
@@ -66,6 +72,8 @@ public:
 	inline bool HasFormatSpecifier(StrTimeSpecifier s) const {
 		return std::find(specifiers.begin(), specifiers.end(), s) != specifiers.end();
 	}
+	//! If the string format is empty
+	DUCKDB_API bool Empty() const;
 
 	//! The full format specifier, for error messages
 	string format_specifier;
@@ -131,6 +139,9 @@ public:
 		string error_message;
 		idx_t error_position = DConstants::INVALID_INDEX;
 
+		bool is_special;
+		date_t special;
+
 		date_t ToDate();
 		timestamp_t ToTimestamp();
 
@@ -141,6 +152,9 @@ public:
 	};
 
 public:
+	bool operator!=(const StrpTimeFormat &other) const {
+		return format_specifier != other.format_specifier;
+	}
 	DUCKDB_API static ParseResult Parse(const string &format, const string &text);
 
 	DUCKDB_API bool Parse(string_t str, ParseResult &result) const;