duckdb 0.7.1-dev37.0 → 0.7.1-dev407.0

package/src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp

@@ -350,15 +350,15 @@
 
 #include "extension/icu/third_party/icu/i18n/double-conversion-strtod.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-double-to-string.cpp"
-
 #include "extension/icu/third_party/icu/i18n/double-conversion-string-to-double.cpp"
 
+#include "extension/icu/third_party/icu/i18n/double-conversion-bignum.cpp"
+
 #include "extension/icu/third_party/icu/i18n/double-conversion-fast-dtoa.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-bignum-dtoa.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-double-to-string.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-bignum.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-bignum-dtoa.cpp"
 
 #include "extension/icu/third_party/icu/i18n/double-conversion-cached-powers.cpp"
 

package/src/duckdb/ub_src_execution_operator_schema.cpp

@@ -16,5 +16,7 @@
 
 #include "src/execution/operator/schema/physical_create_function.cpp"
 
+#include "src/execution/operator/schema/physical_detach.cpp"
+
 #include "src/execution/operator/schema/physical_drop.cpp"
 

package/src/duckdb/ub_src_function_table_system.cpp

@@ -22,6 +22,8 @@
 
 #include "src/function/table/system/duckdb_tables.cpp"
 
+#include "src/function/table/system/duckdb_temporary_files.cpp"
+
 #include "src/function/table/system/duckdb_types.cpp"
 
 #include "src/function/table/system/duckdb_views.cpp"

package/src/duckdb/ub_src_parser_statement.cpp

@@ -8,6 +8,8 @@
 
 #include "src/parser/statement/create_statement.cpp"
 
+#include "src/parser/statement/detach_statement.cpp"
+
 #include "src/parser/statement/delete_statement.cpp"
 
 #include "src/parser/statement/drop_statement.cpp"

package/src/duckdb/ub_src_parser_transform_statement.cpp

@@ -2,6 +2,8 @@
 
 #include "src/parser/transform/statement/transform_attach.cpp"
 
+#include "src/parser/transform/statement/transform_detach.cpp"
+
 #include "src/parser/transform/statement/transform_call.cpp"
 
 #include "src/parser/transform/statement/transform_checkpoint.cpp"

package/src/duckdb/ub_src_planner_binder_statement.cpp

@@ -10,6 +10,8 @@
 
 #include "src/planner/binder/statement/bind_delete.cpp"
 
+#include "src/planner/binder/statement/bind_detach.cpp"
+
 #include "src/planner/binder/statement/bind_drop.cpp"
 
 #include "src/planner/binder/statement/bind_execute.cpp"

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);

package/src/duckdb/src/include/duckdb/function/create_database_extension.hpp

@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/create_database_extension.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-
-namespace duckdb {
-
-class ClientContext;
-class TableFunctionRef;
-
-struct CreateDatabaseExtensionData {
-	virtual ~CreateDatabaseExtensionData() {
-	}
-};
-
-typedef unique_ptr<TableFunctionRef> (*create_database_t)(ClientContext &context, const string &extension_name,
-                                                          const string &database_name, const string &source_path,
-                                                          CreateDatabaseExtensionData *data);
-
-struct CreateDatabaseExtension {
-	explicit CreateDatabaseExtension(create_database_t function,
-	                                 unique_ptr<CreateDatabaseExtensionData> data_p = nullptr)
-	    : function(function), data(std::move(data_p)) {
-	}
-
-	create_database_t function;
-	unique_ptr<CreateDatabaseExtensionData> data;
-};
-
-} // namespace duckdb