duckdb 1.3.4 → 1.4.0

package/.github/workflows/NodeJS.yml

@@ -41,27 +41,21 @@ jobs:
     name: node.js Linux
     runs-on: ubuntu-22.04
     needs: set-up-npm
-    continue-on-error: ${{ matrix.node != '18' && matrix.node != '20' && matrix.node != '21' }}
+    continue-on-error: ${{matrix.node != '20' }}
     env:
       TARGET_ARCH: ${{ matrix.target_arch }}
       DUCKDB_NODE_BUILD_CACHE: 0
     strategy:
       matrix:
         # node.js current support policy to be found at https://github.com/duckdb/duckdb-node/tree/main/#Supported-Node-versions
-        node: [ '18', '20', '22', '23', '24']
+        node: ['20', '22', '24']
         target_arch: [ x64, arm64 ]
         isRelease:
           - ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
         exclude:
-          - isRelease: false
-            node: 18
-            target_arch: arm64
           - isRelease: false
             node: 20
             target_arch: arm64
-          - isRelease: false
-            node: 21
-            target_arch: arm64
 
     steps:
       - uses: actions/checkout@v3
@@ -109,17 +103,13 @@ jobs:
     name: node.js OSX arm64
     runs-on: macos-14
     needs: set-up-npm
-    continue-on-error: ${{ matrix.node != '18' && matrix.node != '20' && matrix.node != '21' }}
+    continue-on-error: ${{ matrix.node != '20'  }}
     strategy:
       matrix:
         target_arch: [ arm64 ]
-        node: [ '18', '20', '22', '23', '24']
+        node: ['20', '22', '24']
         isRelease:
           - ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
-        exclude:
-          - isRelease: false
-            node: 19
-        # these older versions of NodeJS don't have M1 support
 
     env:
       TARGET_ARCH: ${{ matrix.target_arch }}
@@ -160,11 +150,11 @@ jobs:
     name: node.js OSX x64
     runs-on: macos-13
     needs: set-up-npm
-    continue-on-error: ${{ matrix.node != '18' && matrix.node != '20' && matrix.node != '21' }}
+    continue-on-error: ${{  matrix.node != '20' }}
     strategy:
       matrix:
         target_arch: [ x64 ]
-        node: [ '18', '20', '22', '23', '24']
+        node: ['20', '22', '24']
         isRelease:
           - ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
     env:
@@ -206,18 +196,16 @@ jobs:
     name: node.js Windows
     runs-on: windows-latest
     needs: set-up-npm
-    continue-on-error: ${{ matrix.node != '18' && matrix.node != '20' && matrix.node != '21' }}
+    continue-on-error: ${{ matrix.node != '20' }}
     env:
       npm_config_msvs_version: 2019
 
     strategy:
       matrix:
-        node: [ '18', '20', '22', '23', '24']
+        node: ['20', '22', '24']
         isRelease:
           - ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
         exclude:
-          - isRelease: false
-            node: 18
           - isRelease: false
             node: 20
 

package/binding.gyp

@@ -27,6 +27,7 @@
                 "src/duckdb/ub_src_common_row_operations.cpp", 
                 "src/duckdb/ub_src_common_serializer.cpp", 
                 "src/duckdb/ub_src_common_sort.cpp", 
+                "src/duckdb/ub_src_common_sorting.cpp", 
                 "src/duckdb/ub_src_common_tree_renderer.cpp", 
                 "src/duckdb/ub_src_common_types.cpp", 
                 "src/duckdb/ub_src_common_types_column.cpp", 
@@ -71,6 +72,7 @@
                 "src/duckdb/ub_src_function.cpp", 
                 "src/duckdb/ub_src_function_cast.cpp", 
                 "src/duckdb/ub_src_function_cast_union.cpp", 
+                "src/duckdb/ub_src_function_cast_variant.cpp", 
                 "src/duckdb/ub_src_function_pragma.cpp", 
                 "src/duckdb/ub_src_function_scalar_compressed_materialization.cpp", 
                 "src/duckdb/ub_src_function_scalar.cpp", 
