duckdb 0.6.1-dev131.0 → 0.6.1-dev140.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.6.1-dev131.0",
+  "version": "0.6.1-dev140.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

package/src/duckdb.cpp

@@ -193749,6 +193749,33 @@ unique_ptr<BoundTableRef> Binder::Bind(SubqueryRef &ref, CommonTableExpressionIn
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression_binder/table_function_binder.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+//! The Table function binder can bind standard table function parameters (i.e. non-table-in-out functions)
+class TableFunctionBinder : public ExpressionBinder {
+public:
+	TableFunctionBinder(Binder &binder, ClientContext &context);
+
+protected:
+	BindResult BindColumnReference(ColumnRefExpression &expr);
+	BindResult BindExpression(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false) override;
+
+	string UnsupportedAggregateMessage() override;
+};
+
+} // namespace duckdb
 
 
 
@@ -193825,7 +193852,7 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 			continue;
 		}
 
-		ConstantBinder binder(*this, context, "TABLE FUNCTION parameter");
+		TableFunctionBinder binder(*this, context);
 		LogicalType sql_type;
 		auto expr = binder.Bind(child, &sql_type);
 		if (expr->HasParameter()) {
@@ -197291,6 +197318,42 @@ BindResult SelectBinder::BindGroup(ParsedExpression &expr, idx_t depth, idx_t gr
 } // namespace duckdb
 
 
+
+
+namespace duckdb {
+
+TableFunctionBinder::TableFunctionBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
+}
+
+BindResult TableFunctionBinder::BindColumnReference(ColumnRefExpression &expr) {
+	auto result_name = StringUtil::Join(expr.column_names, ".");
+	return BindResult(make_unique<BoundConstantExpression>(Value(result_name)));
+}
+
+BindResult TableFunctionBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+                                               bool root_expression) {
+	auto &expr = **expr_ptr;
+	switch (expr.GetExpressionClass()) {
+	case ExpressionClass::COLUMN_REF:
+		return BindColumnReference((ColumnRefExpression &)expr);
+	case ExpressionClass::SUBQUERY:
+		throw BinderException("Table function cannot contain subqueries");
+	case ExpressionClass::DEFAULT:
+		return BindResult("Table function cannot contain DEFAULT clause");
+	case ExpressionClass::WINDOW:
+		return BindResult("Table function cannot contain window functions!");
+	default:
+		return ExpressionBinder::BindExpression(expr_ptr, depth);
+	}
+}
+
+string TableFunctionBinder::UnsupportedAggregateMessage() {
+	return "Table function cannot contain aggregates!";
+}
+
+} // namespace duckdb
+
+
 namespace duckdb {
 
 UpdateBinder::UpdateBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {

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 "799db99fc3"
-#define DUCKDB_VERSION "v0.6.1-dev131"
+#define DUCKDB_SOURCE_ID "dd5dcd5722"
+#define DUCKDB_VERSION "v0.6.1-dev140"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //

package/src/duckdb_node.hpp

@@ -133,7 +133,6 @@ public:
 	std::unique_ptr<duckdb::Connection> connection;
 	Database *database_ref;
 	std::unordered_map<std::string, duckdb_node_udf_function_t> udfs;
-	std::unordered_map<std::string, std::vector<std::pair<uint64_t, uint64_t>>> buffers;
 	std::unordered_map<std::string, Napi::Reference<Napi::Array>> array_references;
 };