duckdb 1.2.0 → 1.2.1-dev6.0

package/package.json

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

package/src/connection.cpp

@@ -4,6 +4,10 @@
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/parser/parsed_data/drop_info.hpp"
 #include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/common/types/value.hpp"
+#include "duckdb/main/relation/table_function_relation.hpp"
+
+
 #include <iostream>
 #include <thread>
 
@@ -13,12 +17,12 @@ Napi::FunctionReference Connection::Init(Napi::Env env, Napi::Object exports) {
 	Napi::HandleScope scope(env);
 
 	Napi::Function t = DefineClass(
-	    env, "Connection",
-	    {InstanceMethod("prepare", &Connection::Prepare), InstanceMethod("exec", &Connection::Exec),
-	     InstanceMethod("register_udf_bulk", &Connection::RegisterUdf),
-	     InstanceMethod("register_buffer", &Connection::RegisterBuffer),
-	     InstanceMethod("unregister_udf", &Connection::UnregisterUdf), InstanceMethod("close", &Connection::Close),
-	     InstanceMethod("unregister_buffer", &Connection::UnRegisterBuffer)});
+		env, "Connection",
+		{InstanceMethod("prepare", &Connection::Prepare), InstanceMethod("exec", &Connection::Exec),
+		 InstanceMethod("register_udf_bulk", &Connection::RegisterUdf),
+		 InstanceMethod("register_buffer", &Connection::RegisterBuffer),
+		 InstanceMethod("unregister_udf", &Connection::UnregisterUdf), InstanceMethod("close", &Connection::Close),
+		 InstanceMethod("unregister_buffer", &Connection::UnRegisterBuffer)});
 
 	exports.Set("Connection", t);
 
