duckdb 0.3.3-dev1439.0 → 0.3.3-dev1441.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.3-dev1439.0",
+  "version": "0.3.3-dev1441.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -73190,7 +73190,6 @@ void ApproxCountDistinctFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
-#include <utility>
 
 namespace duckdb {
 
@@ -73201,39 +73200,71 @@ struct ArgMinMaxState {
 	bool is_initialized;
 };
 
-struct ArgMinMaxOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->is_initialized = false;
+template <class T>
+static void ArgMinMaxDestroyValue(T value) {
+}
+
+template <>
+void ArgMinMaxDestroyValue(string_t value) {
+	if (!value.IsInlined()) {
+		delete[] value.GetDataUnsafe();
 	}
+}
 
-	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_initialized) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->arg;
+template <class T>
+static void ArgMinMaxAssignValue(T &target, T new_value, bool is_initialized) {
+	target = new_value;
+}
+
+template <>
+void ArgMinMaxAssignValue(string_t &target, string_t new_value, bool is_initialized) {
+	if (is_initialized) {
+		ArgMinMaxDestroyValue(target);
+	}
+	if (new_value.IsInlined()) {
+		target = new_value;
+	} else {
+		// non-inlined string, need to allocate space for it
+		auto len = new_value.GetSize();
+		auto ptr = new char[len];
+		memcpy(ptr, new_value.GetDataUnsafe(), len);
+
+		target = string_t(ptr, len);
+	}
+}
+
+template <class COMPARATOR>
+struct ArgMinMaxBase {
+	template <class STATE>
+	static void Destroy(STATE *state) {
+		if (state->is_initialized) {
+			ArgMinMaxDestroyValue(state->arg);
+			ArgMinMaxDestroyValue(state->value);
 		}
 	}
 
-	static bool IgnoreNull() {
-		return true;
+	template <class STATE>
+	static void Initialize(STATE *state) {
+		state->is_initialized = false;
 	}
-};
 
-struct ArgMinOperation : ArgMinMaxOperation {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
 	static void Operation(STATE *state, FunctionData *bind_data, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
 	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
 		if (!state->is_initialized) {
-			state->value = y_data[yidx];
-			state->arg = x_data[xidx];
+			ArgMinMaxAssignValue<A_TYPE>(state->arg, x_data[xidx], false);
+			ArgMinMaxAssignValue<B_TYPE>(state->value, y_data[yidx], false);
 			state->is_initialized = true;
 		} else {
-			if (y_data[yidx] < state->value) {
-				state->value = y_data[yidx];
-				state->arg = x_data[xidx];
-			}
+			OP::template Execute<A_TYPE, B_TYPE, STATE>(state, x_data[xidx], y_data[yidx]);
+		}
+	}
+
+	template <class A_TYPE, class B_TYPE, class STATE>
+	static void Execute(STATE *state, A_TYPE x_data, B_TYPE y_data) {
+		if (COMPARATOR::Operation(y_data, state->value)) {
+			ArgMinMaxAssignValue<A_TYPE>(state->arg, x_data, true);
+			ArgMinMaxAssignValue<B_TYPE>(state->value, y_data, true);
 		}
 	}
 
@@ -73242,183 +73273,98 @@ struct ArgMinOperation : ArgMinMaxOperation {
 		if (!source.is_initialized) {
 			return;
 		}
-		if (!target->is_initialized) {
+		if (!target->is_initialized || COMPARATOR::Operation(source.value, target->value)) {
+			ArgMinMaxAssignValue(target->arg, source.arg, target->is_initialized);
+			ArgMinMaxAssignValue(target->value, source.value, target->is_initialized);
 			target->is_initialized = true;
-			target->value = source.value;
-			target->arg = source.arg;
-			return;
-		}
-		if (source.value < target->value) {
-			target->value = source.value;
-			target->arg = source.arg;
 		}
 	}
+
+	static bool IgnoreNull() {
+		return true;
+	}
 };
 
-struct ArgMaxOperation : ArgMinMaxOperation {
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
-	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
+template <class COMPARATOR>
+struct StringArgMinMax : public ArgMinMaxBase<COMPARATOR> {
+	template <class T, class STATE>
+	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->is_initialized) {
-			state->value = y_data[yidx];
-			state->arg = x_data[xidx];
-			state->is_initialized = true;
+			mask.SetInvalid(idx);
 		} else {
-			if (state->value < y_data[yidx]) {
-				state->value = y_data[yidx];
-				state->arg = x_data[xidx];
-			}
+			target[idx] = StringVector::AddStringOrBlob(result, state->arg);
 		}
 	}
+};
 
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target) {
-		if (!source.is_initialized) {
-			return;
-		}
-		if (!target->is_initialized) {
-			target->is_initialized = true;
-			target->value = source.value;
-			target->arg = source.arg;
-			return;
-		}
-		if (target->value < source.value) {
-			target->value = source.value;
-			target->arg = source.arg;
+template <class COMPARATOR>
+struct NumericArgMinMax : public ArgMinMaxBase<COMPARATOR> {
+	template <class T, class STATE>
+	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+		if (!state->is_initialized) {
+			mask.SetInvalid(idx);
+		} else {
+			target[idx] = state->arg;
 		}
 	}
 };
 
+using NumericArgMinOperation = NumericArgMinMax<LessThan>;
+using NumericArgMaxOperation = NumericArgMinMax<GreaterThan>;
+using StringArgMinOperation = StringArgMinMax<LessThan>;
+using StringArgMaxOperation = StringArgMinMax<GreaterThan>;
+
+template <class OP, class T, class T2>
+AggregateFunction GetArgMinMaxFunctionInternal(const LogicalType &arg_2, const LogicalType &arg) {
+	auto function = AggregateFunction::BinaryAggregate<ArgMinMaxState<T, T2>, T, T2, T, OP>(arg, arg_2, arg);
+	if (arg.InternalType() == PhysicalType::VARCHAR || arg_2.InternalType() == PhysicalType::VARCHAR) {
+		function.destructor = AggregateFunction::StateDestroy<ArgMinMaxState<T, T2>, OP>;
+	}
+	return function;
+}
 template <class OP, class T>
-AggregateFunction GetArgMinMaxFunctionArg2(LogicalTypeId arg_2, const LogicalType &arg) {
-	switch (arg_2) {
-	case LogicalTypeId::INTEGER:
-		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, int32_t>, T, int32_t, T, OP>(
-		    arg, LogicalType::INTEGER, arg);
-	case LogicalTypeId::BIGINT:
-		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, int64_t>, T, int64_t, T, OP>(
-		    arg, LogicalType::BIGINT, arg);
-	case LogicalTypeId::DOUBLE:
-		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, double>, T, double, T, OP>(arg, LogicalType::DOUBLE,
-		                                                                                       arg);
-	case LogicalTypeId::VARCHAR:
-		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, string_t>, T, string_t, T, OP>(
-		    arg, LogicalType::VARCHAR, arg);
-	case LogicalTypeId::DATE:
-		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, date_t>, T, date_t, T, OP>(arg, LogicalType::DATE,
-		                                                                                       arg);
-	case LogicalTypeId::TIMESTAMP:
-		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, timestamp_t>, T, timestamp_t, T, OP>(
-		    arg, LogicalType::TIMESTAMP, arg);
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, timestamp_t>, T, timestamp_t, T, OP>(
-		    arg, LogicalType::TIMESTAMP_TZ, arg);
-	case LogicalTypeId::BLOB:
-		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, string_t>, T, string_t, T, OP>(
-		    arg, LogicalType::BLOB, arg);
+AggregateFunction GetArgMinMaxFunctionArg2(const LogicalType &arg_2, const LogicalType &arg) {
+	switch (arg_2.InternalType()) {
+	case PhysicalType::INT32:
+		return GetArgMinMaxFunctionInternal<OP, T, int32_t>(arg_2, arg);
+	case PhysicalType::INT64:
+		return GetArgMinMaxFunctionInternal<OP, T, int64_t>(arg_2, arg);
+	case PhysicalType::DOUBLE:
+		return GetArgMinMaxFunctionInternal<OP, T, double>(arg_2, arg);
+	case PhysicalType::VARCHAR:
+		return GetArgMinMaxFunctionInternal<OP, T, string_t>(arg_2, arg);
 	default:
 		throw InternalException("Unimplemented arg_min/arg_max aggregate");
 	}
 }
 
-template <class OP>
-void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
-	switch (arg_1) {
-	case LogicalTypeId::INTEGER:
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::INTEGER, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::BIGINT, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::DOUBLE, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::VARCHAR, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::DATE, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::TIMESTAMP, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::BLOB, LogicalType::INTEGER));
-		break;
-	case LogicalTypeId::BIGINT:
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::INTEGER, LogicalType::BIGINT));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::BIGINT, LogicalType::BIGINT));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::DOUBLE, LogicalType::BIGINT));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::VARCHAR, LogicalType::BIGINT));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::DATE, LogicalType::BIGINT));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::TIMESTAMP, LogicalType::BIGINT));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::BIGINT));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::BLOB, LogicalType::BIGINT));
-		break;
-	case LogicalTypeId::DOUBLE:
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::INTEGER, LogicalType::DOUBLE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::BIGINT, LogicalType::DOUBLE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::DOUBLE, LogicalType::DOUBLE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::VARCHAR, LogicalType::DOUBLE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::DATE, LogicalType::DOUBLE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::TIMESTAMP, LogicalType::DOUBLE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::DOUBLE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::BLOB, LogicalType::DOUBLE));
-		break;
-	case LogicalTypeId::VARCHAR:
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::INTEGER, LogicalType::VARCHAR));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::BIGINT, LogicalType::VARCHAR));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::DOUBLE, LogicalType::VARCHAR));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::VARCHAR, LogicalType::VARCHAR));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::DATE, LogicalType::VARCHAR));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::TIMESTAMP, LogicalType::VARCHAR));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::VARCHAR));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::BLOB, LogicalType::VARCHAR));
-		break;
-	case LogicalTypeId::DATE:
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::INTEGER, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::BIGINT, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DOUBLE, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::VARCHAR, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DATE, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::TIMESTAMP, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::BLOB, LogicalType::DATE));
-		break;
-	case LogicalTypeId::TIMESTAMP:
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::INTEGER, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BIGINT, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DOUBLE, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::VARCHAR, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DATE, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BLOB, LogicalType::TIMESTAMP));
-		break;
-	case LogicalTypeId::TIMESTAMP_TZ:
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::INTEGER, LogicalType::TIMESTAMP_TZ));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BIGINT, LogicalType::TIMESTAMP_TZ));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DOUBLE, LogicalType::TIMESTAMP_TZ));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::VARCHAR, LogicalType::TIMESTAMP_TZ));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DATE, LogicalType::TIMESTAMP_TZ));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP, LogicalType::TIMESTAMP_TZ));
-		fun.AddFunction(
-		    GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BLOB, LogicalType::TIMESTAMP_TZ));
-		break;
-	case LogicalTypeId::BLOB:
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::INTEGER, LogicalType::BLOB));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::BIGINT, LogicalType::BLOB));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::DOUBLE, LogicalType::BLOB));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::VARCHAR, LogicalType::BLOB));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::DATE, LogicalType::BLOB));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::TIMESTAMP, LogicalType::BLOB));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::BLOB));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::BLOB, LogicalType::BLOB));
-		break;
-	default:
-		throw InternalException("Unimplemented arg_min/arg_max aggregate");
-	}
+template <class OP, class T>
+void AddArgMinMaxFunctionArg2(AggregateFunctionSet &fun, const LogicalType &arg) {
+	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::INTEGER, arg));
+	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::BIGINT, arg));
+	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::DOUBLE, arg));
+	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::VARCHAR, arg));
+	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::DATE, arg));
+	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::TIMESTAMP, arg));
+	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::TIMESTAMP_TZ, arg));
+	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::BLOB, arg));
+}
+
+template <class OP, class STRING_OP>
+static void AddArgMinMaxFunctions(AggregateFunctionSet &fun) {
+	AddArgMinMaxFunctionArg2<OP, int32_t>(fun, LogicalType::INTEGER);
+	AddArgMinMaxFunctionArg2<OP, int64_t>(fun, LogicalType::BIGINT);
+	AddArgMinMaxFunctionArg2<OP, double>(fun, LogicalType::DOUBLE);
+	AddArgMinMaxFunctionArg2<STRING_OP, string_t>(fun, LogicalType::VARCHAR);
+	AddArgMinMaxFunctionArg2<OP, date_t>(fun, LogicalType::DATE);
+	AddArgMinMaxFunctionArg2<OP, timestamp_t>(fun, LogicalType::TIMESTAMP);
+	AddArgMinMaxFunctionArg2<OP, timestamp_t>(fun, LogicalType::TIMESTAMP_TZ);
+	AddArgMinMaxFunctionArg2<STRING_OP, string_t>(fun, LogicalType::BLOB);
 }