@@ -84,6 +86,7 @@
                 "src/duckdb/ub_src_function_scalar_string_regexp.cpp", 
                 "src/duckdb/ub_src_function_scalar_struct.cpp", 
                 "src/duckdb/ub_src_function_scalar_system.cpp", 
+                "src/duckdb/ub_src_function_scalar_variant.cpp", 
                 "src/duckdb/ub_src_function_table_arrow.cpp", 
                 "src/duckdb/ub_src_function_table.cpp", 
                 "src/duckdb/ub_src_function_table_system.cpp", 
@@ -99,7 +102,7 @@
                 "src/duckdb/src/main/extension/extension_helper.cpp", 
                 "src/duckdb/src/main/extension/extension_install.cpp", 
                 "src/duckdb/src/main/extension/extension_load.cpp", 
-                "src/duckdb/src/main/extension/extension_util.cpp", 
+                "src/duckdb/src/main/extension/extension_loader.cpp", 
                 "src/duckdb/ub_src_main_http.cpp", 
                 "src/duckdb/ub_src_main_relation.cpp", 
                 "src/duckdb/ub_src_main_secret.cpp", 
@@ -152,6 +155,7 @@
                 "src/duckdb/ub_src_transaction.cpp", 
                 "src/duckdb/src/verification/copied_statement_verifier.cpp", 
                 "src/duckdb/src/verification/deserialized_statement_verifier.cpp", 
+                "src/duckdb/src/verification/explain_statement_verifier.cpp", 
                 "src/duckdb/src/verification/external_statement_verifier.cpp", 
                 "src/duckdb/src/verification/fetch_row_verifier.cpp", 
                 "src/duckdb/src/verification/no_operator_caching_verifier.cpp", 
@@ -273,6 +277,7 @@
                 "src/duckdb/extension/parquet/column_reader.cpp", 
                 "src/duckdb/extension/parquet/parquet_writer.cpp", 
                 "src/duckdb/ub_extension_parquet_reader.cpp", 
+                "src/duckdb/ub_extension_parquet_reader_variant.cpp", 
                 "src/duckdb/ub_extension_parquet_decoder.cpp", 
                 "src/duckdb/ub_extension_parquet_writer.cpp", 
                 "src/duckdb/third_party/parquet/parquet_types.cpp", 
@@ -387,11 +392,14 @@
                 "src/duckdb/third_party/mbedtls/library", 
                 "src/duckdb/third_party/miniz", 
                 "src/duckdb/third_party/pcg", 
+                "src/duckdb/third_party/pdqsort", 
                 "src/duckdb/third_party/re2", 
+                "src/duckdb/third_party/ska_sort", 
                 "src/duckdb/third_party/skiplist", 
                 "src/duckdb/third_party/tdigest", 
                 "src/duckdb/third_party/utf8proc", 
                 "src/duckdb/third_party/utf8proc/include", 
+                "src/duckdb/third_party/vergesort", 
                 "src/duckdb/third_party/yyjson/include", 
                 "src/duckdb/third_party/zstd/include", 
                 "src/duckdb/extension/parquet/include", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "1.3.4",
+  "version": "1.4.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/connection.cpp

@@ -375,7 +375,7 @@ struct ExecTask : public Task {
 					break;
 				}
 			}
