duckdb 0.8.1-dev31.0 → 0.8.1-dev341.0

package/src/duckdb/src/transaction/duck_transaction_manager.cpp

@@ -61,7 +61,7 @@ DuckTransactionManager &DuckTransactionManager::Get(AttachedDatabase &db) {
 	if (!transaction_manager.IsDuckTransactionManager()) {
 		throw InternalException("Calling DuckTransactionManager::Get on non-DuckDB transaction manager");
 	}
-	return (DuckTransactionManager &)transaction_manager;
+	return reinterpret_cast<DuckTransactionManager &>(transaction_manager);
 }
 
 Transaction *DuckTransactionManager::StartTransaction(ClientContext &context) {
@@ -152,7 +152,7 @@ void DuckTransactionManager::Checkpoint(ClientContext &context, bool force) {
 
 				// remove the transaction id from the list of active transactions
 				// potentially resulting in garbage collection
-				RemoveTransaction(transaction.get());
+				RemoveTransaction(*transaction);
 				if (transaction_context) {
 					transaction_context->transaction.ClearTransaction();
 				}
@@ -164,7 +164,7 @@ void DuckTransactionManager::Checkpoint(ClientContext &context, bool force) {
 	storage_manager.CreateCheckpoint();
 }
 
-bool DuckTransactionManager::CanCheckpoint(DuckTransaction *current) {
+bool DuckTransactionManager::CanCheckpoint(optional_ptr<DuckTransaction> current) {
 	if (db.IsSystem()) {
 		return false;
 	}
@@ -176,7 +176,7 @@ bool DuckTransactionManager::CanCheckpoint(DuckTransaction *current) {
 		return false;
 	}
 	for (auto &transaction : active_transactions) {
-		if (transaction.get() != current) {
+		if (transaction.get() != current.get()) {
 			return false;
 		}
 	}
@@ -184,14 +184,14 @@ bool DuckTransactionManager::CanCheckpoint(DuckTransaction *current) {
 }
 
 string DuckTransactionManager::CommitTransaction(ClientContext &context, Transaction *transaction_p) {
-	auto transaction = (DuckTransaction *)transaction_p;
+	auto &transaction = transaction_p->Cast<DuckTransaction>();
 	vector<ClientLockWrapper> client_locks;
 	auto lock = make_uniq<lock_guard<mutex>>(transaction_lock);
 	CheckpointLock checkpoint_lock(*this);
 	// check if we can checkpoint
-	bool checkpoint = thread_is_checkpointing ? false : CanCheckpoint(transaction);
+	bool checkpoint = thread_is_checkpointing ? false : CanCheckpoint(&transaction);
 	if (checkpoint) {
-		if (transaction->AutomaticCheckpoint(db)) {
+		if (transaction.AutomaticCheckpoint(db)) {
 			checkpoint_lock.Lock();
 			// we might be able to checkpoint: lock all clients
 			// to avoid deadlock we release the transaction lock while locking the clients
@@ -200,7 +200,7 @@ string DuckTransactionManager::CommitTransaction(ClientContext &context, Transac
 			LockClients(client_locks, context);
 
 			lock = make_uniq<lock_guard<mutex>>(transaction_lock);
-			checkpoint = CanCheckpoint(transaction);
+			checkpoint = CanCheckpoint(&transaction);
 			if (!checkpoint) {
 				checkpoint_lock.Unlock();
 				client_locks.clear();
@@ -212,12 +212,12 @@ string DuckTransactionManager::CommitTransaction(ClientContext &context, Transac
 	// obtain a commit id for the transaction
 	transaction_t commit_id = current_start_timestamp++;
 	// commit the UndoBuffer of the transaction
-	string error = transaction->Commit(db, commit_id, checkpoint);
+	string error = transaction.Commit(db, commit_id, checkpoint);
 	if (!error.empty()) {
 		// commit unsuccessful: rollback the transaction instead
 		checkpoint = false;
-		transaction->commit_id = 0;
-		transaction->Rollback();
+		transaction.commit_id = 0;
+		transaction.Rollback();
 	}
 	if (!checkpoint) {
 		// we won't checkpoint after all: unlock the clients again
@@ -239,19 +239,19 @@ string DuckTransactionManager::CommitTransaction(ClientContext &context, Transac
 }
 
 void DuckTransactionManager::RollbackTransaction(Transaction *transaction_p) {
-	auto transaction = (DuckTransaction *)transaction_p;
+	auto &transaction = transaction_p->Cast<DuckTransaction>();
 	// obtain the transaction lock during this function
 	lock_guard<mutex> lock(transaction_lock);
 
 	// rollback the transaction
-	transaction->Rollback();
+	transaction.Rollback();
 
 	// remove the transaction id from the list of active transactions
 	// potentially resulting in garbage collection
 	RemoveTransaction(transaction);
 }
 
-void DuckTransactionManager::RemoveTransaction(DuckTransaction *transaction) noexcept {
+void DuckTransactionManager::RemoveTransaction(DuckTransaction &transaction) noexcept {
 	// remove the transaction from the list of active transactions
 	idx_t t_index = active_transactions.size();
 	// check for the lowest and highest start time in the list of transactions
@@ -259,7 +259,7 @@ void DuckTransactionManager::RemoveTransaction(DuckTransaction *transaction) noe
 	transaction_t lowest_transaction_id = MAX_TRANSACTION_ID;
 	transaction_t lowest_active_query = MAXIMUM_QUERY_ID;
 	for (idx_t i = 0; i < active_transactions.size(); i++) {
-		if (active_transactions[i].get() == transaction) {
+		if (active_transactions[i].get() == &transaction) {
 			t_index = i;
 		} else {
 			transaction_t active_query = active_transactions[i]->active_query;
@@ -275,7 +275,7 @@ void DuckTransactionManager::RemoveTransaction(DuckTransaction *transaction) noe
 	D_ASSERT(t_index != active_transactions.size());
 	auto current_transaction = std::move(active_transactions[t_index]);
 	auto current_query = DatabaseManager::Get(db).ActiveQueryNumber();
-	if (transaction->commit_id != 0) {
+	if (transaction.commit_id != 0) {
 		// the transaction was committed, add it to the list of recently
 		// committed transactions
 		recently_committed_transactions.push_back(std::move(current_transaction));

package/src/duckdb/src/transaction/rollback_state.cpp

@@ -22,19 +22,19 @@ void RollbackState::RollbackEntry(UndoFlags type, data_ptr_t data) {
 		break;
 	}
 	case UndoFlags::INSERT_TUPLE: {
-		auto info = (AppendInfo *)data;
+		auto info = reinterpret_cast<AppendInfo *>(data);
 		// revert the append in the base table
 		info->table->RevertAppend(info->start_row, info->count);
 		break;
 	}
 	case UndoFlags::DELETE_TUPLE: {
-		auto info = (DeleteInfo *)data;
+		auto info = reinterpret_cast<DeleteInfo *>(data);
 		// reset the deleted flag on rollback
 		info->vinfo->CommitDelete(NOT_DELETED_ID, info->rows, info->count);
 		break;
 	}
 	case UndoFlags::UPDATE_TUPLE: {
-		auto info = (UpdateInfo *)data;
+		auto info = reinterpret_cast<UpdateInfo *>(data);
 		info->segment->RollbackUpdate(*info);
 		break;
 	}

package/src/duckdb/src/verification/prepared_statement_verifier.cpp

@@ -50,7 +50,7 @@ void PreparedStatementVerifier::ConvertConstants(unique_ptr<ParsedExpression> &c
 		// check if the value already exists
 		idx_t index = values.size();
 		for (idx_t v_idx = 0; v_idx < values.size(); v_idx++) {
-			if (values[v_idx]->Equals(child.get())) {
+			if (values[v_idx]->Equals(*child)) {
 				// duplicate value! refer to the original value
 				index = v_idx;
 				break;

package/src/duckdb/src/verification/statement_verifier.cpp

@@ -57,7 +57,7 @@ void StatementVerifier::CheckExpressions(const StatementVerifier &other) const {
 
 	// Check equality
 	if (other.RequireEquality()) {
-		D_ASSERT(statement->Equals(other.statement.get()));
+		D_ASSERT(statement->Equals(*other.statement));
 	}
 
 #ifdef DEBUG
@@ -66,7 +66,6 @@ void StatementVerifier::CheckExpressions(const StatementVerifier &other) const {
 	const auto expr_count = select_list.size();
 	if (other.RequireEquality()) {
 		for (idx_t i = 0; i < expr_count; i++) {
-			D_ASSERT(!select_list[i]->Equals(nullptr));
 			// Run the ToString, to verify that it doesn't crash
 			select_list[i]->ToString();
 
@@ -75,7 +74,7 @@ void StatementVerifier::CheckExpressions(const StatementVerifier &other) const {
 			}
 
 			// Check that the expressions are equivalent
-			D_ASSERT(select_list[i]->Equals(other.select_list[i].get()));
+			D_ASSERT(select_list[i]->Equals(*other.select_list[i]));
 			// Check that the hashes are equivalent too
 			D_ASSERT(select_list[i]->Hash() == other.select_list[i]->Hash());
 
@@ -96,7 +95,7 @@ void StatementVerifier::CheckExpressions() const {
 			auto hash2 = select_list[inner_idx]->Hash();
 			if (hash != hash2) {
 				// if the hashes are not equivalent, the expressions should not be equivalent
-				D_ASSERT(!select_list[outer_idx]->Equals(select_list[inner_idx].get()));
+				D_ASSERT(!select_list[outer_idx]->Equals(*select_list[inner_idx]));
 			}
 		}
 	}

package/src/duckdb/third_party/hyperloglog/hyperloglog.hpp

@@ -17,9 +17,9 @@ namespace duckdb_hll {
 #define HLL_C_OK  0
 #define HLL_C_ERR -1
 
-typedef struct {
+struct robj {
 	void *ptr;
-} robj;
+};
 
 //! Create a new empty HyperLogLog object
 robj *hll_create(void);

package/src/duckdb/third_party/libpg_query/include/nodes/nodes.hpp

@@ -426,7 +426,6 @@ typedef enum PGNodeTag {
 	T_PGImportStmt,
 	T_PGAttachStmt,
 	T_PGDetachStmt,
-	T_PGCreateDatabaseStmt,
 	T_PGUseStmt,
 
 	/*

package/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp

@@ -2119,20 +2119,6 @@ typedef struct PGDetachStmt
 	bool missing_ok;
 } PGDetachStmt;
 
-
-
-/* ----------------------
- *		CREATE DATABASE Statement
- * ----------------------
- */
-typedef struct PGCreateDatabaseStmt
-{
-	PGNodeTag	type;
-	PGRangeVar *name;			/* The name of the created database */
-	char *extension;			/* The name of the extension which will create the database */
-	char *path;					/* The file path of the to-be-created database */
-} PGCreateDatabaseStmt;
-
 /* ----------------------
  *		Use Statement
  * ----------------------