+
 void ArgMinFun::RegisterFunction(BuiltinFunctions &set) {
 	AggregateFunctionSet fun("argmin");
-	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::INTEGER, fun);
-	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::BIGINT, fun);
-	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::DOUBLE, fun);
-	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::VARCHAR, fun);
-	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::DATE, fun);
-	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::TIMESTAMP, fun);
-	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::TIMESTAMP_TZ, fun);
-	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::BLOB, fun);
+	AddArgMinMaxFunctions<NumericArgMinOperation, StringArgMinOperation>(fun);
 	set.AddFunction(fun);
 
 	//! Add min_by alias
@@ -73432,14 +73378,7 @@ void ArgMinFun::RegisterFunction(BuiltinFunctions &set) {
 
 void ArgMaxFun::RegisterFunction(BuiltinFunctions &set) {
 	AggregateFunctionSet fun("argmax");
-	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::INTEGER, fun);
-	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::BIGINT, fun);
-	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::DOUBLE, fun);
-	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::VARCHAR, fun);
-	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::DATE, fun);
-	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::TIMESTAMP, fun);
-	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::TIMESTAMP_TZ, fun);
-	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::BLOB, fun);
+	AddArgMinMaxFunctions<NumericArgMaxOperation, StringArgMaxOperation>(fun);
 	set.AddFunction(fun);
 
 	//! Add max_by alias

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "31ae8ed9a"
-#define DUCKDB_VERSION "v0.3.3-dev1439"
+#define DUCKDB_SOURCE_ID "eb19f35fa"
+#define DUCKDB_VERSION "v0.3.3-dev1441"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //