duckdb 0.3.3-dev440.0 → 0.3.3-dev471.0

package/Makefile

@@ -18,6 +18,8 @@ clean:
 	rm -f test/support/big.db-journal
 	rm -rf ./node_modules/
 	rm -rf src/duckdb.*
+	rm -rf src/parquet-amalgamation.*
+
 
 test:
 	npm test

package/binding.gyp

@@ -61,14 +61,14 @@
                     },
                 ],  # OS=="win"
             ],  # conditions
-            # uncomment this to build against existing lib
-            # "libraries": [
-            #     "/Users/hannes/source/duckdb/build/release/src/libduckdb_static.a",
-            #     "/Users/hannes/source/duckdb/build/release/third_party/fmt/libfmt.a",
-            #     "/Users/hannes/source/duckdb/build/release/third_party/libpg_query/libpg_query.a",
-            #     "/Users/hannes/source/duckdb/build/release/third_party/utf8proc/libutf8proc.a",
-            #     "/Users/hannes/source/duckdb/build/release/third_party/re2/libduckdb_re2.a"
-            # ]
+          #  uncomment this to build against existing lib
+#             "libraries": [
+#                 "/Users/hannes/source/duckdb/build/release/src/libduckdb_static.a",
+#                 "/Users/hannes/source/duckdb/build/release/third_party/fmt/libduckdb_fmt.a",
+#                 "/Users/hannes/source/duckdb/build/release/third_party/libpg_query/libduckdb_pg_query.a",
+#                 "/Users/hannes/source/duckdb/build/release/third_party/utf8proc/libduckdb_utf8proc.a",
+#                 "/Users/hannes/source/duckdb/build/release/third_party/re2/libduckdb_re2.a"
+#             ]
         },
         {
             "target_name": "action_after_build",

package/lib/duckdb.js

@@ -23,42 +23,130 @@ Connection.prototype.each = function(sql) {
     return statement.each.apply(statement, arguments);
 }
 
-Database.prototype.prepare = function() {
-    if (this.default_connection == undefined) {
-        this.default_connection = new duckdb.Connection(this);
+function ptr_to_arr(buffer, ptype, n) {
+    // TODO can we create those on the C++ side of things already?
+    switch(ptype) {
+        case 'BOOL':
+        case 'UINT8':
+            return new Uint8Array(buffer.buffer, 0, n);
+        case 'INT8':
+            return new Int8Array(buffer.buffer, 0, n);
+        case 'INT16':
+            return new Int16Array(buffer.buffer, 0, n);
+        case 'UINT16':
+            return new UInt16Array(buffer.buffer, 0, n);
+        case 'INT32':
+            return new Int32Array(buffer.buffer, 0, n);
+        case 'UINT32':
+            return new UInt32Array(buffer.buffer, 0, n);
+        case 'FLOAT':
+            return new Float32Array(buffer.buffer, 0, n);
+        case 'DOUBLE':
+            return new Float64Array(buffer.buffer, 0, n);
+        case 'VARCHAR':  // we already have created a string array on the C++ side for this
+            return buffer;
+        default:
+            return new Array<string>(0); // cough
     }
-    return this.default_connection.prepare.apply(this.default_connection, arguments);
 }
 
-Database.prototype.run = function() {
-    if (this.default_connection == undefined) {
-        this.default_connection = new Connection(this);
+// this follows the wasm udfs somewhat but is simpler because we can pass data much more cleanly
+Connection.prototype.register = function(name, return_type, fun) {
+    // TODO what if this throws an error somewhere? do we need a try/catch?
+    return this.register_bulk(name, return_type, function(descr) {
+        try {
+            const data_arr = [];
+            const validity_arr = [];
+
+            for (const idx in descr.args) {
+                const arg = descr.args[idx];
+                validity_arr.push(arg.data_buffers[arg.validity_buffer]);
+                data_arr.push(ptr_to_arr(arg.data_buffers[arg.data_buffer], arg.physical_type, descr.rows));
+            }
+
+            const out_data = ptr_to_arr(descr.ret.data_buffers[descr.ret.data_buffer], descr.ret.physical_type, descr.rows);
+            const out_validity = descr.ret.data_buffers[descr.ret.validity_buffer];
+
+            switch (descr.args.length) {
+                case 0:
+                    for (let i = 0; i < descr.rows; ++i) {
+                        const res = fun();
+                        out_data[i] = res;
+                        out_validity[i] = res == undefined || res == null ? 0 : 1;
+                    }
+                    break;
+                case 1:
+                    for (let i = 0; i < descr.rows; ++i) {
+                        const res = fun(validity_arr[0][i] ? data_arr[0][i] : undefined);
+                        out_data[i] = res;
+                        out_validity[i] = res == undefined || res == null ? 0 : 1;
+                    }
+                    break;
+                case 2:
+                    for (let i = 0; i < descr.rows; ++i) {
+                        const res = fun(validity_arr[0][i] ? data_arr[0][i] : undefined, validity_arr[1][i] ? data_arr[1][i] : undefined);
+                        out_data[i] = res;
+                        out_validity[i] = res == undefined || res == null ? 0 : 1;
+                    }
+                    break;
+                case 3:
+                    for (let i = 0; i < descr.rows; ++i) {
+                        const res = fun(validity_arr[0][i] ? data_arr[0][i] : undefined, validity_arr[1][i] ? data_arr[1][i] : undefined, validity_arr[2][i] ? data_arr[2][i] : undefined);
+                        out_data[i] = res;
+                        out_validity[i] = res == undefined || res == null ? 0 : 1;
+                    }
+                    break;
+                default:
+                    throw "Unsupported argument count";
+            }
+        } catch(error) { // work around recently fixed napi bug https://github.com/nodejs/node-addon-api/issues/912
+            msg = error;
+            if (typeof error == 'object' && 'message' in error) {
+                msg = error.message
+            }
+            throw {name: 'DuckDB-UDF-Exception', message : msg};
+        }
+    })
+}
+
+default_connection = function(o) {
+    if (o.default_connection == undefined) {
+        o.default_connection = new duckdb.Connection(o);
     }
-    this.default_connection.run.apply(this.default_connection, arguments);
+    return(o.default_connection);
+}
+
+Database.prototype.prepare = function() {
+    return default_connection(this).prepare.apply(this.default_connection, arguments);
+}
+
+Database.prototype.run = function() {
+    default_connection(this).run.apply(this.default_connection, arguments);
     return this;
 }
 
 Database.prototype.each = function() {
-    if (this.default_connection == undefined) {
-        this.default_connection = new Connection(this);
-    }
-    this.default_connection.each.apply(this.default_connection, arguments);
+    default_connection(this).each.apply(this.default_connection, arguments);
     return this;
 }
 
 Database.prototype.all = function() {
-    if (this.default_connection == undefined) {
-        this.default_connection = new Connection(this);
-    }
-    this.default_connection.all.apply(this.default_connection, arguments);
+    default_connection(this).all.apply(this.default_connection, arguments);
     return this;
 }
 
 Database.prototype.exec = function() {
-    if (this.default_connection == undefined) {
-        this.default_connection = new Connection(this);
-    }
-    this.default_connection.exec.apply(this.default_connection, arguments);
+    default_connection(this).exec.apply(this.default_connection, arguments);
+    return this;
+}
+
+Database.prototype.register = function() {
+    default_connection(this).register.apply(this.default_connection, arguments);
+    return this;
+}
+
+Database.prototype.unregister = function() {
+    default_connection(this).unregister.apply(this.default_connection, arguments);
     return this;
 }
 

package/package.json

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

package/src/connection.cpp

@@ -1,5 +1,7 @@
 #include "duckdb_node.hpp"
 
+#include <thread>
+
 namespace node_duckdb {
 
 Napi::FunctionReference Connection::constructor;
@@ -9,7 +11,9 @@ Napi::Object Connection::Init(Napi::Env env, Napi::Object exports) {
 
 	Napi::Function t =
 	    DefineClass(env, "Connection",
-	                {InstanceMethod("prepare", &Connection::Prepare), InstanceMethod("exec", &Connection::Exec)});
+	                {InstanceMethod("prepare", &Connection::Prepare), InstanceMethod("exec", &Connection::Exec),
+	                 InstanceMethod("register_bulk", &Connection::Register),
+	                 InstanceMethod("unregister", &Connection::Unregister)});
 
 	constructor = Napi::Persistent(t);
 	constructor.SuppressDestruct();
@@ -66,6 +70,275 @@ Napi::Value Connection::Prepare(const Napi::CallbackInfo &info) {
 	return res->Value();
 }
 
+struct JSArgs {
+	duckdb::idx_t rows;
+	duckdb::DataChunk *args;
+	duckdb::Vector *result;
+	bool done;
+	std::string error;
+};
+
+static Napi::Value transform_vector(Napi::Env env, duckdb::Vector &vec, duckdb::idx_t rows, bool copy) {
+	Napi::EscapableHandleScope scope(env);
+
+	Napi::Array data_buffers(Napi::Array::New(env));
+
+	auto data_buffer_index = -1;
+	auto length_buffer_index = -1;
+	auto validity_buffer_index = -1;
+
+	auto validity_buffer = Napi::Buffer<uint8_t>::New(env, rows);
+	auto validity = duckdb::FlatVector::Validity(vec);
+	auto validity_ptr = validity_buffer.Data();
+	for (duckdb::idx_t row_idx = 0; row_idx < rows; row_idx++) {
+		validity_ptr[row_idx] = validity.RowIsValid(row_idx);
+	}
+	data_buffers.Set(data_buffers.Length(), validity_buffer);
+	validity_buffer_index = data_buffers.Length() - 1;
+
+	auto &vec_type = vec.GetType();
+
+	switch (vec_type.id()) {
+	case duckdb::LogicalTypeId::BOOLEAN:
+	case duckdb::LogicalTypeId::UTINYINT:
+	case duckdb::LogicalTypeId::TINYINT:
+	case duckdb::LogicalTypeId::USMALLINT:
+	case duckdb::LogicalTypeId::SMALLINT:
+	case duckdb::LogicalTypeId::INTEGER:
+	case duckdb::LogicalTypeId::UINTEGER:
+	case duckdb::LogicalTypeId::FLOAT:
+	case duckdb::LogicalTypeId::DOUBLE: {
+		auto data_buffer = Napi::Buffer<uint8_t>::New(env, rows * duckdb::GetTypeIdSize(vec_type.InternalType()));
+		// TODO this is technically not neccessary but it fixes a crash in Node 14. Some weird data ownership issue.
+		memcpy(data_buffer.Data(), duckdb::FlatVector::GetData<uint8_t>(vec),
+		       rows * duckdb::GetTypeIdSize(vec_type.InternalType()));
+
+		data_buffers.Set(data_buffers.Length(), data_buffer);
+		data_buffer_index = data_buffers.Length() - 1;
+		break;
+	}
+	case duckdb::LogicalTypeId::VARCHAR: {
+		Napi::Array string_buffers(Napi::Array::New(env, rows));
+		if (copy) {
+			auto string_vec_ptr = duckdb::FlatVector::GetData<duckdb::string_t>(vec);
+			for (duckdb::idx_t row_idx = 0; row_idx < rows; row_idx++) {
+				string_buffers.Set(row_idx, validity_ptr[row_idx]
+				                                ? Napi::String::New(env, string_vec_ptr[row_idx].GetDataUnsafe(),
+				                                                    string_vec_ptr[row_idx].GetSize())
+				                                : Napi::Value());
+			}
+		}
+		data_buffers.Set(data_buffers.Length(), string_buffers);
+		data_buffer_index = data_buffers.Length() - 1;
+		break;
+	}
+	default:
+		throw duckdb::NotImplementedException(vec_type.ToString());
+	}
+
+	Napi::Object desc(Napi::Object::New(env));
+	desc.Set("logical_type", vec_type.ToString());
+	desc.Set("physical_type", TypeIdToString(vec_type.InternalType()));
+	desc.Set("validity_buffer", validity_buffer_index);
+	desc.Set("data_buffer", data_buffer_index);
+	desc.Set("length_buffer", length_buffer_index);
+	desc.Set("data_buffers", data_buffers);
+
+	return scope.Escape(desc);
+}
+
+void DuckDBNodeUDFLauncher(Napi::Env env, Napi::Function jsudf, nullptr_t *, JSArgs *jsargs) {
+	try { // if we dont catch exceptions here we terminate node if one happens ^^
+
+		// set up descriptor and data arrays
+		Napi::Array args_descr(Napi::Array::New(env, jsargs->args->ColumnCount()));
+		for (duckdb::idx_t col_idx = 0; col_idx < jsargs->args->ColumnCount(); col_idx++) {
+			auto &vec = jsargs->args->data[col_idx];
+			auto arg_descr = transform_vector(env, vec, jsargs->rows, true);
+			args_descr.Set(col_idx, arg_descr);
+		}
+		auto ret_descr = transform_vector(env, *jsargs->result, jsargs->rows, false);
+
+		Napi::Object descr(Napi::Object::New(env));
+		descr.Set("rows", jsargs->rows);
+		descr.Set("args", args_descr);
+		descr.Set("ret", ret_descr);
+
+		// actually call the UDF, or rather its vectorized wrapper from duckdb.js/Connection.prototype.register wrapper
+		jsudf({descr});
+
+		if (env.IsExceptionPending()) {
+			// bit of a dance to get a nice error message if possible
+			auto exception = env.GetAndClearPendingException();
+			std::string msg = exception.Message();
+			if (msg.empty()) {
+				auto exception_value = exception.Value();
+				if (exception_value.IsObject() && exception_value.Has("message")) {
+					msg = exception_value.Get("message").ToString().Utf8Value();
+				}
+			}
+			throw duckdb::IOException("UDF Execution Error: " + msg);
+		}
+
+		// transform the result back to a vector
+		auto return_validity = ret_descr.ToObject()
+		                           .Get("data_buffers")
+		                           .ToObject()
+		                           .Get(ret_descr.ToObject().Get("validity_buffer"))
+		                           .As<Napi::Buffer<uint8_t>>();
+		for (duckdb::idx_t row_idx = 0; row_idx < jsargs->rows; row_idx++) {
+			duckdb::FlatVector::SetNull(*jsargs->result, row_idx, !return_validity[row_idx]);
+		}
+
+		if (jsargs->result->GetType().id() == duckdb::LogicalTypeId::VARCHAR) {
+			auto return_string_array = ret_descr.ToObject()
+			                               .Get("data_buffers")
+			                               .ToObject()
+			                               .Get(ret_descr.ToObject().Get("data_buffer"))
+			                               .ToObject();
+			auto return_string_vec_ptr = duckdb::FlatVector::GetData<duckdb::string_t>(*jsargs->result);
+
+			for (duckdb::idx_t row_idx = 0; row_idx < jsargs->rows; row_idx++) {
+				if (!return_validity[row_idx]) {
+					duckdb::FlatVector::SetNull(*jsargs->result, row_idx, true);
+				} else {
+					auto str = return_string_array.Get(row_idx).As<Napi::String>();
+					return_string_vec_ptr[row_idx] = duckdb::StringVector::AddString(*jsargs->result, str);
+				}
+			}
+		} else {
+			auto return_data = ret_descr.ToObject()
+			                       .Get("data_buffers")
+			                       .ToObject()
+			                       .Get(ret_descr.ToObject().Get("data_buffer"))
+			                       .As<Napi::Buffer<uint8_t>>();
+			memcpy(duckdb::FlatVector::GetData<uint8_t>(*jsargs->result), return_data.Data(),
+			       jsargs->rows * duckdb::GetTypeIdSize(jsargs->result->GetType().InternalType()));
+		}
+	} catch (const std::exception &e) {
+		jsargs->error = e.what();
+	}
+	jsargs->done = true;
+}
+
+struct RegisterTask : public Task {
+	RegisterTask(Connection &connection_, std::string name_, std::string return_type_name_, Napi::Function callback_)
+	    : Task(connection_, callback_), name(name_), return_type_name(return_type_name_) {
+	}
+
+	void DoWork() override {
+		auto &connection = Get<Connection>();
+		auto &udf_ptr = connection.udfs[name];
+		duckdb::scalar_function_t udf_function = [&udf_ptr](duckdb::DataChunk &args, duckdb::ExpressionState &state,
+		                                                    duckdb::Vector &result) -> void {
+			// here we can do only DuckDB stuff because we do not have a functioning env
+
+			// Flatten all args to simplify udfs
+			args.Normalify();
+
+			JSArgs jsargs;
+			jsargs.rows = args.size();
+			jsargs.args = &args;
+			jsargs.result = &result;
+			jsargs.done = false;
+
+			udf_ptr.BlockingCall(&jsargs);
+			while (!jsargs.done) {
+				std::this_thread::yield();
+			}
+			if (!jsargs.error.empty()) {
+				throw duckdb::IOException(jsargs.error);
+			}
+		};
+
+		auto expr = duckdb::Parser::ParseExpressionList(duckdb::StringUtil::Format("asdf::%s", return_type_name));
+		auto &cast = (duckdb::CastExpression &)*expr[0];
+		auto return_type = cast.cast_type;
+
+		connection.connection->CreateVectorizedFunction(name, std::vector<duckdb::LogicalType> {}, return_type,
+		                                                udf_function, duckdb::LogicalType::ANY);
+	}
+	std::string name;
+	std::string return_type_name;
+};
+
+Napi::Value Connection::Register(const Napi::CallbackInfo &info) {
+	auto env = info.Env();
+	if (info.Length() < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsFunction()) {
+		Napi::TypeError::New(env, "Holding it wrong").ThrowAsJavaScriptException();
+		return env.Null();
+	}
+
+	std::string name = info[0].As<Napi::String>();
+	std::string return_type_name = info[1].As<Napi::String>();
+	Napi::Function udf_callback = info[2].As<Napi::Function>();
+	Napi::Function completion_callback;
+	if (info.Length() > 3 && info[3].IsFunction()) {
+		completion_callback = info[3].As<Napi::Function>();
+	}
+
+	if (udfs.find(name) != udfs.end()) {
+		Napi::TypeError::New(env, "UDF with this name already exists").ThrowAsJavaScriptException();
+		return env.Null();
+	}
+
+	auto udf = DuckDBNodeUDFFUnction::New(env, udf_callback, "duckdb_node_udf" + name, 0, 1, nullptr,
+	                                      [](Napi::Env, void *, nullptr_t *ctx) {});
+
+	// we have to unref the udf because otherwise there is a circular ref with the connection somehow(?)
+	// this took far too long to figure out
+	udf.Unref(env);
+	udfs[name] = udf;
+
+	database_ref->Schedule(info.Env(),
+	                       duckdb::make_unique<RegisterTask>(*this, name, return_type_name, completion_callback));
+
+	return Value();
+}
+
+struct UnregisterTask : public Task {
+	UnregisterTask(Connection &connection_, std::string name_, Napi::Function callback_)
+	    : Task(connection_, callback_), name(name_) {
+	}
+
+	void DoWork() override {
+		auto &connection = Get<Connection>();
+		if (connection.udfs.find(name) == connection.udfs.end()) { // silently ignore
+			return;
+		}
+
+		connection.udfs[name].Release();
+		connection.udfs.erase(name);
+		auto &con = *connection.connection;
+		con.BeginTransaction();
+		auto &context = *con.context;
+		auto &catalog = duckdb::Catalog::GetCatalog(context);
+		duckdb::DropInfo info;
+		info.type = duckdb::CatalogType::SCALAR_FUNCTION_ENTRY;
+		info.name = name;
+		catalog.DropEntry(context, &info);
+		con.Commit();
+	}
+	std::string name;
+};
+
+Napi::Value Connection::Unregister(const Napi::CallbackInfo &info) {
+	auto env = info.Env();
+	if (info.Length() < 1 || !info[0].IsString()) {
+		Napi::TypeError::New(env, "Holding it wrong").ThrowAsJavaScriptException();
+		return env.Null();
+	}
+	std::string name = info[0].As<Napi::String>();
+
+	Napi::Function callback;
+	if (info.Length() > 1 && info[1].IsFunction()) {
+		callback = info[1].As<Napi::Function>();
+	}
+
+	database_ref->Schedule(info.Env(), duckdb::make_unique<UnregisterTask>(*this, name, callback));
+	return Value();
+}
+
 struct ExecTask : public Task {
 	ExecTask(Connection &connection_, std::string sql_, Napi::Function callback_)
 	    : Task(connection_, callback_), sql(sql_) {

package/src/database.cpp

@@ -28,6 +28,7 @@ struct OpenTask : public Task {
 
 	void DoWork() override {
 		try {
+
 			Get<Database>().database = duckdb::make_unique<duckdb::DuckDB>(filename);
 			duckdb::ParquetExtension extension;
 			extension.Load(*Get<Database>().database);

package/src/duckdb.cpp

@@ -44384,6 +44384,9 @@ static bool BlobCastSwitch(Vector &source, Vector &result, idx_t count, string *
 		// blob to varchar
 		VectorStringCast<string_t, duckdb::CastFromBlob>(source, result, count);
 		break;
+	case LogicalTypeId::AGGREGATE_STATE:
+		result.Reinterpret(source);
+		break;
 	default:
 		return TryVectorNullCast(source, result, count, error_message);
 	}
@@ -44572,6 +44575,15 @@ static bool EnumCastSwitch(Vector &source, Vector &result, idx_t count, string *
 	return true;
 }
 
+static bool AggregateStateToBlobCast(Vector &source, Vector &result, idx_t count, string *error_message, bool strict) {
+	if (result.GetType().id() != LogicalTypeId::BLOB) {
+		throw TypeMismatchException(source.GetType(), result.GetType(),
+		                            "Cannot cast AGGREGATE_STATE to anything but BLOB");
+	}
+	result.Reinterpret(source);
+	return true;
+}
+
 static bool StructCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
 	switch (result.GetType().id()) {
 	case LogicalTypeId::STRUCT:
@@ -44687,6 +44699,8 @@ bool VectorOperations::TryCast(Vector &source, Vector &result, idx_t count, stri
 		return ListCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::ENUM:
 		return EnumCastSwitch(source, result, count, error_message, strict);
+	case LogicalTypeId::AGGREGATE_STATE:
+		return AggregateStateToBlobCast(source, result, count, error_message, strict);
 	default:
 		return TryVectorNullCast(source, result, count, error_message);
 	}
@@ -69315,6 +69329,10 @@ struct VarianceFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct StandardErrorOfTheMeanFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -69909,6 +69927,20 @@ struct STDDevPopOperation : public STDDevBaseOperation {
 		}
 	}
 };
+
+struct StandardErrorOfTheMeanOperation : public STDDevBaseOperation {
+	template <class T, class STATE>
+	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+		if (state->count == 0) {
+			mask.SetInvalid(idx);
+		} else {
+			target[idx] = sqrt(state->dsquared / state->count) / sqrt((state->count));
+			if (!Value::DoubleIsValid(target[idx])) {
+				throw OutOfRangeException("SEM is out of range!");
+			}
+		}
+	}
+};
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -70070,6 +70102,13 @@ void VarianceFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(var_samp);
 }
 
+void StandardErrorOfTheMeanFun::RegisterFunction(BuiltinFunctions &set) {
+	AggregateFunctionSet sem("sem");
+	sem.AddFunction(AggregateFunction::UnaryAggregate<StddevState, double, double, StandardErrorOfTheMeanOperation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE));
+	set.AddFunction(sem);
+}
+
 } // namespace duckdb
 
 
@@ -70087,7 +70126,7 @@ void BuiltinFunctions::RegisterAlgebraicAggregates() {
 	Register<VarPopFun>();
 	Register<VarSampFun>();
 	Register<VarianceFun>();
-
+	Register<StandardErrorOfTheMeanFun>();
 	Register<Corr>();
 }
 
@@ -71244,7 +71283,7 @@ struct FirstFunctionString : public FirstFunctionBase {
 		if (!state->is_set || state->is_null) {
 			mask.SetInvalid(idx);
 		} else {
-			target[idx] = StringVector::AddString(result, state->value);
+			target[idx] = StringVector::AddStringOrBlob(result, state->value);
 		}
 	}
 
@@ -92902,9 +92941,13 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 
 	D_ASSERT(input.data.size() == 2);
 	D_ASSERT(input.data[0].GetType().id() == LogicalTypeId::AGGREGATE_STATE);
-	D_ASSERT(input.data[0].GetType() == input.data[1].GetType());
 	D_ASSERT(input.data[0].GetType() == result.GetType());
 
+	if (input.data[0].GetType().InternalType() != input.data[1].GetType().InternalType()) {
+		throw IOException("Aggregate state combine type mismatch, expect %s, got %s",
+		                  input.data[0].GetType().ToString(), input.data[1].GetType().ToString());
+	}
+
 	VectorData state0_data, state1_data;
 	input.data[0].Orrify(input.size(), state0_data);
 	input.data[1].Orrify(input.size(), state1_data);
@@ -92935,8 +92978,10 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 		}
 
 		// we actually have to combine
-		D_ASSERT(state0.GetSize() == bind_data.state_size);
-		D_ASSERT(state1.GetSize() == bind_data.state_size);
+		if (state0.GetSize() != bind_data.state_size || state1.GetSize() != bind_data.state_size) {
+			throw IOException("Aggregate state size mismatch, expect %llu, got %llu and %llu", bind_data.state_size,
+			                  state0.GetSize(), state1.GetSize());
+		}
 
 		memcpy(local_state.state_buffer0.get(), state0.GetDataUnsafe(), bind_data.state_size);
 		memcpy(local_state.state_buffer1.get(), state1.GetDataUnsafe(), bind_data.state_size);
@@ -92963,7 +93008,8 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 		throw BinderException("Can only FINALIZE aggregate state, not %s", arg_return_type.ToString());
 	}
 	// combine
-	if (arguments.size() == 2 && arguments[0]->return_type != arguments[1]->return_type) {
+	if (arguments.size() == 2 && arguments[0]->return_type != arguments[1]->return_type &&
+	    arguments[1]->return_type.id() != LogicalTypeId::BLOB) {
 		throw BinderException("Cannot COMBINE aggregate states from different functions, %s <> %s",
 		                      arguments[0]->return_type.ToString(), arguments[1]->return_type.ToString());
 	}
@@ -93069,7 +93115,7 @@ ScalarFunction ExportAggregateFunction::GetFinalize() {
 }
 
 ScalarFunction ExportAggregateFunction::GetCombine() {
-	return ScalarFunction("combine", {LogicalTypeId::AGGREGATE_STATE, LogicalTypeId::AGGREGATE_STATE},
+	return ScalarFunction("combine", {LogicalTypeId::AGGREGATE_STATE, LogicalTypeId::ANY},
 	                      LogicalTypeId::AGGREGATE_STATE, AggregateStateCombine, false, BindAggregateState, nullptr,
 	                      nullptr, InitCombineState);
 }

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 "f7a783d93"
-#define DUCKDB_VERSION "v0.3.3-dev440"
+#define DUCKDB_SOURCE_ID "fbe58d359"
+#define DUCKDB_VERSION "v0.3.3-dev471"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //