duckdb 0.3.5-dev992.0 → 0.4.1-dev1019.0

package/src/statement.cpp

@@ -1,5 +1,7 @@
 #include "duckdb_node.hpp"
 
+#include <cassert>
+
 namespace node_duckdb {
 
 Napi::FunctionReference Statement::constructor;
@@ -10,7 +12,7 @@ Napi::Object Statement::Init(Napi::Env env, Napi::Object exports) {
 	Napi::Function t =
 	    DefineClass(env, "Statement",
 	                {InstanceMethod("run", &Statement::Run), InstanceMethod("all", &Statement::All),
-	                 InstanceMethod("each", &Statement::Each), InstanceMethod("finalize", &Statement::Finalize_)});
+	                 InstanceMethod("each", &Statement::Each), InstanceMethod("finalize", &Statement::Finish)});
 
 	constructor = Napi::Persistent(t);
 	constructor.SuppressDestruct();
@@ -20,7 +22,7 @@ Napi::Object Statement::Init(Napi::Env env, Napi::Object exports) {
 }
 
 struct PrepareTask : public Task {
-	PrepareTask(Statement &statement_, Napi::Function callback_) : Task(statement_, callback_) {
+	PrepareTask(Statement &statement, Napi::Function callback) : Task(statement, callback) {
 	}
 
 	void DoWork() override {
@@ -77,7 +79,7 @@ Statement::~Statement() {
 }
 
 // A Napi InstanceOf for Javascript Objects "Date" and "RegExp"
-static bool other_instance_of(Napi::Object source, const char *object_type) {
+static bool OtherInstanceOf(Napi::Object source, const char *object_type) {
 	if (strcmp(object_type, "Date") == 0) {
 		return source.InstanceOf(source.Env().Global().Get(object_type).As<Napi::Function>());
 	} else if (strcmp(object_type, "RegExp") == 0) {
@@ -87,10 +89,10 @@ static bool other_instance_of(Napi::Object source, const char *object_type) {
 	return false;
 }
 
-static duckdb::Value bind_parameter(const Napi::Value source) {
+static duckdb::Value BindParameter(const Napi::Value source) {
 	if (source.IsString()) {
 		return duckdb::Value(source.As<Napi::String>().Utf8Value());
-	} else if (other_instance_of(source.As<Napi::Object>(), "RegExp")) {
+	} else if (OtherInstanceOf(source.As<Napi::Object>(), "RegExp")) {
 		return duckdb::Value(source.ToString().Utf8Value());
 	} else if (source.IsNumber()) {
 		if (Utils::OtherIsInt(source.As<Napi::Number>())) {
@@ -208,6 +210,7 @@ static Napi::Value convert_chunk(Napi::Env &env, std::vector<std::string> names,
 	Napi::EscapableHandleScope scope(env);
 	std::vector<Napi::String> node_names;
 	assert(names.size() == chunk.ColumnCount());
+	node_names.reserve(names.size());
 	for (auto &name : names) {
 		node_names.push_back(Napi::String::New(env, name));
 	}
@@ -240,8 +243,8 @@ struct StatementParam {
 };
 
 struct RunPreparedTask : public Task {
-	RunPreparedTask(Statement &statement_, duckdb::unique_ptr<StatementParam> params_, RunType run_type_)
-	    : Task(statement_, params_->callback), params(move(params_)), run_type(run_type_) {
+	RunPreparedTask(Statement &statement, duckdb::unique_ptr<StatementParam> params, RunType run_type)
+	    : Task(statement, params->callback), params(move(params)), run_type(run_type) {
 	}
 
 	void DoWork() override {
@@ -285,6 +288,8 @@ struct RunPreparedTask : public Task {
 		case RunType::EACH: {
 			duckdb::idx_t count = 0;
 			while (true) {
+				Napi::HandleScope scope(env);
+
 				auto chunk = result->Fetch();
 				if (!chunk || chunk->size() == 0) {
 					break;
@@ -352,7 +357,7 @@ duckdb::unique_ptr<StatementParam> Statement::HandleArgs(const Napi::CallbackInf
 		if (p.IsUndefined()) {
 			continue;
 		}
-		params->params.push_back(bind_parameter(p));
+		params->params.push_back(BindParameter(p));
 	}
 	return params;
 }
@@ -377,8 +382,8 @@ Napi::Value Statement::Each(const Napi::CallbackInfo &info) {
 	return info.This();
 }
 
-struct FinalizeTask : public Task {
-	FinalizeTask(Statement &statement_, Napi::Function callback_) : Task(statement_, callback_) {
+struct FinishTask : public Task {
+	FinishTask(Statement &statement, Napi::Function callback) : Task(statement, callback) {
 	}
 
 	void DoWork() override {
@@ -387,7 +392,7 @@ struct FinalizeTask : public Task {
 	}
 };
 
-Napi::Value Statement::Finalize_(const Napi::CallbackInfo &info) {
+Napi::Value Statement::Finish(const Napi::CallbackInfo &info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 
@@ -397,7 +402,7 @@ Napi::Value Statement::Finalize_(const Napi::CallbackInfo &info) {
 		callback = info[0].As<Napi::Function>();
 	}
 
-	connection_ref->database_ref->Schedule(env, duckdb::make_unique<FinalizeTask>(*this, callback));
+	connection_ref->database_ref->Schedule(env, duckdb::make_unique<FinishTask>(*this, callback));
 	return env.Null();
 }
 

package/test/extension.test.js

@@ -67,7 +67,7 @@ describe('Extension loading', function() {
     var db;
 
     before(function(done) {
-        db = new duckdb.Database(':memory:', done);
+        db = new duckdb.Database(':memory:', {"allow_unsigned_extensions":"true"}, done);
     });
 
     for (ext of extension_paths) {

package/test/pathnames.test.js

@@ -0,0 +1,82 @@
+var sqlite3 = require("..");
+var assert = require("assert");
+
+describe("pathname search support", function () {
+  let db;
+  describe("without search paths", () => {
+    before((done) => {
+      db = new sqlite3.Database(":memory:", done);
+    });
+
+    it("supports a full path", function (done) {
+      db.prepare('select * from "test/support/prepare.csv"').all(
+        (err, result) => {
+          assert(err === null);
+          assert(result.length === 5000);
+          done();
+        }
+      );
+    });
+
+    it("don't not support a partial path", function (done) {
+      db.prepare('select * from "prepare.csv"').all((err, result) => {
+        assert(err.code === "DUCKDB_NODEJS_ERROR");
+        assert(err.errno === -1);
+        assert(result == null);
+        done();
+      });
+    });
+  });
+
+  describe("with search paths", () => {
+    before((done) => {
+      db = new sqlite3.Database(":memory:", () => {
+        db.prepare("SET FILE_SEARCH_PATH='test/support'").run(done);
+      });
+    });
+
+    it("supports a full path", function (done) {
+      db.prepare('select * from "test/support/prepare.csv"').all(
+        (err, result) => {
+          assert(err === null);
+          assert(result.length === 5000);
+          done();
+        }
+      );
+    });
+
+    it("supports a partial path", function (done) {
+      db.prepare('select * from "prepare.csv"').all((err, result) => {
+        assert(err === null);
+        assert(result.length === 5000);
+        done();
+      });
+    });
+  });
+
+  describe("with multiple search paths", () => {
+    before((done) => {
+      db = new sqlite3.Database(":memory:", () => {
+        db.prepare("SET FILE_SEARCH_PATH='test/support'").run(done);
+      });
+    });
+
+    it("supports a full path", function (done) {
+      db.prepare('select * from "test/support/prepare.csv"').all(
+        (err, result) => {
+          assert(err === null);
+          assert(result.length === 5000);
+          done();
+        }
+      );
+    });
+
+    it("supports a partial path", function (done) {
+      db.prepare('select * from "prepare.csv"').all((err, result) => {
+        assert(err === null);
+        assert(result.length === 5000);
+        done();
+      });
+    });
+  });
+});

package/test/syntax_error.test.js

@@ -0,0 +1,16 @@
+var duckdb = require('..');
+var assert = require('assert');
+
+describe('exec', function() {
+    var db;
+    before(function(done) {
+        db = new duckdb.Database(':memory:', done);
+    });
+
+    it("doesn't crash on a syntax error", function(done) {
+        db.exec("syntax error", function(err) {
+            assert.notEqual(err, null, "Expected an error")
+            done();
+        });
+    });
+});

package/test/udf.test.js

@@ -2,148 +2,213 @@ var duckdb = require('..');
 var assert = require('assert');
 
 describe('UDFs', function() {
-    var db;
+    describe('arity', function() {
+        var db;
+        before(function(done) {
+            db = new duckdb.Database(':memory:', done);
+        });
 
-    before(function(done) {
-        db = new duckdb.Database(':memory:', done);
-    });
+        it('0ary int', function(done) {
+            db.register("udf", "integer", () => 42);
+            db.all("select udf() v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 42);
+            });
+            db.unregister("udf", done);
+        });
 
-    it('0ary int', function(done) {
-        db.register("udf", "integer", () => 42);
-        db.all("select udf() v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, 42);
+        it('0ary double', function(done) {
+            db.register("udf", "double", () => 4.2);
+            db.all("select udf() v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 4.2);
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
-    });
 
-    it('0ary double', function(done) {
-        db.register("udf", "double", () => 4.2);
-        db.all("select udf() v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, 4.2);
+        it('0ary string', function(done) {
+            db.register("udf", "varchar", () => 'hello');
+            db.all("select udf() v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 'hello');
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
-    });
 
-    it('0ary string', function(done) {
-        db.register("udf", "varchar", () => 'hello');
-        db.all("select udf() v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, 'hello');
+        it('0ary int null', function(done) {
+            db.register("udf", "integer", () => undefined);
+            db.all("select udf() v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, undefined);
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
-    });
 
-    it('0ary int null', function(done) {
-        db.register("udf", "integer", () => undefined);
-        db.all("select udf() v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, undefined);
+
+        it('0ary string null', function(done) {
+            db.register("udf", "varchar", () => undefined);
+            db.all("select udf() v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, undefined);
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
-    });
 
 
-    it('0ary string null', function(done) {
-        db.register("udf", "varchar", () => undefined);
-        db.all("select udf() v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, undefined);
+        it('unary int', function(done) {
+            db.register("udf", "integer", (x) => x+1);
+            db.all("select udf(42) v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 43);
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
-    });
 
+        it('unary double', function(done) {
+            db.register("udf", "double", (x) => x);
+            db.all("select udf(4.2::double) v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 4.2);
+            });
+            db.unregister("udf", done);
+        });
 
-    it('unary int', function(done) {
-        db.register("udf", "integer", (x) => x+1);
-        db.all("select udf(42) v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, 43);
+        it('unary int null', function(done) {
+            db.register("udf", "integer", (x) => undefined);
+            db.all("select udf(42) v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, undefined);
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
-    });
 
-    it('unary double', function(done) {
-        db.register("udf", "double", (x) => x);
-        db.all("select udf(4.2::double) v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, 4.2);
+
+        it('unary double null', function(done) {
+            db.register("udf", "double", (x) => undefined);
+            db.all("select udf(4.2::double) v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, undefined);
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
-    });
 
-    it('unary int null', function(done) {
-        db.register("udf", "integer", (x) => undefined);
-        db.all("select udf(42) v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, undefined);
+
+        it('unary string', function(done) {
+            db.register("udf", "varchar", (x) => 'hello ' + x);
+            db.all("select udf('world') v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 'hello world');
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
-    });
 
+        it('unary string null', function(done) {
+            db.register("udf", "varchar", (x) => undefined);
+            db.all("select udf('world') v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, undefined);
+            });
+            db.unregister("udf", done);
+        });
 
-    it('unary double null', function(done) {
-        db.register("udf", "double", (x) => undefined);
-        db.all("select udf(4.2::double) v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, undefined);
+        it('binary int', function(done) {
+            db.register("udf", "integer", (x, y) => x + y);
+            db.all("select udf(40, 2) v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 42);
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
-    });
 
+        it('binary string', function(done) {
+            db.register("udf", "varchar", (x, y) => x + ' ' + y);
+            db.all("select udf('hello', 'world') v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 'hello world');
+            });
+            db.unregister("udf", done);
+        });
 
-    it('unary string', function(done) {
-        db.register("udf", "varchar", (x) => 'hello ' + x);
-        db.all("select udf('world') v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, 'hello world');
+        it('ternary int', function(done) {
+            db.register("udf", "integer", (x, y, z) => x + y + z);
+            db.all("select udf(21, 20, 1) v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 42);
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
-    });
 
-    it('unary string null', function(done) {
-        db.register("udf", "varchar", (x) => undefined);
-        db.all("select udf('world') v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, undefined);
+        it('unary larger series', function(done) {
+            db.register("udf", "integer", (x) => 1);
+            db.all("select sum(udf(range::double)) v from range(10000)", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 10000);
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
     });
 
-    it('binary int', function(done) {
-        db.register("udf", "integer", (x, y) => x + y);
-        db.all("select udf(40, 2) v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, 42);
+    describe('types', function() {
+        var db;
+        before(function(done) {
+            db = new duckdb.Database(':memory:', done);
         });
-        db.unregister("udf", done);
-    });
 
-    it('binary string', function(done) {
-        db.register("udf", "varchar", (x, y) => x + ' ' + y);
-        db.all("select udf('hello', 'world') v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, 'hello world');
+        it('tinyint', function(done) {
+            db.register("udf", "integer", (x) => x+1);
+            db.all("select udf(42::tinyint) v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 43);
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
-    });
 
-    it('ternary int', function(done) {
-        db.register("udf", "integer", (x, y, z) => x + y + z);
-        db.all("select udf(21, 20, 1) v", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, 42);
+        it('smallint', function(done) {
+            db.register("udf", "integer", (x) => x+1);
+            db.all("select udf(42::smallint) v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 43);
+            });
+            db.unregister("udf", done);
+        });
+
+        it('int', function(done) {
+            db.register("udf", "integer", (x) => x+1);
+            db.all("select udf(42::integer) v", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].v, 43);
+            });
+            db.unregister("udf", done);
+        });
+
+        it('timestamp', function(done) {
+            db.register("udf", "timestamp", (x) => x);
+            db.all("select udf(timestamp '1992-09-20 11:30:00') v", function(err, rows) {
+                if (err) throw err;
+            });
+            db.unregister("udf", done);
+        });
+
+        it('struct', function(done) {
+            db.register("udf", "integer", a => {
+                return (a.x == null ? -100 : a.x);
+            });
+            db.all("SELECT min(udf({'x': (case when v % 2 = 0 then v else null end)::INTEGER, 'y': 42}))::INTEGER as foo FROM generate_series(1, 10000) as t(v)", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].foo, -100);
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
-    });
 
-    it('unary larger series', function(done) {
-        db.register("udf", "integer", (x) => 1);
-        db.all("select sum(udf(range::double)) v from range(10000)", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].v, 10000);
+        it('structnestednull', function(done) {
+            db.register("udf", "integer", a => {
+                return (a.x == null ? -100 : a.x.y);
+            });
+            db.all("SELECT min(udf({'x': (case when v % 2 = 0 then {'y': v::INTEGER } else null end), 'z': 42}))::INTEGER as foo FROM generate_series(1, 10000) as t(v)", function(err, rows) {
+                if (err) throw err;
+                assert.equal(rows[0].foo, -100);
+            });
+            db.unregister("udf", done);
         });
-        db.unregister("udf", done);
     });
 });