@@ -230,14 +234,14 @@ void DuckDBNodeUDFLauncher(Napi::Env env, Napi::Function jsudf, std::nullptr_t *
 
 struct RegisterUdfTask : public Task {
 	RegisterUdfTask(Connection &connection, std::string name, std::string return_type_name, Napi::Function callback)
-	    : Task(connection, callback), name(std::move(name)), return_type_name(std::move(return_type_name)) {
+		: Task(connection, callback), name(std::move(name)), return_type_name(std::move(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 {
+															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
@@ -267,7 +271,7 @@ struct RegisterUdfTask : public Task {
 		auto return_type = cast.cast_type;
 
 		connection.connection->CreateVectorizedFunction(name, vector<duckdb::LogicalType> {}, return_type, udf_function,
-		                                                duckdb::LogicalType::ANY);
+														duckdb::LogicalType::ANY);
 	}
 	std::string name;
 	std::string return_type_name;
@@ -292,7 +296,7 @@ Napi::Value Connection::RegisterUdf(const Napi::CallbackInfo &info) {
 	}
 
 	auto udf = duckdb_node_udf_function_t::New(env, udf_callback, "duckdb_node_udf" + name, 0, 1, nullptr,
-	                                           [](Napi::Env, void *, std::nullptr_t *ctx) {});
+											   [](Napi::Env, void *, std::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
@@ -300,14 +304,14 @@ Napi::Value Connection::RegisterUdf(const Napi::CallbackInfo &info) {
 	udfs[name] = udf;
 
 	database_ref->Schedule(info.Env(),
-	                       duckdb::make_uniq<RegisterUdfTask>(*this, name, return_type_name, completion_callback));
+						   duckdb::make_uniq<RegisterUdfTask>(*this, name, return_type_name, completion_callback));
 
 	return Value();
 }
 
 struct UnregisterUdfTask : public Task {
 	UnregisterUdfTask(Connection &connection, std::string name, Napi::Function callback)
-	    : Task(connection, callback), name(std::move(name)) {
+		: Task(connection, callback), name(std::move(name)) {
 	}
 
 	void DoWork() override {
@@ -350,7 +354,7 @@ Napi::Value Connection::UnregisterUdf(const Napi::CallbackInfo &info) {
 
 struct ExecTask : public Task {
 	ExecTask(Connection &connection, std::string sql, Napi::Function callback)
-	    : Task(connection, callback), sql(std::move(sql)) {
+		: Task(connection, callback), sql(std::move(sql)) {
 	}
 
 	void DoWork() override {
@@ -391,8 +395,8 @@ struct ExecTask : public Task {
 
 struct ExecTaskWithCallback : public ExecTask {
 	ExecTaskWithCallback(Connection &connection, std::string sql, Napi::Function js_callback,
-	                     std::function<void(void)> cpp_callback)
-	    : ExecTask(connection, sql, js_callback), cpp_callback(cpp_callback) {
+						 std::function<void(void)> cpp_callback)
+		: ExecTask(connection, sql, js_callback), cpp_callback(cpp_callback) {
 	}
 
 	void Callback() override {
@@ -451,6 +455,44 @@ Napi::Value Connection::Exec(const Napi::CallbackInfo &info) {
 	return Value();
 }
 
+struct CreateArrowViewTask : public Task {
+	CreateArrowViewTask(Connection &connection, duckdb::vector<duckdb::Value>& parameters, std::string &view_name, Napi::Function callback)
+		: Task(connection, callback), parameters(parameters), view_name(view_name) {
+	}
+
+	void DoWork() override {
+		auto &connection = Get<Connection>();
+		success = true;
+		try {
+			auto &con = *connection.connection;
+			// Now we create a table function relation
+			auto table_function_relation = duckdb::make_shared_ptr<duckdb::TableFunctionRelation>(con.context,"scan_arrow_ipc",parameters);
+			// Creates a relation for a temporary view that does replace
+			auto view_relation = table_function_relation->CreateView(view_name,true,true);
+			auto res = view_relation->Execute();
+			if (res->HasError()) {
+				success = false;
+				error = res->GetErrorObject();
+			}
+		} catch (duckdb::Exception &e) {
+			success = false;
+			error = duckdb::ErrorData(e);
+			return;
+		}
+	}
+
+	void Callback() override {
+		auto env = object.Env();
+		Napi::HandleScope scope(env);
+		callback.Value().MakeCallback(object.Value(), {success ? env.Null() : Utils::CreateError(env, error)});
+	};
+
+	duckdb::vector<duckdb::Value> parameters;
+	std::string view_name;
+	bool success;
+	duckdb::ErrorData error;
+};
+
 // Register Arrow IPC buffers for scanning from DuckDB
 Napi::Value Connection::RegisterBuffer(const Napi::CallbackInfo &info) {
 	auto env = info.Env();
@@ -475,9 +517,10 @@ Napi::Value Connection::RegisterBuffer(const Napi::CallbackInfo &info) {
 	}
 
 	array_references[name] = Napi::Persistent(array);
+	auto &db = *connection->context->db;
 
-	std::string arrow_scan_function = "scan_arrow_ipc([";
-
+	vector<duckdb::Value> values;
+	
 	for (uint64_t ipc_idx = 0; ipc_idx < array.Length(); ipc_idx++) {
 		Napi::Value v = array[ipc_idx];
 		if (!v.IsObject()) {
@@ -486,19 +529,25 @@ Napi::Value Connection::RegisterBuffer(const Napi::CallbackInfo &info) {
 		Napi::Uint8Array arr = v.As<Napi::Uint8Array>();
 		auto raw_ptr = reinterpret_cast<uint64_t>(arr.ArrayBuffer().Data());
 		auto length = (uint64_t)arr.ElementLength();
-
-		arrow_scan_function += "{'ptr': " + std::to_string(raw_ptr) + "::UBIGINT, 'size': " + std::to_string(length) + "::UBIGINT},";
+		duckdb::child_list_t<duckdb::Value> buffer_values;
+		// This is a little bit evil, but allows us to support both libraries in between 1.2 and 1.3
+		if (db.ExtensionIsLoaded("nanoarrow")){
+			buffer_values.push_back({"ptr", duckdb::Value::POINTER(raw_ptr)});
+		} else {
+			buffer_values.push_back({"ptr", duckdb::Value::UBIGINT(raw_ptr)});
+		}
+		buffer_values.push_back({"size", duckdb::Value::UBIGINT(length)});
+		values.push_back(duckdb::Value::STRUCT(buffer_values));
 	}
-	arrow_scan_function += "])";
-
-	std::string final_query = "CREATE OR REPLACE TEMPORARY VIEW " + name + " AS SELECT * FROM " + arrow_scan_function;
+	duckdb::vector<duckdb::Value> list_value;
+	list_value.push_back(duckdb::Value::LIST(values));
 
 	Napi::Function callback;
 	if (info.Length() > 3 && info[3].IsFunction()) {
 		callback = info[3].As<Napi::Function>();
 	}
 
-	database_ref->Schedule(info.Env(), duckdb::make_uniq<ExecTask>(*this, final_query, callback));
+	database_ref->Schedule(info.Env(), duckdb::make_uniq<CreateArrowViewTask>(*this, list_value, name, callback));
 
 	return Value();
 }
@@ -524,7 +573,7 @@ Napi::Value Connection::UnRegisterBuffer(const Napi::CallbackInfo &info) {
 	};
 
 	database_ref->Schedule(info.Env(),
-	                       duckdb::make_uniq<ExecTaskWithCallback>(*this, final_query, callback, cpp_callback));
+						   duckdb::make_uniq<ExecTaskWithCallback>(*this, final_query, callback, cpp_callback));
 
 	return Value();
 }