duckdb 1.1.3 → 1.1.4-dev9.0

package/.github/workflows/NodeJS.yml

@@ -39,7 +39,7 @@ jobs:
 
   linux-nodejs:
     name: node.js Linux
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     needs: set-up-npm
     continue-on-error: ${{ matrix.node != '18' && matrix.node != '20' && matrix.node != '21' }}
     env:
@@ -48,21 +48,11 @@ jobs:
     strategy:
       matrix:
         # node.js current support policy to be found at https://github.com/duckdb/duckdb-node/tree/main/#Supported-Node-versions
-        node: [ '12', '14', '16', '17', '18', '19', '20', '21', '22']
+        node: [ '18', '20', '22', '23']
         target_arch: [ x64, arm64 ]
         isRelease:
           - ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
         exclude:
-          - isRelease: false
-            node: 12
-          - isRelease: false
-            node: 14
-          - isRelease: false
-            node: 16
-          - isRelease: false
-            node: 17
-          - isRelease: false
-            node: 19
           - isRelease: false
             node: 18
             target_arch: arm64
@@ -123,24 +113,12 @@ jobs:
     strategy:
       matrix:
         target_arch: [ arm64 ]
-        node: [ '16', '17', '18', '19', '20', '21', '22']
+        node: [ '18', '20', '22', '23']
         isRelease:
           - ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
         exclude:
-          - isRelease: false
-            node: 12
-          - isRelease: false
-            node: 14
-          - isRelease: false
-            node: 16
-          - isRelease: false
-            node: 17
           - isRelease: false
             node: 19
-          - target_arch: arm64
-            node: 12
-          - target_arch: arm64
-            node: 14
         # these older versions of NodeJS don't have M1 support
 
     env:
@@ -186,26 +164,9 @@ jobs:
     strategy:
       matrix:
         target_arch: [ x64 ]
-        node: [ '16', '17', '18', '19', '20', '21', '22']
+        node: [ '18', '20', '22', '23']
         isRelease:
           - ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
-        exclude:
-          - isRelease: false
-            node: 12
-          - isRelease: false
-            node: 14
-          - isRelease: false
-            node: 16
-          - isRelease: false
-            node: 17
-          - isRelease: false
-            node: 19
-          - target_arch: arm64
-            node: 12
-          - target_arch: arm64
-            node: 14
-        # these older versions of NodeJS don't have M1 support
-
     env:
       TARGET_ARCH: ${{ matrix.target_arch }}
       DUCKDB_NODE_BUILD_CACHE: 0
@@ -251,22 +212,12 @@ jobs:
 
     strategy:
       matrix:
-        node: [ '16', '17', '18', '19', '20', '21', '22' ]
+        node: [ '18', '20', '22', '23']
         isRelease:
           - ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
         exclude:
-          - isRelease: false
-            node: 12
-          - isRelease: false
-            node: 14
-          - isRelease: false
-            node: 16
-          - isRelease: false
-            node: 17
           - isRelease: false
             node: 18
-          - isRelease: false
-            node: 19
           - isRelease: false
             node: 20
 

package/binding.gyp

@@ -41,27 +41,6 @@
                 "src/duckdb/src/common/vector_operations/vector_copy.cpp", 
                 "src/duckdb/src/common/vector_operations/vector_hash.cpp", 
                 "src/duckdb/src/common/vector_operations/vector_storage.cpp", 
-                "src/duckdb/ub_src_core_functions_aggregate_algebraic.cpp", 
-                "src/duckdb/ub_src_core_functions_aggregate_distributive.cpp", 
-                "src/duckdb/ub_src_core_functions_aggregate_holistic.cpp", 
-                "src/duckdb/ub_src_core_functions_aggregate_nested.cpp", 
-                "src/duckdb/ub_src_core_functions_aggregate_regression.cpp", 
-                "src/duckdb/ub_src_core_functions.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_array.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_bit.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_blob.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_date.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_debug.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_enum.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_generic.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_list.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_map.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_math.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_operators.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_random.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_string.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_struct.cpp", 
-                "src/duckdb/ub_src_core_functions_scalar_union.cpp", 
                 "src/duckdb/ub_src_execution.cpp", 
                 "src/duckdb/ub_src_execution_expression_executor.cpp", 
                 "src/duckdb/ub_src_execution_index_art.cpp", 
