duckdb 0.5.2-dev1740.0 → 0.5.2-dev1745.0

package/binding.gyp

@@ -63,6 +63,12 @@
                         ]
                     },
                 ],  # OS=="win"
+                [
+                    'target_arch=="arm64"',
+                    {
+                        "cflags_cc": ["-arch", "arm64"]
+                    }
+                ]
             ],  # conditions
           #  uncomment this to build against existing lib
 #             "libraries": [

package/package.json

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

package/src/duckdb.cpp

@@ -48711,6 +48711,8 @@ class DatabaseInstance;
 enum class ErrorType : uint16_t {
 	// error message types
 	UNSIGNED_EXTENSION = 0,
+	INVALIDATED_TRANSACTION = 1,
+	INVALIDATED_DATABASE = 2,
 
 	// this should always be the last value
 	ERROR_COUNT,
@@ -48736,13 +48738,18 @@ public:
 		return FormatExceptionRecursive(error_type, values, params...);
 	}
 
+	template <typename... Args>
+	static string FormatException(ClientContext &context, ErrorType error_type, Args... params) {
+		return Get(context).FormatException(error_type, params...);
+	}
+
 	DUCKDB_API static string InvalidUnicodeError(const string &input, const string &context);
 
 	//! Adds a custom error for a specific error type
 	void AddCustomError(ErrorType type, string new_error);
 
-	DUCKDB_API ErrorManager &Get(ClientContext &context);
-	DUCKDB_API ErrorManager &Get(DatabaseInstance &context);
+	DUCKDB_API static ErrorManager &Get(ClientContext &context);
+	DUCKDB_API static ErrorManager &Get(DatabaseInstance &context);
 
 private:
 	map<ErrorType, string> custom_errors;
