duckdb 0.7.1-dev90.0 → 0.7.2-dev0.0

package/src/statement.cpp

@@ -8,6 +8,8 @@
 #include <string>
 #include <regex>
 
+using std::unique_ptr;
+
 namespace node_duckdb {
 
 Napi::FunctionReference Statement::constructor;
@@ -28,13 +30,45 @@ Napi::Object Statement::Init(Napi::Env env, Napi::Object exports) {
 	return exports;
 }
 
+static unique_ptr<duckdb::PreparedStatement> PrepareManyInternal(Statement &statement) {
+	auto &connection = statement.connection_ref->connection;
+	std::vector<unique_ptr<duckdb::SQLStatement>> statements;
+	try {
+		if (connection == nullptr) {
+			throw duckdb::ConnectionException("Connection was never established or has been closed already");
+		}
+
+		// Prepare all statements
+		statements = connection->ExtractStatements(statement.sql);
+		if (statements.empty()) {
+			throw duckdb::InvalidInputException("No statement to prepare!");
+		}
+
+		// if there are multiple statements, we directly execute the statements besides the last one
+		// we only return the result of the last statement to the user, unless one of the previous statements fails
+		for (idx_t i = 0; i + 1 < statements.size(); i++) {
+			auto pending_query = connection->PendingQuery(std::move(statements[i]));
+			auto res = pending_query->Execute();
+			if (res->HasError()) {
+				return duckdb::make_unique<duckdb::PreparedStatement>(res->GetErrorObject());
+			}
+		}
+
+		return connection->Prepare(std::move(statements.back()));
+	} catch (const duckdb::Exception &ex) {
+		return duckdb::make_unique<duckdb::PreparedStatement>(duckdb::PreservedError(ex));
+	} catch (std::exception &ex) {
+		return duckdb::make_unique<duckdb::PreparedStatement>(duckdb::PreservedError(ex));
+	}
+}
+
 struct PrepareTask : public Task {
 	PrepareTask(Statement &statement, Napi::Function callback) : Task(statement, callback) {
 	}
 
 	void DoWork() override {
 		auto &statement = Get<Statement>();
-		statement.statement = statement.connection_ref->connection->Prepare(statement.sql);
+		statement.statement = PrepareManyInternal(statement);
 	}
 
 	void Callback() override {
@@ -221,7 +255,7 @@ struct StatementParam {
 };
 
 struct RunPreparedTask : public Task {
-	RunPreparedTask(Statement &statement, duckdb::unique_ptr<StatementParam> params, RunType run_type)
+	RunPreparedTask(Statement &statement, unique_ptr<StatementParam> params, RunType run_type)
 	    : Task(statement, params->callback), params(std::move(params)), run_type(run_type) {
 	}
 
@@ -366,13 +400,13 @@ struct RunPreparedTask : public Task {
 		} break;
 		}
 	}
-	std::unique_ptr<duckdb::QueryResult> result;
-	duckdb::unique_ptr<StatementParam> params;
+	unique_ptr<duckdb::QueryResult> result;
+	unique_ptr<StatementParam> params;
 	RunType run_type;
 };
 
 struct RunQueryTask : public Task {
-	RunQueryTask(Statement &statement, duckdb::unique_ptr<StatementParam> params, Napi::Promise::Deferred deferred)
+	RunQueryTask(Statement &statement, unique_ptr<StatementParam> params, Napi::Promise::Deferred deferred)
 	    : Task(statement), deferred(deferred), params(std::move(params)) {
 	}
 
@@ -406,11 +440,11 @@ struct RunQueryTask : public Task {
 	}
 
 	Napi::Promise::Deferred deferred;
-	std::unique_ptr<duckdb::QueryResult> result;
-	duckdb::unique_ptr<StatementParam> params;
+	unique_ptr<duckdb::QueryResult> result;
+	unique_ptr<StatementParam> params;
 };
 
-duckdb::unique_ptr<StatementParam> Statement::HandleArgs(const Napi::CallbackInfo &info) {
+unique_ptr<StatementParam> Statement::HandleArgs(const Napi::CallbackInfo &info) {
 	size_t start_idx = ignore_first_param ? 1 : 0;
 	auto params = duckdb::make_unique<StatementParam>();
 
@@ -541,7 +575,7 @@ struct GetChunkTask : public Task {
 	}
 
 	Napi::Promise::Deferred deferred;
-	std::unique_ptr<duckdb::DataChunk> chunk;
+	unique_ptr<duckdb::DataChunk> chunk;
 };
 
 struct GetNextArrowIpcTask : public Task {
@@ -571,10 +605,10 @@ struct GetNextArrowIpcTask : public Task {
 		duckdb::string_t blob = *(duckdb::string_t *)(chunk->data[0].GetData());
 
 		// Transfer ownership and Construct ArrayBuffer
-		auto data_chunk_ptr = new std::unique_ptr<duckdb::DataChunk>();
+		auto data_chunk_ptr = new unique_ptr<duckdb::DataChunk>();
 		*data_chunk_ptr = std::move(chunk);
 		auto deleter = [](Napi::Env, void *finalizeData, void *hint) {
-			delete static_cast<std::unique_ptr<duckdb::DataChunk> *>(hint);
+			delete static_cast<unique_ptr<duckdb::DataChunk> *>(hint);
 		};
 		auto array_buffer =
 		    Napi::ArrayBuffer::New(env, (void *)blob.GetDataUnsafe(), blob.GetSize(), deleter, data_chunk_ptr);
@@ -583,7 +617,7 @@ struct GetNextArrowIpcTask : public Task {
 	}
 
 	Napi::Promise::Deferred deferred;
-	std::unique_ptr<duckdb::DataChunk> chunk;
+	unique_ptr<duckdb::DataChunk> chunk;
 };
 
 Napi::Value QueryResult::NextChunk(const Napi::CallbackInfo &info) {

package/test/arrow.test.ts

@@ -20,13 +20,13 @@ describe('arrow IPC API fails neatly when extension not loaded', function() {
         db.arrowIPCStream(query).then(
             () => Promise.reject(new Error('Expected method to reject.')),
             err => {
-                assert.ok(err.message.includes("Catalog Error: Function with name to_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"))
+                assert.ok(err.message.includes("arrow"))
             }
         );
 
         db.arrowIPCAll(`SELECT * FROM ipc_table`, function (err: null | Error, result: ArrowArray) {
             if (err) {
-                assert.ok(err.message.includes("Catalog Error: Function with name to_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"))
+                assert.ok(err.message.includes("arrow"))
             } else {
                 assert.fail("Expected error");
             }
@@ -39,7 +39,7 @@ describe('arrow IPC API fails neatly when extension not loaded', function() {
     it('register buffer should be disabled currently', function(done) {
         db.register_buffer("test", [new Uint8Array(new ArrayBuffer(10))], true, (err: null | Error) => {
             assert.ok(err)
-            assert.ok(err.toString().includes("Function with name scan_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"));
+            assert.ok(err.toString().includes("arrow"));
             done()
         });
     });

package/test/prepare.test.ts

@@ -66,7 +66,6 @@ describe('prepare', function() {
             }
         });
 
-
         it('should prepare a statement and return values again', function(done) {
             var stmt = db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err: null | Error) {
                 if (err) throw err;
@@ -343,6 +342,45 @@ describe('prepare', function() {
         after(function(done) { db.close(done); });
     });
 
+    describe('prepare multiple statements', function() {
+        var db: sqlite3.Database;
+        before(function(done) { db = new sqlite3.Database(':memory:',
+            function(err) {
+                db.run("CREATE TABLE foo (a integer)", done)
+            }
+            ); });
+
+        it('should directly execute first statements', function(done) {
+            db.prepare("insert into foo values (3); insert into foo values (4); select * from foo")
+                .all(function(err: null | Error, rows: TableData) {
+                    if (err) throw err;
+                    assert.equal(rows[0].a, 3);
+                    assert.equal(rows[1].a, 4);
+                })
+                .finalize(done);
+        });
+
+        it('should fail in prepare, when executing the first statement', function(done) {
+            let prepared = db.prepare("SELECT * FROM non_existent_table; SELECT 42", function(err: null | Error) {
+				if (err) {
+					done();
+					return;
+				}
+			});
+        });
+
+        it('should fail in prepare, when preparing the first statement', function(done) {
+            let prepared = db.prepare("SELCET * FROM foo; SELECT 42", function(err: null | Error) {
+				if (err) {
+					done();
+					return;
+				}
+			});
+        });
+
+        after(function(done) { db.close(done); });
+    });
+
     describe('all()', function() {
         var db: sqlite3.Database;
         before(function(done) { db = new sqlite3.Database(':memory:',

package/test/typescript_decls.test.ts

@@ -2,7 +2,7 @@ import * as duckdb from "..";
 import assert from "assert";
 import fs from "fs";
 
-describe("TypeScript declarataions", function () {
+describe("TypeScript declarations", function () {
   var db: duckdb.Database;
   before(function (done) {
     db = new duckdb.Database(":memory:", duckdb.OPEN_READWRITE, done);