@@ -69,6 +48,7 @@
                 "src/duckdb/ub_src_execution_nested_loop_join.cpp", 
                 "src/duckdb/ub_src_execution_operator_aggregate.cpp", 
                 "src/duckdb/ub_src_execution_operator_csv_scanner_buffer_manager.cpp", 
+                "src/duckdb/ub_src_execution_operator_csv_scanner_encode.cpp", 
                 "src/duckdb/ub_src_execution_operator_csv_scanner_scanner.cpp", 
                 "src/duckdb/ub_src_execution_operator_csv_scanner_sniffer.cpp", 
                 "src/duckdb/ub_src_execution_operator_csv_scanner_state_machine.cpp", 
@@ -84,6 +64,7 @@
                 "src/duckdb/ub_src_execution_operator_schema.cpp", 
                 "src/duckdb/ub_src_execution_operator_set.cpp", 
                 "src/duckdb/ub_src_execution_physical_plan.cpp", 
+                "src/duckdb/ub_src_execution_sample.cpp", 
                 "src/duckdb/ub_src_function_aggregate_distributive.cpp", 
                 "src/duckdb/ub_src_function_aggregate.cpp", 
                 "src/duckdb/ub_src_function.cpp", 
@@ -92,9 +73,11 @@
                 "src/duckdb/ub_src_function_pragma.cpp", 
                 "src/duckdb/ub_src_function_scalar_compressed_materialization.cpp", 
                 "src/duckdb/ub_src_function_scalar.cpp", 
+                "src/duckdb/ub_src_function_scalar_date.cpp", 
                 "src/duckdb/ub_src_function_scalar_generic.cpp", 
                 "src/duckdb/ub_src_function_scalar_list.cpp", 
-                "src/duckdb/ub_src_function_scalar_operators.cpp", 
+                "src/duckdb/ub_src_function_scalar_map.cpp", 
+                "src/duckdb/ub_src_function_scalar_operator.cpp", 
                 "src/duckdb/ub_src_function_scalar_sequence.cpp", 
                 "src/duckdb/ub_src_function_scalar_string.cpp", 
                 "src/duckdb/ub_src_function_scalar_string_regexp.cpp", 
@@ -104,6 +87,8 @@
                 "src/duckdb/ub_src_function_table.cpp", 
                 "src/duckdb/ub_src_function_table_system.cpp", 
                 "src/duckdb/ub_src_function_table_version.cpp", 
+                "src/duckdb/ub_src_function_window.cpp", 
+                "src/duckdb/ub_src_logging.cpp", 
                 "src/duckdb/ub_src_main.cpp", 
                 "src/duckdb/ub_src_main_buffered_data.cpp", 
                 "src/duckdb/ub_src_main_capi.cpp", 
@@ -151,6 +136,8 @@
                 "src/duckdb/ub_src_storage_compression_alp.cpp", 
                 "src/duckdb/ub_src_storage_compression.cpp", 
                 "src/duckdb/ub_src_storage_compression_chimp.cpp", 
+                "src/duckdb/ub_src_storage_compression_dictionary.cpp", 
+                "src/duckdb/ub_src_storage_compression_roaring.cpp", 
                 "src/duckdb/ub_src_storage_metadata.cpp", 
                 "src/duckdb/ub_src_storage_serialization.cpp", 
                 "src/duckdb/ub_src_storage_statistics.cpp", 
@@ -233,6 +220,38 @@
                 "src/duckdb/third_party/mbedtls/library/sha512.cpp", 
                 "src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp", 
                 "src/duckdb/third_party/yyjson/yyjson.cpp", 