@@ -133571,6 +133578,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 struct ActiveQueryContext {
@@ -133639,7 +133647,7 @@ unique_ptr<DataChunk> ClientContext::FetchInternal(ClientContextLock &lock, Exec
 		// fatal exceptions invalidate the entire database
 		result.SetError(PreservedError(ex));
 		auto &db = DatabaseInstance::GetDatabase(*this);
-		db.Invalidate();
+		ValidChecker::Invalidate(db, ex.what());
 	} catch (const Exception &ex) {
 		result.SetError(PreservedError(ex));
 	} catch (std::exception &ex) {
@@ -133655,12 +133663,13 @@ void ClientContext::BeginTransactionInternal(ClientContextLock &lock, bool requi
 	// check if we are on AutoCommit. In this case we should start a transaction
 	D_ASSERT(!active_query);
 	auto &db = DatabaseInstance::GetDatabase(*this);
-	if (db.IsInvalidated()) {
-		throw FatalException("Failed: database has been invalidated!");
+	if (ValidChecker::IsInvalidated(db)) {
+		throw FatalException(ErrorManager::FormatException(*this, ErrorType::INVALIDATED_DATABASE,
+		                                                   ValidChecker::InvalidatedMessage(db)));
 	}
 	if (requires_valid_transaction && transaction.HasActiveTransaction() &&
-	    transaction.ActiveTransaction().IsInvalidated()) {
-		throw Exception("Failed: transaction has been invalidated!");
+	    ValidChecker::IsInvalidated(transaction.ActiveTransaction())) {
+		throw Exception(ErrorManager::FormatException(*this, ErrorType::INVALIDATED_TRANSACTION));
 	}
 	active_query = make_unique<ActiveQueryContext>();
 	if (transaction.IsAutoCommit()) {
@@ -133703,12 +133712,12 @@ PreservedError ClientContext::EndQueryInternal(ClientContextLock &lock, bool suc
 				}
 			} else if (invalidate_transaction) {
 				D_ASSERT(!success);
-				ActiveTransaction().Invalidate();
+				ValidChecker::Invalidate(ActiveTransaction(), "Failed to commit");
 			}
 		}
 	} catch (FatalException &ex) {
 		auto &db = DatabaseInstance::GetDatabase(*this);
-		db.Invalidate();
+		ValidChecker::Invalidate(db, ex.what());
 		error = PreservedError(ex);
 	} catch (const Exception &ex) {
 		error = PreservedError(ex);
@@ -133887,8 +133896,8 @@ unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientCon
                                                                        PendingQueryParameters parameters) {
 	D_ASSERT(active_query);
 	auto &statement = *statement_p;
-	if (ActiveTransaction().IsInvalidated() && statement.properties.requires_valid_transaction) {
-		throw Exception("Current transaction is aborted (please ROLLBACK)");
+	if (ValidChecker::IsInvalidated(ActiveTransaction()) && statement.properties.requires_valid_transaction) {
+		throw Exception(ErrorManager::FormatException(*this, ErrorType::INVALIDATED_TRANSACTION));
 	}
 	auto &db_config = DBConfig::GetConfig(*this);
 	if (db_config.options.access_mode == AccessMode::READ_ONLY && !statement.properties.read_only) {
@@ -133942,7 +133951,7 @@ PendingExecutionResult ClientContext::ExecuteTaskInternal(ClientContextLock &loc
 		// fatal exceptions invalidate the entire database
 		result.SetError(PreservedError(ex));
 		auto &db = DatabaseInstance::GetDatabase(*this);
-		db.Invalidate();
+		ValidChecker::Invalidate(db, ex.what());
 	} catch (const Exception &ex) {
 		result.SetError(PreservedError(ex));
 	} catch (std::exception &ex) {
@@ -134196,7 +134205,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 	} catch (FatalException &ex) {
 		// fatal exceptions invalidate the entire database
 		auto &db = DatabaseInstance::GetDatabase(*this);
-		db.Invalidate();
+		ValidChecker::Invalidate(db, ex.what());
 		result = make_unique<PendingQueryResult>(PreservedError(ex));
 		return result;
 	} catch (const Exception &ex) {
@@ -134229,9 +134238,9 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 		invalidate_query = false;
 	} catch (FatalException &ex) {
 		// fatal exceptions invalidate the entire database
-		auto &db = DatabaseInstance::GetDatabase(*this);
 		if (!config.query_verification_enabled) {
-			db.Invalidate();
+			auto &db = DatabaseInstance::GetDatabase(*this);
+			ValidChecker::Invalidate(db, ex.what());
 		}
 		result = make_unique<PendingQueryResult>(PreservedError(ex));
 	} catch (const Exception &ex) {
@@ -134418,8 +134427,8 @@ void ClientContext::RegisterFunction(CreateFunctionInfo *info) {
 void ClientContext::RunFunctionInTransactionInternal(ClientContextLock &lock, const std::function<void(void)> &fun,
                                                      bool requires_valid_transaction) {
 	if (requires_valid_transaction && transaction.HasActiveTransaction() &&
-	    transaction.ActiveTransaction().IsInvalidated()) {
-		throw Exception("Failed: transaction has been invalidated!");
+	    ValidChecker::IsInvalidated(ActiveTransaction())) {
+		throw Exception(ErrorManager::FormatException(*this, ErrorType::INVALIDATED_TRANSACTION));
 	}
 	// check if we are on AutoCommit. In this case we should start a transaction
 	bool require_new_transaction = transaction.IsAutoCommit() && !transaction.HasActiveTransaction();
@@ -134436,13 +134445,13 @@ void ClientContext::RunFunctionInTransactionInternal(ClientContextLock &lock, co
 		throw;
 	} catch (FatalException &ex) {
 		auto &db = DatabaseInstance::GetDatabase(*this);
-		db.Invalidate();
+		ValidChecker::Invalidate(db, ex.what());
 		throw;
 	} catch (std::exception &ex) {
 		if (require_new_transaction) {
 			transaction.Rollback();
 		} else {
-			ActiveTransaction().Invalidate();
+			ValidChecker::Invalidate(ActiveTransaction(), ex.what());
 		}
 		throw;
 	}
@@ -134806,7 +134815,7 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 			statement_verifiers.push_back(move(prepared_statement_verifier));
 		}
 	} else {
-		if (db->IsInvalidated()) {
+		if (ValidChecker::IsInvalidated(*db)) {
 			return original->materialized_result->GetErrorObject();
 		}
 	}
@@ -135973,7 +135982,7 @@ DBConfig::DBConfig(std::unordered_map<string, string> &config_dict, bool read_on
 DBConfig::~DBConfig() {
 }
 
-DatabaseInstance::DatabaseInstance() : is_invalidated(false) {
+DatabaseInstance::DatabaseInstance() {
 }
 
 DatabaseInstance::~DatabaseInstance() {
@@ -136198,6 +136207,9 @@ void DatabaseInstance::Configure(DBConfig &new_config) {
 	config.replacement_opens = move(new_config.replacement_opens);
 	config.parser_extensions = move(new_config.parser_extensions);
 	config.error_manager = move(new_config.error_manager);
+	if (!config.error_manager) {
+		config.error_manager = make_unique<ErrorManager>();
+	}
 }
 
 DBConfig &DBConfig::GetConfig(ClientContext &context) {
@@ -136250,11 +136262,12 @@ string ClientConfig::ExtractTimezone() const {
 	}
 }
 
-void DatabaseInstance::Invalidate() {
-	this->is_invalidated = true;
+ValidChecker &DatabaseInstance::GetValidChecker() {
+	return db_validity;
 }
-bool DatabaseInstance::IsInvalidated() {
-	return this->is_invalidated;
+
+ValidChecker &ValidChecker::Get(DatabaseInstance &db) {
+	return db.GetValidChecker();
 }
 
 } // namespace duckdb
@@ -136364,6 +136377,9 @@ static DefaultError internal_errors[] = {
     {ErrorType::UNSIGNED_EXTENSION,
      "Extension \"%s\" could not be loaded because its signature is either missing or invalid and unsigned extensions "
      "are disabled by configuration (allow_unsigned_extensions)"},
+    {ErrorType::INVALIDATED_TRANSACTION, "Current transaction is aborted (please ROLLBACK)"},
+    {ErrorType::INVALIDATED_DATABASE, "Failed: database has been invalidated because of a previous fatal error. The "
+                                      "database must be restarted prior to being used again.\nOriginal error: \"%s\""},
     {ErrorType::INVALID, nullptr}};
 
 string ErrorManager::FormatExceptionRecursive(ErrorType error_type, vector<ExceptionFormatValue> &values) {
@@ -149884,6 +149900,28 @@ void StreamQueryResult::Close() {
 } // namespace duckdb
 
 
+namespace duckdb {
+
+ValidChecker::ValidChecker() : is_invalidated(false) {
+}
+
+void ValidChecker::Invalidate(string error) {
+	lock_guard<mutex> l(invalidate_lock);
+	this->is_invalidated = true;
+	this->invalidated_msg = move(error);
+}
+
+bool ValidChecker::IsInvalidated() {
+	return this->is_invalidated;
+}
+
+string ValidChecker::InvalidatedMessage() {
+	lock_guard<mutex> l(invalidate_lock);
+	return invalidated_msg;
+}
+} // namespace duckdb
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -221497,8 +221535,7 @@ Transaction::Transaction(weak_ptr<ClientContext> context_p, transaction_t start_
                          timestamp_t start_timestamp, idx_t catalog_version)
     : context(move(context_p)), start_time(start_time), transaction_id(transaction_id), commit_id(0),
       highest_active_query(0), active_query(MAXIMUM_QUERY_ID), start_timestamp(start_timestamp),
-      catalog_version(catalog_version), is_invalidated(false), undo_buffer(context.lock()),
-      storage(make_unique<LocalStorage>(*this)) {
+      catalog_version(catalog_version), undo_buffer(context.lock()), storage(make_unique<LocalStorage>(*this)) {
 }
 
 Transaction::~Transaction() {
@@ -221605,11 +221642,8 @@ void Transaction::Cleanup() {
 	undo_buffer.Cleanup();
 }
 
-void Transaction::Invalidate() {
-	is_invalidated = true;
-}
-bool Transaction::IsInvalidated() {
-	return is_invalidated;
+ValidChecker &ValidChecker::Get(Transaction &transaction) {
+	return transaction.transaction_validity;
 }
 
 } // namespace duckdb

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 "a09de46040"
-#define DUCKDB_VERSION "v0.5.2-dev1740"
+#define DUCKDB_SOURCE_ID "08c5167e04"
+#define DUCKDB_VERSION "v0.5.2-dev1745"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -14703,6 +14703,58 @@ struct TransactionData {
 
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/valid_checker.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+class DatabaseInstance;
+class Transaction;
+
+class ValidChecker {
+public:
+	ValidChecker();
+
+	DUCKDB_API static ValidChecker &Get(DatabaseInstance &db);
+	DUCKDB_API static ValidChecker &Get(Transaction &transaction);
+
+	DUCKDB_API void Invalidate(string error);
+	DUCKDB_API bool IsInvalidated();
+	DUCKDB_API string InvalidatedMessage();
+
+	template <class T>
+	static bool IsInvalidated(T &o) {
+		return Get(o).IsInvalidated();
+	}
+	template <class T>
+	static void Invalidate(T &o, string error) {
+		Get(o).Invalidate(move(error));
+	}
+
+	template <class T>
+	static string InvalidatedMessage(T &o) {
+		return Get(o).InvalidatedMessage();
+	}
+
+private:
+	//! Set to true if a fatal exception has occurred
+	mutex invalidate_lock;
+	atomic<bool> is_invalidated;
+	string invalidated_msg;
+};
+
+} // namespace duckdb
+
 
 namespace duckdb {
 class SequenceCatalogEntry;
@@ -14722,7 +14774,6 @@ struct UpdateInfo;
 
 //! The transaction object holds information about a currently running or past
 //! transaction
-
 class Transaction {
 public:
 	Transaction(weak_ptr<ClientContext> context, transaction_t start_time, transaction_t transaction_id,
@@ -14747,8 +14798,8 @@ public:
 	idx_t catalog_version;
 	//! Map of all sequences that were used during the transaction and the value they had in this transaction
 	unordered_map<SequenceCatalogEntry *, SequenceValue> sequence_usage;
-	//! Whether or not the transaction has been invalidated
-	bool is_invalidated;
+	//! The validity checker of the transaction
+	ValidChecker transaction_validity;
 
 public:
 	static Transaction &GetTransaction(ClientContext &context);
@@ -14767,8 +14818,6 @@ public:
 	//! Cleanup the undo buffer
 	void Cleanup();
 
-	void Invalidate();
-	bool IsInvalidated();
 	bool ChangesMade();
 
 	timestamp_t GetCurrentTransactionStartTimestamp() {
@@ -15983,8 +16032,6 @@ private:
 
 
 
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -16624,6 +16671,8 @@ private:
 
 } // namespace duckdb
 
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -16678,8 +16727,7 @@ public:
 	DUCKDB_API TaskScheduler &GetScheduler();
 	DUCKDB_API ObjectCache &GetObjectCache();
 	DUCKDB_API ConnectionManager &GetConnectionManager();
-	DUCKDB_API void Invalidate();
-	DUCKDB_API bool IsInvalidated();
+	DUCKDB_API ValidChecker &GetValidChecker();
 	DUCKDB_API void SetExtensionLoaded(const std::string &extension_name);
 
 	idx_t NumberOfThreads();
@@ -16703,8 +16751,7 @@ private:
 	unique_ptr<ObjectCache> object_cache;
 	unique_ptr<ConnectionManager> connection_manager;
 	unordered_set<std::string> loaded_extensions;
-	//! Set to true if a fatal exception has occurred
-	atomic<bool> is_invalidated;
+	ValidChecker db_validity;
 };
 
 //! The database object. This object holds the catalog and all the