duckdb 0.6.1-dev86.0 → 0.6.2-dev6.0

package/package.json

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

package/src/connection.cpp

@@ -63,41 +63,6 @@ struct NodeReplacementScanData : duckdb::ReplacementScanData {
 	Connection *connection_ref;
 };
 
-static duckdb::unique_ptr<duckdb::TableFunctionRef>
-ScanReplacement(duckdb::ClientContext &context, const std::string &table_name, duckdb::ReplacementScanData *data) {
-	auto &buffers = ((NodeReplacementScanData *)data)->connection_ref->buffers;
-	// Lookup buffer
-	auto lookup = buffers.find(table_name);
-	if (lookup == buffers.end()) {
-		return nullptr;
-	}
-
-	// Create table scan on ipc buffers
-	auto name = lookup->first;
-	auto ipc_buffer_array = lookup->second;
-
-	auto table_function = duckdb::make_unique<duckdb::TableFunctionRef>();
-	std::vector<duckdb::unique_ptr<duckdb::ParsedExpression>> table_fun_children;
-
-	duckdb::vector<duckdb::Value> list_children;
-
-	for (uint64_t ipc_idx = 0; ipc_idx < ipc_buffer_array.size(); ipc_idx++) {
-		auto &v = ipc_buffer_array[ipc_idx];
-		duckdb::child_list_t<duckdb::Value> struct_children;
-		struct_children.push_back(make_pair("ptr", duckdb::Value::UBIGINT(v.first)));
-		struct_children.push_back(make_pair("size", duckdb::Value::UBIGINT(v.second)));
-
-		// Push struct into table fun
-		list_children.push_back(duckdb::Value::STRUCT(move(struct_children)));
-	}
-
-	table_fun_children.push_back(
-	    duckdb::make_unique<duckdb::ConstantExpression>(duckdb::Value::LIST(move(list_children))));
-	table_function->function =
-	    duckdb::make_unique<duckdb::FunctionExpression>("scan_arrow_ipc", move(table_fun_children));
-	return table_function;
-}
-
 Connection::Connection(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Connection>(info) {
 	Napi::Env env = info.Env();
 	int length = info.Length();
@@ -339,70 +304,6 @@ Napi::Value Connection::RegisterUdf(const Napi::CallbackInfo &info) {
 	return Value();
 }
 
-// Register Arrow IPC buffers for scanning from DuckDB
-Napi::Value Connection::RegisterBuffer(const Napi::CallbackInfo &info) {
-	auto env = info.Env();
-
-	Napi::TypeError::New(env, "Register buffer currently not implemented").ThrowAsJavaScriptException();
-	return env.Null();
-
-	if (info.Length() < 2 || !info[0].IsString() || !info[1].IsObject()) {
-		Napi::TypeError::New(env, "Incorrect params").ThrowAsJavaScriptException();
-		return env.Null();
-	}
-
-	std::string name = info[0].As<Napi::String>();
-	Napi::Array array = info[1].As<Napi::Array>();
-	bool force_register = false;
-
-	if (info.Length() > 2) {
-		if (!info[2].IsBoolean()) {
-			Napi::TypeError::New(env, "Incorrect params").ThrowAsJavaScriptException();
-			return env.Null();
-		}
-		force_register = info[2].As<Napi::Boolean>().Value();
-	}
-
-	array_references[name] = Napi::Persistent(array);
-
-	if (!force_register && buffers.find(name) != buffers.end()) {
-		Napi::TypeError::New(env, "Buffer with this name already exists").ThrowAsJavaScriptException();
-		return env.Null();
-	}
-
-	buffers[name] = std::vector<std::pair<uint64_t, uint64_t>>();
-
-	for (uint64_t ipc_idx = 0; ipc_idx < array.Length(); ipc_idx++) {
-		Napi::Value v = array[ipc_idx];
-		if (!v.IsObject()) {
-			Napi::TypeError::New(env, "Incorrect params").ThrowAsJavaScriptException();
-			return env.Null();
-		}
-		Napi::Uint8Array arr = v.As<Napi::Uint8Array>();
-		auto raw_ptr = reinterpret_cast<uint64_t>(arr.ArrayBuffer().Data());
-		auto length = (uint64_t)arr.ElementLength();
-
-		buffers[name].push_back(std::pair<uint64_t, uint64_t>({raw_ptr, length}));
-	}
-
-	return Value();
-}
-
-Napi::Value Connection::UnRegisterBuffer(const Napi::CallbackInfo &info) {
-	auto env = info.Env();
-
-	Napi::TypeError::New(env, "Register buffer currently not implemented").ThrowAsJavaScriptException();
-	return env.Null();
-
-	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>();
-	buffers.erase(name);
-	return Value();
-}
-
 struct UnregisterUdfTask : public Task {
 	UnregisterUdfTask(Connection &connection, std::string name, Napi::Function callback)
 	    : Task(connection, callback), name(std::move(name)) {
@@ -487,6 +388,20 @@ struct ExecTask : public Task {
 	duckdb::PreservedError error;
 };
 
+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) {
+	}
+
+	void Callback() override {
+		cpp_callback();
+		ExecTask::Callback();
+	};
+
+	std::function<void(void)> cpp_callback;
+};
+
 Napi::Value Connection::Exec(const Napi::CallbackInfo &info) {
 	auto env = info.Env();
 
@@ -506,4 +421,90 @@ Napi::Value Connection::Exec(const Napi::CallbackInfo &info) {
 	return Value();
 }
 
+// Register Arrow IPC buffers for scanning from DuckDB
+Napi::Value Connection::RegisterBuffer(const Napi::CallbackInfo &info) {
+	auto env = info.Env();
+
+	if (info.Length() < 2 || !info[0].IsString() || !info[1].IsObject()) {
+		Napi::TypeError::New(env, "Incorrect params").ThrowAsJavaScriptException();
+		return env.Null();
+	}
+
+	std::string name = info[0].As<Napi::String>();
+	Napi::Array array = info[1].As<Napi::Array>();
+	bool force_register = false;
+
+	if (info.Length() > 2) {
+		if (!info[2].IsBoolean()) {
+			Napi::TypeError::New(env, "Parameter 3 is of unexpected type. Expected boolean")
+			    .ThrowAsJavaScriptException();
+			return env.Null();
+		}
+		force_register = info[2].As<Napi::Boolean>().Value();
+	}
+
+	if (!force_register && array_references.find(name) != array_references.end()) {
+		Napi::TypeError::New(env, "Buffer with this name already exists and force_register is not enabled")
+		    .ThrowAsJavaScriptException();
+		return env.Null();
+	}
+
+	array_references[name] = Napi::Persistent(array);
+
+	std::string arrow_scan_function = "scan_arrow_ipc([";
+
+	for (uint64_t ipc_idx = 0; ipc_idx < array.Length(); ipc_idx++) {
+		Napi::Value v = array[ipc_idx];
+		if (!v.IsObject()) {
+			Napi::TypeError::New(env, "Parameter 2 contains unexpected type at index " + std::to_string(ipc_idx))
+			    .ThrowAsJavaScriptException();
+			return env.Null();
+		}
+		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) + ", 'size': " + std::to_string(length) + "},";
+	}
+	arrow_scan_function += "])";
+
+	std::string final_query = "CREATE OR REPLACE TEMPORARY VIEW " + name + " AS SELECT * FROM " + arrow_scan_function;
+
+	Napi::Function callback;
+	if (info.Length() > 3 && info[3].IsFunction()) {
+		callback = info[3].As<Napi::Function>();
+	}
+
+	database_ref->Schedule(info.Env(), duckdb::make_unique<ExecTask>(*this, final_query, callback));
+
+	return Value();
+}
+
+Napi::Value Connection::UnRegisterBuffer(const Napi::CallbackInfo &info) {
+	auto env = info.Env();
+
+	if (info.Length() < 1 || !info[0].IsString()) {
+		Napi::TypeError::New(env, "Incorrect params").ThrowAsJavaScriptException();
+		return env.Null();
+	}
+	std::string name = info[0].As<Napi::String>();
+
+	std::string final_query = "DROP VIEW IF EXISTS " + name;
+
+	Napi::Function callback;
+	if (info.Length() > 1 && info[1].IsFunction()) {
+		callback = info[1].As<Napi::Function>();
+	}
+
+	// When query succeeds we can safely delete the ref
+	std::function<void(void)> cpp_callback = [&, name]() {
+		array_references.erase(name);
+	};
+
+	database_ref->Schedule(info.Env(),
+	                       duckdb::make_unique<ExecTaskWithCallback>(*this, final_query, callback, cpp_callback));
+
+	return Value();
+}
+
 } // namespace node_duckdb