+                "src/duckdb/third_party/zstd/common/debug.cpp", 
+                "src/duckdb/third_party/zstd/common/entropy_common.cpp", 
+                "src/duckdb/third_party/zstd/common/error_private.cpp", 
+                "src/duckdb/third_party/zstd/common/fse_decompress.cpp", 
+                "src/duckdb/third_party/zstd/common/pool.cpp", 
+                "src/duckdb/third_party/zstd/common/threading.cpp", 
+                "src/duckdb/third_party/zstd/common/xxhash.cpp", 
+                "src/duckdb/third_party/zstd/common/zstd_common.cpp", 
+                "src/duckdb/third_party/zstd/compress/fse_compress.cpp", 
+                "src/duckdb/third_party/zstd/compress/hist.cpp", 
+                "src/duckdb/third_party/zstd/compress/huf_compress.cpp", 
+                "src/duckdb/third_party/zstd/compress/zstd_compress.cpp", 
+                "src/duckdb/third_party/zstd/compress/zstd_compress_literals.cpp", 
+                "src/duckdb/third_party/zstd/compress/zstd_compress_sequences.cpp", 
+                "src/duckdb/third_party/zstd/compress/zstd_compress_superblock.cpp", 
+                "src/duckdb/third_party/zstd/compress/zstd_double_fast.cpp", 
+                "src/duckdb/third_party/zstd/compress/zstd_fast.cpp", 
+                "src/duckdb/third_party/zstd/compress/zstd_lazy.cpp", 
+                "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
+                "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
+                "src/duckdb/third_party/zstd/compress/zstdmt_compress.cpp", 
+                "src/duckdb/third_party/zstd/decompress/huf_decompress.cpp", 
+                "src/duckdb/third_party/zstd/decompress/zstd_ddict.cpp", 
+                "src/duckdb/third_party/zstd/decompress/zstd_decompress.cpp", 
+                "src/duckdb/third_party/zstd/decompress/zstd_decompress_block.cpp", 
+                "src/duckdb/third_party/zstd/deprecated/zbuff_common.cpp", 
+                "src/duckdb/third_party/zstd/deprecated/zbuff_compress.cpp", 
+                "src/duckdb/third_party/zstd/deprecated/zbuff_decompress.cpp", 
+                "src/duckdb/third_party/zstd/dict/cover.cpp", 
+                "src/duckdb/third_party/zstd/dict/divsufsort.cpp", 
+                "src/duckdb/third_party/zstd/dict/fastcover.cpp", 
+                "src/duckdb/third_party/zstd/dict/zdict.cpp", 
                 "src/duckdb/extension/parquet/column_reader.cpp", 
                 "src/duckdb/extension/parquet/column_writer.cpp", 
                 "src/duckdb/extension/parquet/parquet_crypto.cpp", 
@@ -245,34 +264,12 @@
                 "src/duckdb/extension/parquet/serialize_parquet.cpp", 
                 "src/duckdb/extension/parquet/zstd_file_system.cpp", 
                 "src/duckdb/extension/parquet/geo_parquet.cpp", 
-                "src/duckdb/third_party/parquet/parquet_constants.cpp", 
                 "src/duckdb/third_party/parquet/parquet_types.cpp", 
                 "src/duckdb/third_party/thrift/thrift/protocol/TProtocol.cpp", 
                 "src/duckdb/third_party/thrift/thrift/transport/TTransportException.cpp", 
                 "src/duckdb/third_party/thrift/thrift/transport/TBufferTransports.cpp", 
                 "src/duckdb/third_party/snappy/snappy.cc", 
                 "src/duckdb/third_party/snappy/snappy-sinksource.cc", 