-		} catch (duckdb::ParserException &e) {
+		} catch (duckdb::Exception &e) {
 			success = false;
 			error = duckdb::ErrorData(e);
 			return;

package/src/duckdb/extension/core_functions/aggregate/algebraic/avg.cpp

@@ -8,6 +8,8 @@
 
 namespace duckdb {
 
+namespace {
+
 template <class T>
 struct AvgState {
 	uint64_t count;
@@ -275,6 +277,8 @@ unique_ptr<FunctionData> BindDecimalAvg(ClientContext &context, AggregateFunctio
 	    Hugeint::Cast<double>(Hugeint::POWERS_OF_TEN[DecimalType::GetScale(decimal_type)]));
 }
 
+} // namespace
+
 AggregateFunctionSet AvgFun::GetFunctions() {
 	AggregateFunctionSet avg;
 

package/src/duckdb/extension/core_functions/aggregate/distributive/approx_count.cpp

@@ -11,6 +11,8 @@ namespace duckdb {
 // Algorithms from
 // "New cardinality estimation algorithms for HyperLogLog sketches"
 // Otmar Ertl, arXiv:1702.01284
+namespace {
+
 struct ApproxDistinctCountState {
 	HyperLogLog hll;
 };
@@ -36,8 +38,8 @@ struct ApproxCountDistinctFunction {
 	}
 };
 
-static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count,
-                                                    data_ptr_t state, idx_t count) {
+void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count, data_ptr_t state,
+                                             idx_t count) {
 	D_ASSERT(input_count == 1);
 	auto &input = inputs[0];
 
@@ -51,8 +53,8 @@ static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], AggregateIn
 	agg_state->hll.Update(input, hash_vec, count);
 }
 
-static void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count,
-                                              Vector &state_vector, idx_t count) {
+void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector,
+                                       idx_t count) {
 	D_ASSERT(input_count == 1);
 	auto &input = inputs[0];
 	UnifiedVectorFormat idata;
@@ -92,6 +94,8 @@ AggregateFunction GetApproxCountDistinctFunction(const LogicalType &input_type)
 	return fun;
 }
 
+} // namespace
+
 AggregateFunction ApproxCountDistinctFun::GetFunction() {
 	return GetApproxCountDistinctFunction(LogicalType::ANY);
 }

package/src/duckdb/extension/core_functions/aggregate/distributive/arg_min_max.cpp