-                "src/duckdb/third_party/zstd/decompress/zstd_ddict.cpp", 
-                "src/duckdb/third_party/zstd/decompress/huf_decompress.cpp", 
-                "src/duckdb/third_party/zstd/decompress/zstd_decompress.cpp", 
-                "src/duckdb/third_party/zstd/decompress/zstd_decompress_block.cpp", 
-                "src/duckdb/third_party/zstd/common/entropy_common.cpp", 
-                "src/duckdb/third_party/zstd/common/fse_decompress.cpp", 
-                "src/duckdb/third_party/zstd/common/zstd_common.cpp", 
-                "src/duckdb/third_party/zstd/common/error_private.cpp", 
-                "src/duckdb/third_party/zstd/common/xxhash.cpp", 
-                "src/duckdb/third_party/zstd/compress/fse_compress.cpp", 
-                "src/duckdb/third_party/zstd/compress/hist.cpp", 
-                "src/duckdb/third_party/zstd/compress/huf_compress.cpp", 
-                "src/duckdb/third_party/zstd/compress/zstd_compress.cpp", 
-                "src/duckdb/third_party/zstd/compress/zstd_compress_literals.cpp", 
-                "src/duckdb/third_party/zstd/compress/zstd_compress_sequences.cpp", 
-                "src/duckdb/third_party/zstd/compress/zstd_compress_superblock.cpp", 
-                "src/duckdb/third_party/zstd/compress/zstd_double_fast.cpp", 
-                "src/duckdb/third_party/zstd/compress/zstd_fast.cpp", 
-                "src/duckdb/third_party/zstd/compress/zstd_lazy.cpp", 
-                "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
-                "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
                 "src/duckdb/third_party/lz4/lz4.cpp", 
                 "src/duckdb/third_party/brotli/common/constants.cpp", 
                 "src/duckdb/third_party/brotli/common/context.cpp", 
@@ -329,7 +326,30 @@
                 "src/duckdb/extension/json/json_serializer.cpp", 
                 "src/duckdb/extension/json/json_deserializer.cpp", 
                 "src/duckdb/extension/json/serialize_json.cpp", 
-                "src/duckdb/ub_extension_json_json_functions.cpp"
+                "src/duckdb/ub_extension_json_json_functions.cpp", 
+                "src/duckdb/extension/core_functions/function_list.cpp", 
+                "src/duckdb/extension/core_functions/core_functions_extension.cpp", 
+                "src/duckdb/extension/core_functions/lambda_functions.cpp", 
+                "src/duckdb/ub_extension_core_functions_aggregate_holistic.cpp", 
+                "src/duckdb/ub_extension_core_functions_aggregate_distributive.cpp", 
+                "src/duckdb/ub_extension_core_functions_aggregate_algebraic.cpp", 
+                "src/duckdb/ub_extension_core_functions_aggregate_regression.cpp", 
+                "src/duckdb/ub_extension_core_functions_aggregate_nested.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_bit.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_operators.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_array.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_date.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_enum.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_math.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_struct.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_map.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_list.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_union.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_generic.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_string.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_random.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_blob.cpp", 
+                "src/duckdb/ub_extension_core_functions_scalar_debug.cpp"
             ], 
             "include_dirs": [
                 "<!(node -p \"require('node-addon-api').include_dir\")", 
@@ -361,6 +381,7 @@
                 "src/duckdb/third_party/utf8proc", 
                 "src/duckdb/third_party/utf8proc/include", 
                 "src/duckdb/third_party/yyjson/include", 
+                "src/duckdb/third_party/zstd/include", 
                 "src/duckdb/extension/parquet/include", 
                 "src/duckdb/third_party/parquet", 
                 "src/duckdb/third_party/thrift", 
@@ -370,21 +391,23 @@
                 "src/duckdb/third_party/brotli/dec", 
                 "src/duckdb/third_party/brotli/enc", 
                 "src/duckdb/third_party/snappy", 
-                "src/duckdb/third_party/zstd/include", 
                 "src/duckdb/third_party/mbedtls", 
                 "src/duckdb/third_party/mbedtls/include", 
+                "src/duckdb/third_party/zstd/include", 
                 "src/duckdb/extension/icu/include", 
                 "src/duckdb/extension/icu/third_party/icu/common", 
                 "src/duckdb/extension/icu/third_party/icu/i18n", 
-                "src/duckdb/extension/json/include"
+                "src/duckdb/extension/json/include", 
+                "src/duckdb/extension/core_functions/include"
             ], 
             "defines": [
                 "NAPI_VERSION=6", 
                 "DUCKDB_EXTENSION_PARQUET_LINKED", 
                 "DUCKDB_EXTENSION_ICU_LINKED", 
                 "DUCKDB_EXTENSION_JSON_LINKED", 
+                "DUCKDB_EXTENSION_CORE_FUNCTIONS_LINKED", 
                 "DUCKDB_EXTENSION_AUTOLOAD_DEFAULT=1", 
-                "DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT=1",
+                "DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT=1", 
                 "NDEBUG"
             ], 
             "cflags_cc": [
@@ -420,12 +443,10 @@
             }, 
             "msvs_settings": {
                 "VCCLCompilerTool": {
-                    "ExceptionHandling": 1,
-                    "RuntimeLibrary": 2,
+                    "ExceptionHandling": 1, 
                     "AdditionalOptions": [
                         "/bigobj", 
-                        "/GR",
-                        "/MD"
+                        "/GR"
                     ]
                 }
             }, 