@@ -12,6 +12,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct ArgMinMaxStateBase {
 	ArgMinMaxStateBase() : is_initialized(false), arg_null(false) {
 	}
@@ -346,7 +348,7 @@ AggregateFunction GetVectorArgMinMaxFunctionBy(const LogicalType &by_type, const
 }
 #endif
 
-static const vector<LogicalType> ArgMaxByTypes() {
+const vector<LogicalType> ArgMaxByTypes() {
 	vector<LogicalType> types = {LogicalType::INTEGER,   LogicalType::BIGINT,       LogicalType::HUGEINT,
 	                             LogicalType::DOUBLE,    LogicalType::VARCHAR,      LogicalType::DATE,
 	                             LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ, LogicalType::BLOB};
@@ -417,7 +419,7 @@ void AddArgMinMaxFunctionBy(AggregateFunctionSet &fun, const LogicalType &type)
 }
 
 template <class OP>
-static AggregateFunction GetDecimalArgMinMaxFunction(const LogicalType &by_type, const LogicalType &type) {
+AggregateFunction GetDecimalArgMinMaxFunction(const LogicalType &by_type, const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
 #ifndef DUCKDB_SMALLER_BINARY
 	switch (type.InternalType()) {
@@ -436,8 +438,8 @@ static AggregateFunction GetDecimalArgMinMaxFunction(const LogicalType &by_type,
 }
 
 template <class OP>
-static unique_ptr<FunctionData> BindDecimalArgMinMax(ClientContext &context, AggregateFunction &function,
-                                                     vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> BindDecimalArgMinMax(ClientContext &context, AggregateFunction &function,
+                                              vector<unique_ptr<Expression>> &arguments) {
 	auto decimal_type = arguments[0]->return_type;
 	auto by_type = arguments[1]->return_type;
 
@@ -453,7 +455,7 @@ static unique_ptr<FunctionData> BindDecimalArgMinMax(ClientContext &context, Agg
 			break;
 		}
 
-		auto cast_cost = CastFunctionSet::Get(context).ImplicitCastCost(by_type, by_types[i]);
+		auto cast_cost = CastFunctionSet::ImplicitCastCost(context, by_type, by_types[i]);
 		if (cast_cost < 0) {
 			continue;
 		}
@@ -485,7 +487,7 @@ void AddGenericArgMinMaxFunction(AggregateFunctionSet &fun) {
 }
 
 template <class COMPARATOR, bool IGNORE_NULL, OrderType ORDER_TYPE>
-static void AddArgMinMaxFunctions(AggregateFunctionSet &fun) {
+void AddArgMinMaxFunctions(AggregateFunctionSet &fun) {
 	using GENERIC_VECTOR_OP = VectorArgMinMaxBase<LessThan, IGNORE_NULL, ORDER_TYPE, GenericArgMinMaxState<ORDER_TYPE>>;
 #ifndef DUCKDB_SMALLER_BINARY
 	using OP = ArgMinMaxBase<COMPARATOR, IGNORE_NULL>;
@@ -543,8 +545,8 @@ public:
 // Operation
 //------------------------------------------------------------------------------
 template <class STATE>
-static void ArgMinMaxNUpdate(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count, Vector &state_vector,
-                             idx_t count) {
+void ArgMinMaxNUpdate(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count, Vector &state_vector,
+                      idx_t count) {
 
 	auto &val_vector = inputs[0];
 	auto &arg_vector = inputs[1];
@@ -604,7 +606,7 @@ static void ArgMinMaxNUpdate(Vector inputs[], AggregateInputData &aggr_input, id
 // Bind
 //------------------------------------------------------------------------------
 template <class VAL_TYPE, class ARG_TYPE, class COMPARATOR>
-static void SpecializeArgMinMaxNFunction(AggregateFunction &function) {
+void SpecializeArgMinMaxNFunction(AggregateFunction &function) {
 	using STATE = ArgMinMaxNState<VAL_TYPE, ARG_TYPE, COMPARATOR>;
 	using OP = MinMaxNOperation;
 
@@ -618,7 +620,7 @@ static void SpecializeArgMinMaxNFunction(AggregateFunction &function) {
 }
 
 template <class VAL_TYPE, class COMPARATOR>
-static void SpecializeArgMinMaxNFunction(PhysicalType arg_type, AggregateFunction &function) {
+void SpecializeArgMinMaxNFunction(PhysicalType arg_type, AggregateFunction &function) {
 	switch (arg_type) {
 #ifndef DUCKDB_SMALLER_BINARY
 	case PhysicalType::VARCHAR:
@@ -644,7 +646,7 @@ static void SpecializeArgMinMaxNFunction(PhysicalType arg_type, AggregateFunctio
 }
 
 template <class COMPARATOR>
-static void SpecializeArgMinMaxNFunction(PhysicalType val_type, PhysicalType arg_type, AggregateFunction &function) {
+void SpecializeArgMinMaxNFunction(PhysicalType val_type, PhysicalType arg_type, AggregateFunction &function) {
 	switch (val_type) {
 #ifndef DUCKDB_SMALLER_BINARY
 	case PhysicalType::VARCHAR:
@@ -689,7 +691,7 @@ unique_ptr<FunctionData> ArgMinMaxNBind(ClientContext &context, AggregateFunctio
 }
 
 template <class COMPARATOR>
-static void AddArgMinMaxNFunction(AggregateFunctionSet &set) {
+void AddArgMinMaxNFunction(AggregateFunctionSet &set) {
 	AggregateFunction function({LogicalTypeId::ANY, LogicalTypeId::ANY, LogicalType::BIGINT},
 	                           LogicalType::LIST(LogicalType::ANY), nullptr, nullptr, nullptr, nullptr, nullptr,
 	                           nullptr, ArgMinMaxNBind<COMPARATOR>);
@@ -697,6 +699,8 @@ static void AddArgMinMaxNFunction(AggregateFunctionSet &set) {
 	return set.AddFunction(function);
 }
 
+} // namespace
+
 //------------------------------------------------------------------------------
 // Function Registration
 //------------------------------------------------------------------------------

package/src/duckdb/extension/core_functions/aggregate/distributive/bitagg.cpp

@@ -8,6 +8,8 @@
 
 namespace duckdb {
 
+namespace {
+
 template <class T>
 struct BitState {
 	using TYPE = T;
@@ -16,7 +18,7 @@ struct BitState {
 };
 
 template <class OP>
-static AggregateFunction GetBitfieldUnaryAggregate(LogicalType type) {
+AggregateFunction GetBitfieldUnaryAggregate(LogicalType type) {
 	switch (type.id()) {
 	case LogicalTypeId::TINYINT:
 		return AggregateFunction::UnaryAggregate<BitState<uint8_t>, int8_t, int8_t, OP>(type, type);
@@ -194,6 +196,8 @@ struct BitStringXorOperation : public BitStringBitwiseOperation {
 	}
 };
 
+} // namespace
+
 AggregateFunctionSet BitAndFun::GetFunctions() {
 	AggregateFunctionSet bit_and;
 	for (auto &type : LogicalType::Integral()) {

package/src/duckdb/extension/core_functions/aggregate/distributive/bitstring_agg.cpp

@@ -13,6 +13,8 @@
 
 namespace duckdb {
 
+namespace {
+
 template <class INPUT_TYPE>
 struct BitAggState {
 	bool is_set;
@@ -258,7 +260,7 @@ unique_ptr<FunctionData> BindBitstringAgg(ClientContext &context, AggregateFunct
 }
 
 template <class TYPE>
-static void BindBitString(AggregateFunctionSet &bitstring_agg, const LogicalTypeId &type) {
+void BindBitString(AggregateFunctionSet &bitstring_agg, const LogicalTypeId &type) {
 	auto function =
 	    AggregateFunction::UnaryAggregateDestructor<BitAggState<TYPE>, TYPE, string_t, BitStringAggOperation>(
 	        type, LogicalType::BIT);
@@ -309,6 +311,8 @@ void GetBitStringAggregate(const LogicalType &type, AggregateFunctionSet &bitstr
 	}
 }
 
+} // namespace
+
 AggregateFunctionSet BitstringAggFun::GetFunctions() {
 	AggregateFunctionSet bitstring_agg("bitstring_agg");
 	for (auto &type : LogicalType::Integral()) {

package/src/duckdb/extension/core_functions/aggregate/distributive/bool.cpp

@@ -6,6 +6,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct BoolState {
 	bool empty;
 	bool val;
@@ -91,6 +93,8 @@ struct BoolOrFunFunction {
 	}
 };
 
+} // namespace
+
 AggregateFunction BoolOrFun::GetFunction() {
 	auto fun = AggregateFunction::UnaryAggregate<BoolState, bool, bool, BoolOrFunFunction>(
 	    LogicalType(LogicalTypeId::BOOLEAN), LogicalType::BOOLEAN);

package/src/duckdb/extension/core_functions/aggregate/distributive/kurtosis.cpp

@@ -6,6 +6,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct KurtosisState {
 	idx_t n;
 	double sum;
@@ -98,6 +100,8 @@ struct KurtosisOperation {
 	}
 };
 
+} // namespace
+
 AggregateFunction KurtosisFun::GetFunction() {
 	auto result =
 	    AggregateFunction::UnaryAggregate<KurtosisState, double, double, KurtosisOperation<KurtosisFlagBiasCorrection>>(

package/src/duckdb/extension/core_functions/aggregate/distributive/product.cpp

@@ -6,6 +6,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct ProductState {
 	bool empty;
 	double val;
@@ -53,6 +55,8 @@ struct ProductFunction {
 	}
 };
 
+} // namespace
+
 AggregateFunction ProductFun::GetFunction() {
 	return AggregateFunction::UnaryAggregate<ProductState, double, double, ProductFunction>(
 	    LogicalType(LogicalTypeId::DOUBLE), LogicalType::DOUBLE);

package/src/duckdb/extension/core_functions/aggregate/distributive/skew.cpp

@@ -6,6 +6,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct SkewState {
 	size_t n;
 	double sum;
@@ -78,6 +80,8 @@ struct SkewnessOperation {
 	}
 };
 
+} // namespace
+
 AggregateFunction SkewnessFun::GetFunction() {
 	return AggregateFunction::UnaryAggregate<SkewState, double, double, SkewnessOperation>(LogicalType::DOUBLE,
 	                                                                                       LogicalType::DOUBLE);

package/src/duckdb/extension/core_functions/aggregate/distributive/string_agg.cpp

@@ -10,6 +10,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct StringAggState {
 	idx_t size;
 	idx_t alloc_size;
@@ -135,8 +137,8 @@ unique_ptr<FunctionData> StringAggBind(ClientContext &context, AggregateFunction
 	return make_uniq<StringAggBindData>(std::move(separator_string));
 }
 
-static void StringAggSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                               const AggregateFunction &function) {
+void StringAggSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                        const AggregateFunction &function) {
 	auto bind_data = bind_data_p->Cast<StringAggBindData>();
 	serializer.WriteProperty(100, "separator", bind_data.sep);
 }
@@ -146,6 +148,8 @@ unique_ptr<FunctionData> StringAggDeserialize(Deserializer &deserializer, Aggreg
 	return make_uniq<StringAggBindData>(std::move(sep));
 }
 
+} // namespace
+
 AggregateFunctionSet StringAggFun::GetFunctions() {
 	AggregateFunctionSet string_agg;
 	AggregateFunction string_agg_param(

package/src/duckdb/extension/core_functions/aggregate/distributive/sum.cpp

@@ -1,12 +1,15 @@
 #include "core_functions/aggregate/distributive_functions.hpp"
 #include "core_functions/aggregate/sum_helpers.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/bignum.hpp"
 #include "duckdb/common/types/decimal.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
+namespace {
+
 struct SumSetOperation {
 	template <class STATE>
 	static void Initialize(STATE &state) {
@@ -209,6 +212,65 @@ unique_ptr<FunctionData> BindDecimalSum(ClientContext &context, AggregateFunctio
 	return nullptr;
 }
 
+struct BignumState {
+	bool is_set;
+	BignumIntermediate value;
+};
+
+struct BignumOperation {
+	template <class STATE>
+	static void Initialize(STATE &state) {
+		state.is_set = false;
+	}
+
+	template <class INPUT_TYPE, class STATE, class OP>
+	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, input, unary_input);
+		}
+	}
+
+	template <class INPUT_TYPE, class STATE, class OP>
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		if (!state.is_set) {
+			state.is_set = true;
+			state.value.Initialize(unary_input.input.allocator);
+		}
+		BignumIntermediate rhs(input);
+		state.value.AddInPlace(unary_input.input.allocator, rhs);
+	}
+
+	template <class STATE, class OP>
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &input) {
+		if (!source.is_set) {
+			return;
+		}
+		if (!target.is_set) {
+			target.value = source.value;
+			target.is_set = true;
+			return;
+		}
+		target.value.AddInPlace(input.allocator, source.value);
+		target.is_set = true;
+	}
+
+	template <class TARGET_TYPE, class STATE>
+	static void Finalize(STATE &state, TARGET_TYPE &target, AggregateFinalizeData &finalize_data) {
+		if (!state.is_set) {
+			finalize_data.ReturnNull();
+		} else {
+			target = state.value.ToBignum(finalize_data.input.allocator);
+		}
+	}
+
+	static bool IgnoreNull() {
+		return true;
+	}
+};
+
+} // namespace
+
 AggregateFunctionSet SumFun::GetFunctions() {
 	AggregateFunctionSet sum;
 	// decimal
@@ -222,6 +284,8 @@ AggregateFunctionSet SumFun::GetFunctions() {
 	sum.AddFunction(GetSumAggregate(PhysicalType::INT128));
 	sum.AddFunction(AggregateFunction::UnaryAggregate<SumState<double>, double, double, NumericSumOperation>(
 	    LogicalType::DOUBLE, LogicalType::DOUBLE));
+	sum.AddFunction(AggregateFunction::UnaryAggregate<BignumState, bignum_t, bignum_t, BignumOperation>(
+	    LogicalType::BIGNUM, LogicalType::BIGNUM));
 	return sum;
 }
 

package/src/duckdb/extension/core_functions/aggregate/holistic/approx_top_k.cpp

@@ -7,6 +7,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct ApproxTopKString {
 	ApproxTopKString() : str(UINT32_C(0)), hash(0) {
 	}
@@ -313,8 +315,8 @@ struct ApproxTopKOperation {
 };
 
 template <class T = string_t, class OP = HistogramGenericFunctor>
-static void ApproxTopKUpdate(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count, Vector &state_vector,
-                             idx_t count) {
+void ApproxTopKUpdate(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count, Vector &state_vector,
+                      idx_t count) {
 	using STATE = ApproxTopKState;
 	auto &input = inputs[0];
 	UnifiedVectorFormat sdata;
@@ -339,7 +341,7 @@ static void ApproxTopKUpdate(Vector inputs[], AggregateInputData &aggr_input, id
 }
 
 template <class OP = HistogramGenericFunctor>
-static void ApproxTopKFinalize(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count, idx_t offset) {
+void ApproxTopKFinalize(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count, idx_t offset) {
 	UnifiedVectorFormat sdata;
 	state_vector.ToUnifiedFormat(count, sdata);
 	auto states = UnifiedVectorFormat::GetData<ApproxTopKState *>(sdata);
@@ -400,6 +402,8 @@ unique_ptr<FunctionData> ApproxTopKBind(ClientContext &context, AggregateFunctio
 	return nullptr;
 }
 
+} // namespace
+
 AggregateFunction ApproxTopKFun::GetFunction() {
 	using STATE = ApproxTopKState;
 	using OP = ApproxTopKOperation;

package/src/duckdb/extension/core_functions/aggregate/holistic/approximate_quantile.cpp

@@ -10,6 +10,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct ApproxQuantileState {
 	duckdb_tdigest::TDigest *h;
 	idx_t pos;
@@ -168,7 +170,7 @@ struct ApproxQuantileScalarOperation : public ApproxQuantileOperation {
 	}
 };
 
-static AggregateFunction GetApproximateQuantileAggregateFunction(const LogicalType &type) {
+AggregateFunction GetApproximateQuantileAggregateFunction(const LogicalType &type) {
 	//	Not binary comparable
 	if (type == LogicalType::TIME_TZ) {
 		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, dtime_tz_t, dtime_tz_t,
@@ -201,7 +203,7 @@ static AggregateFunction GetApproximateQuantileAggregateFunction(const LogicalTy
 	}
 }
 
-static AggregateFunction GetApproximateQuantileDecimalAggregateFunction(const LogicalType &type) {
+AggregateFunction GetApproximateQuantileDecimalAggregateFunction(const LogicalType &type) {
 	switch (type.InternalType()) {
 	case PhysicalType::INT8:
 		return GetApproximateQuantileAggregateFunction(LogicalType::TINYINT);
@@ -218,7 +220,7 @@ static AggregateFunction GetApproximateQuantileDecimalAggregateFunction(const Lo
 	}
 }
 
-static float CheckApproxQuantile(const Value &quantile_val) {
+float CheckApproxQuantile(const Value &quantile_val) {
 	if (quantile_val.IsNull()) {
 		throw BinderException("APPROXIMATE QUANTILE parameter cannot be NULL");
 	}
@@ -326,7 +328,7 @@ struct ApproxQuantileListOperation : public ApproxQuantileOperation {
 };
 
 template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-static AggregateFunction ApproxQuantileListAggregate(const LogicalType &input_type, const LogicalType &child_type) {
+AggregateFunction ApproxQuantileListAggregate(const LogicalType &input_type, const LogicalType &child_type) {
 	LogicalType result_type = LogicalType::LIST(child_type);
 	return AggregateFunction(
 	    {input_type}, result_type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
@@ -441,6 +443,7 @@ AggregateFunction GetApproxQuantileDecimalList() {
 	fun.deserialize = ApproxQuantileDecimalDeserialize;
 	return fun;
 }
+} // namespace
 
 AggregateFunctionSet ApproxQuantileFun::GetFunctions() {
 	AggregateFunctionSet approx_quantile;