package/package.json

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

package/src/duckdb/{src → extension}/core_functions/aggregate/algebraic/avg.cpp

@@ -1,5 +1,5 @@
-#include "duckdb/core_functions/aggregate/algebraic_functions.hpp"
-#include "duckdb/core_functions/aggregate/sum_helpers.hpp"
+#include "core_functions/aggregate/algebraic_functions.hpp"
+#include "core_functions/aggregate/sum_helpers.hpp"
 #include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/function/function_set.hpp"

package/src/duckdb/{src → extension}/core_functions/aggregate/algebraic/corr.cpp

@@ -1,7 +1,7 @@
-#include "duckdb/core_functions/aggregate/algebraic_functions.hpp"
-#include "duckdb/core_functions/aggregate/algebraic/covar.hpp"
-#include "duckdb/core_functions/aggregate/algebraic/stddev.hpp"
-#include "duckdb/core_functions/aggregate/algebraic/corr.hpp"
+#include "core_functions/aggregate/algebraic_functions.hpp"
+#include "core_functions/aggregate/algebraic/covar.hpp"
+#include "core_functions/aggregate/algebraic/stddev.hpp"
+#include "core_functions/aggregate/algebraic/corr.hpp"
 #include "duckdb/function/function_set.hpp"
 
 namespace duckdb {

package/src/duckdb/{src → extension}/core_functions/aggregate/algebraic/covar.cpp

@@ -1,6 +1,6 @@
-#include "duckdb/core_functions/aggregate/algebraic_functions.hpp"
+#include "core_functions/aggregate/algebraic_functions.hpp"
 #include "duckdb/common/types/null_value.hpp"
-#include "duckdb/core_functions/aggregate/algebraic/covar.hpp"
+#include "core_functions/aggregate/algebraic/covar.hpp"
 
 namespace duckdb {
 

package/src/duckdb/{src → extension}/core_functions/aggregate/algebraic/stddev.cpp

@@ -1,7 +1,7 @@
-#include "duckdb/core_functions/aggregate/algebraic_functions.hpp"
+#include "core_functions/aggregate/algebraic_functions.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/function_set.hpp"
-#include "duckdb/core_functions/aggregate/algebraic/stddev.hpp"
+#include "core_functions/aggregate/algebraic/stddev.hpp"
 #include <cmath>
 
 namespace duckdb {

package/src/duckdb/{src → extension}/core_functions/aggregate/distributive/approx_count.cpp

@@ -1,7 +1,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/types/hyperloglog.hpp"
-#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
+#include "core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "hyperloglog.hpp"

package/src/duckdb/{src → extension}/core_functions/aggregate/distributive/arg_min_max.cpp

@@ -1,14 +1,14 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
+#include "core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/core_functions/create_sort_key.hpp"
-#include "duckdb/core_functions/aggregate/minmax_n_helpers.hpp"
+#include "duckdb/function/create_sort_key.hpp"
+#include "duckdb/function/aggregate/minmax_n_helpers.hpp"
 
 namespace duckdb {
 
@@ -285,7 +285,6 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR, IGNORE_NULL> {
 			target.arg_null = source.arg_null;
 			if (!target.arg_null) {
 				STATE::template AssignValue<typename STATE::ARG_TYPE>(target.arg, source.arg);
-				;
 			}
 			target.is_initialized = true;
 		}
@@ -303,21 +302,43 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR, IGNORE_NULL> {
 
 	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
 	                                     vector<unique_ptr<Expression>> &arguments) {
+		if (arguments[1]->return_type.InternalType() == PhysicalType::VARCHAR) {
+			ExpressionBinder::PushCollation(context, arguments[1], arguments[1]->return_type);
+		}
 		function.arguments[0] = arguments[0]->return_type;
 		function.return_type = arguments[0]->return_type;
 		return nullptr;
 	}
 };
 
+template <class OP>
+AggregateFunction GetGenericArgMinMaxFunction() {
+	using STATE = ArgMinMaxState<string_t, string_t>;
+	return AggregateFunction(
+	    {LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, AggregateFunction::StateSize<STATE>,
+	    AggregateFunction::StateInitialize<STATE, OP, AggregateDestructorType::LEGACY>, OP::template Update<STATE>,
+	    AggregateFunction::StateCombine<STATE, OP>, AggregateFunction::StateVoidFinalize<STATE, OP>, nullptr, OP::Bind,
+	    AggregateFunction::StateDestroy<STATE, OP>);
+}
+
 template <class OP, class ARG_TYPE, class BY_TYPE>
 AggregateFunction GetVectorArgMinMaxFunctionInternal(const LogicalType &by_type, const LogicalType &type) {
+#ifndef DUCKDB_SMALLER_BINARY
 	using STATE = ArgMinMaxState<ARG_TYPE, BY_TYPE>;
-	return AggregateFunction(
-	    {type, by_type}, type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
-	    OP::template Update<STATE>, AggregateFunction::StateCombine<STATE, OP>,
-	    AggregateFunction::StateVoidFinalize<STATE, OP>, nullptr, OP::Bind, AggregateFunction::StateDestroy<STATE, OP>);
+	return AggregateFunction({type, by_type}, type, AggregateFunction::StateSize<STATE>,
+	                         AggregateFunction::StateInitialize<STATE, OP, AggregateDestructorType::LEGACY>,
+	                         OP::template Update<STATE>, AggregateFunction::StateCombine<STATE, OP>,
+	                         AggregateFunction::StateVoidFinalize<STATE, OP>, nullptr, OP::Bind,
+	                         AggregateFunction::StateDestroy<STATE, OP>);
+#else
+	auto function = GetGenericArgMinMaxFunction<OP>();
+	function.arguments = {type, by_type};
+	function.return_type = type;
+	return function;
+#endif
 }
 
+#ifndef DUCKDB_SMALLER_BINARY
 template <class OP, class ARG_TYPE>
 AggregateFunction GetVectorArgMinMaxFunctionBy(const LogicalType &by_type, const LogicalType &type) {
 	switch (by_type.InternalType()) {
@@ -335,6 +356,7 @@ AggregateFunction GetVectorArgMinMaxFunctionBy(const LogicalType &by_type, const
 		throw InternalException("Unimplemented arg_min/arg_max aggregate");
 	}
 }
+#endif
 
 static const vector<LogicalType> ArgMaxByTypes() {
 	vector<LogicalType> types = {LogicalType::INTEGER,   LogicalType::BIGINT,       LogicalType::HUGEINT,
@@ -347,21 +369,34 @@ template <class OP, class ARG_TYPE>
 void AddVectorArgMinMaxFunctionBy(AggregateFunctionSet &fun, const LogicalType &type) {
 	auto by_types = ArgMaxByTypes();
 	for (const auto &by_type : by_types) {
+#ifndef DUCKDB_SMALLER_BINARY
 		fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(by_type, type));
+#else
+		fun.AddFunction(GetVectorArgMinMaxFunctionInternal<OP, string_t, string_t>(by_type, type));
+#endif
 	}
 }
 
 template <class OP, class ARG_TYPE, class BY_TYPE>
 AggregateFunction GetArgMinMaxFunctionInternal(const LogicalType &by_type, const LogicalType &type) {
+#ifndef DUCKDB_SMALLER_BINARY
 	using STATE = ArgMinMaxState<ARG_TYPE, BY_TYPE>;
-	auto function = AggregateFunction::BinaryAggregate<STATE, ARG_TYPE, BY_TYPE, ARG_TYPE, OP>(type, by_type, type);
+	auto function =
+	    AggregateFunction::BinaryAggregate<STATE, ARG_TYPE, BY_TYPE, ARG_TYPE, OP, AggregateDestructorType::LEGACY>(
+	        type, by_type, type);
 	if (type.InternalType() == PhysicalType::VARCHAR || by_type.InternalType() == PhysicalType::VARCHAR) {
 		function.destructor = AggregateFunction::StateDestroy<STATE, OP>;
 	}
 	function.bind = OP::Bind;
+#else
+	auto function = GetGenericArgMinMaxFunction<OP>();
+	function.arguments = {type, by_type};
+	function.return_type = type;
+#endif
 	return function;
 }
 
+#ifndef DUCKDB_SMALLER_BINARY
 template <class OP, class ARG_TYPE>
 AggregateFunction GetArgMinMaxFunctionBy(const LogicalType &by_type, const LogicalType &type) {
 	switch (by_type.InternalType()) {
@@ -379,18 +414,24 @@ AggregateFunction GetArgMinMaxFunctionBy(const LogicalType &by_type, const Logic
 		throw InternalException("Unimplemented arg_min/arg_max by aggregate");
 	}
 }
+#endif
 
 template <class OP, class ARG_TYPE>
 void AddArgMinMaxFunctionBy(AggregateFunctionSet &fun, const LogicalType &type) {
 	auto by_types = ArgMaxByTypes();
 	for (const auto &by_type : by_types) {
+#ifndef DUCKDB_SMALLER_BINARY
 		fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(by_type, type));
+#else
+		fun.AddFunction(GetArgMinMaxFunctionInternal<OP, string_t, string_t>(by_type, type));
+#endif
 	}
 }
 
 template <class OP>
 static AggregateFunction GetDecimalArgMinMaxFunction(const LogicalType &by_type, const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
+#ifndef DUCKDB_SMALLER_BINARY
 	switch (type.InternalType()) {
 	case PhysicalType::INT16:
 		return GetArgMinMaxFunctionBy<OP, int16_t>(by_type, type);
@@ -401,6 +442,9 @@ static AggregateFunction GetDecimalArgMinMaxFunction(const LogicalType &by_type,
 	default:
 		return GetArgMinMaxFunctionBy<OP, hugeint_t>(by_type, type);
 	}
+#else
+	return GetArgMinMaxFunctionInternal<OP, string_t, string_t>(by_type, type);
+#endif
 }
 
 template <class OP>
@@ -449,17 +493,19 @@ void AddDecimalArgMinMaxFunctionBy(AggregateFunctionSet &fun, const LogicalType
 
 template <class OP>
 void AddGenericArgMinMaxFunction(AggregateFunctionSet &fun) {
-	using STATE = ArgMinMaxState<string_t, string_t>;
-	fun.AddFunction(
-	    AggregateFunction({LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, AggregateFunction::StateSize<STATE>,
-	                      AggregateFunction::StateInitialize<STATE, OP>, OP::template Update<STATE>,
-	                      AggregateFunction::StateCombine<STATE, OP>, AggregateFunction::StateVoidFinalize<STATE, OP>,
-	                      nullptr, OP::Bind, AggregateFunction::StateDestroy<STATE, OP>));
+	fun.AddFunction(GetGenericArgMinMaxFunction<OP>());
 }
 
 template <class COMPARATOR, bool IGNORE_NULL, OrderType ORDER_TYPE>
 static 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>;
+	using VECTOR_OP = VectorArgMinMaxBase<COMPARATOR, IGNORE_NULL, ORDER_TYPE>;
+#else
+	using OP = GENERIC_VECTOR_OP;
+	using VECTOR_OP = GENERIC_VECTOR_OP;
+#endif
 	AddArgMinMaxFunctionBy<OP, int32_t>(fun, LogicalType::INTEGER);
 	AddArgMinMaxFunctionBy<OP, int64_t>(fun, LogicalType::BIGINT);
 	AddArgMinMaxFunctionBy<OP, double>(fun, LogicalType::DOUBLE);
@@ -474,11 +520,9 @@ static void AddArgMinMaxFunctions(AggregateFunctionSet &fun) {
 		AddDecimalArgMinMaxFunctionBy<OP>(fun, by_type);
 	}
 
-	using VECTOR_OP = VectorArgMinMaxBase<COMPARATOR, IGNORE_NULL, ORDER_TYPE>;
 	AddVectorArgMinMaxFunctionBy<VECTOR_OP, string_t>(fun, LogicalType::ANY);
 
 	// we always use LessThan when using sort keys because the ORDER_TYPE takes care of selecting the lowest or highest
-	using GENERIC_VECTOR_OP = VectorArgMinMaxBase<LessThan, IGNORE_NULL, ORDER_TYPE, GenericArgMinMaxState<ORDER_TYPE>>;
 	AddGenericArgMinMaxFunction<GENERIC_VECTOR_OP>(fun);
 }
 
@@ -577,7 +621,7 @@ static void SpecializeArgMinMaxNFunction(AggregateFunction &function) {
 	using OP = MinMaxNOperation;
 
 	function.state_size = AggregateFunction::StateSize<STATE>;
-	function.initialize = AggregateFunction::StateInitialize<STATE, OP>;
+	function.initialize = AggregateFunction::StateInitialize<STATE, OP, AggregateDestructorType::LEGACY>;
 	function.combine = AggregateFunction::StateCombine<STATE, OP>;
 	function.destructor = AggregateFunction::StateDestroy<STATE, OP>;
 
@@ -588,6 +632,7 @@ static void SpecializeArgMinMaxNFunction(AggregateFunction &function) {
 template <class VAL_TYPE, class COMPARATOR>
 static void SpecializeArgMinMaxNFunction(PhysicalType arg_type, AggregateFunction &function) {
 	switch (arg_type) {
+#ifndef DUCKDB_SMALLER_BINARY
 	case PhysicalType::VARCHAR:
 		SpecializeArgMinMaxNFunction<VAL_TYPE, MinMaxStringValue, COMPARATOR>(function);
 		break;
@@ -603,6 +648,7 @@ static void SpecializeArgMinMaxNFunction(PhysicalType arg_type, AggregateFunctio
 	case PhysicalType::DOUBLE:
 		SpecializeArgMinMaxNFunction<VAL_TYPE, MinMaxFixedValue<double>, COMPARATOR>(function);
 		break;
+#endif
 	default:
 		SpecializeArgMinMaxNFunction<VAL_TYPE, MinMaxFallbackValue, COMPARATOR>(function);
 		break;
@@ -612,6 +658,7 @@ static void SpecializeArgMinMaxNFunction(PhysicalType arg_type, AggregateFunctio
 template <class COMPARATOR>
 static void SpecializeArgMinMaxNFunction(PhysicalType val_type, PhysicalType arg_type, AggregateFunction &function) {
 	switch (val_type) {
+#ifndef DUCKDB_SMALLER_BINARY
 	case PhysicalType::VARCHAR:
 		SpecializeArgMinMaxNFunction<MinMaxStringValue, COMPARATOR>(arg_type, function);
 		break;
@@ -627,6 +674,7 @@ static void SpecializeArgMinMaxNFunction(PhysicalType val_type, PhysicalType arg
 	case PhysicalType::DOUBLE:
 		SpecializeArgMinMaxNFunction<MinMaxFixedValue<double>, COMPARATOR>(arg_type, function);
 		break;
+#endif
 	default:
 		SpecializeArgMinMaxNFunction<MinMaxFallbackValue, COMPARATOR>(arg_type, function);
 		break;

package/src/duckdb/{src → extension}/core_functions/aggregate/distributive/bitagg.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
+#include "core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"