duckdb 0.10.3-dev0.0 → 0.10.3-dev13.0

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

@@ -17,33 +17,7 @@
 
 namespace duckdb {
 
-struct CheckpointLock {
-	explicit CheckpointLock(DuckTransactionManager &manager) : manager(manager), is_locked(false) {
-	}
-	~CheckpointLock() {
-		Unlock();
-	}
-
-	DuckTransactionManager &manager;
-	bool is_locked;
-
-	void Lock() {
-		D_ASSERT(!manager.thread_is_checkpointing);
-		manager.thread_is_checkpointing = true;
-		is_locked = true;
-	}
-	void Unlock() {
-		if (!is_locked) {
-			return;
-		}
-		D_ASSERT(manager.thread_is_checkpointing);
-		manager.thread_is_checkpointing = false;
-		is_locked = false;
-	}
-};
-
-DuckTransactionManager::DuckTransactionManager(AttachedDatabase &db)
-    : TransactionManager(db), thread_is_checkpointing(false) {
+DuckTransactionManager::DuckTransactionManager(AttachedDatabase &db) : TransactionManager(db) {
 	// start timestamp starts at two
 	current_start_timestamp = 2;
 	// transaction ID starts very high:
@@ -68,6 +42,7 @@ DuckTransactionManager &DuckTransactionManager::Get(AttachedDatabase &db) {
 
 Transaction &DuckTransactionManager::StartTransaction(ClientContext &context) {
 	// obtain the transaction lock during this function
+	lock_guard<mutex> start_lock(start_transaction_lock);
 	lock_guard<mutex> lock(transaction_lock);
 	if (current_start_timestamp >= TRANSACTION_ID_START) { // LCOV_EXCL_START
 		throw InternalException("Cannot start more transactions, ran out of "
@@ -91,136 +66,189 @@ Transaction &DuckTransactionManager::StartTransaction(ClientContext &context) {
 	return transaction_ref;
 }
 
-void DuckTransactionManager::Checkpoint(ClientContext &context, bool force) {
+DuckTransactionManager::CheckpointDecision::CheckpointDecision(string reason_p)
+    : can_checkpoint(false), reason(std::move(reason_p)) {
+}
+
+DuckTransactionManager::CheckpointDecision::CheckpointDecision(CheckpointType type) : can_checkpoint(true), type(type) {
+}
+
+DuckTransactionManager::CheckpointDecision::~CheckpointDecision() {
+}
+
+DuckTransactionManager::CheckpointDecision
+DuckTransactionManager::CanCheckpoint(DuckTransaction &transaction, unique_ptr<StorageLockKey> &lock,
+                                      const UndoBufferProperties &undo_properties) {
+	if (db.IsSystem()) {
+		return CheckpointDecision("system transaction");
+	}
 	auto &storage_manager = db.GetStorageManager();
 	if (storage_manager.InMemory()) {
-		return;
+		return CheckpointDecision("in memory db");
 	}
-
-	// first check if no other thread is checkpointing right now
-	auto current = &DuckTransaction::Get(context, db);
-	auto lock = unique_lock<mutex>(transaction_lock);
-	if (thread_is_checkpointing) {
-		throw TransactionException("Cannot CHECKPOINT: another thread is checkpointing right now");
+	if (!storage_manager.IsLoaded()) {
+		return CheckpointDecision("cannot checkpoint while loading");
 	}
-	CheckpointLock checkpoint_lock(*this);
-	checkpoint_lock.Lock();
-	if (current->ChangesMade()) {
-		throw TransactionException("Cannot CHECKPOINT: the current transaction has transaction local changes");
+	if (!transaction.AutomaticCheckpoint(db, undo_properties)) {
+		return CheckpointDecision("no reason to automatically checkpoint");
 	}
-	if (!force) {
-		if (!CanCheckpoint(current).can_checkpoint) {
-			throw TransactionException("Cannot CHECKPOINT: there are other transactions. Use FORCE CHECKPOINT to abort "
-			                           "the other transactions and force a checkpoint");
-		}
-	} else {
-		lock.unlock();
-
-		// lock all the clients AND the connection manager now
-		// this ensures no new queries can be started, and no new connections to the database can be made
-		// to avoid deadlock we release the transaction lock while locking the clients
-		auto &connection_manager = ConnectionManager::Get(context);
-		vector<ClientLockWrapper> client_locks;
-		connection_manager.LockClients(client_locks, context);
-
-		lock.lock();
-		if (!CanCheckpoint(current).can_checkpoint) {
-			for (size_t i = 0; i < active_transactions.size(); i++) {
-				auto &transaction = active_transactions[i];
-				// rollback the transaction
-				transaction->Rollback();
-				auto transaction_context = transaction->context.lock();
-
-				// remove the transaction id from the list of active transactions
-				// potentially resulting in garbage collection
-				RemoveTransaction(*transaction);
-				if (transaction_context) {
-					// invalidate the active transaction for this connection
-					auto &meta_transaction = MetaTransaction::Get(*transaction_context);
-					meta_transaction.RemoveTransaction(db);
-					ValidChecker::Get(meta_transaction).Invalidate("Invalidated due to FORCE CHECKPOINT");
+	// try to lock the checkpoint lock
+	lock = transaction.TryGetCheckpointLock();
+	if (!lock) {
+		return CheckpointDecision("Failed to obtain checkpoint lock - another thread is writing/checkpointing or "
+		                          "another read transaction relies on data that is not yet committed");
+	}
+	auto checkpoint_type = CheckpointType::FULL_CHECKPOINT;
+	if (undo_properties.has_updates || undo_properties.has_deletes || undo_properties.has_dropped_entries) {
+		// if we have made updates/deletes/catalog changes in this transaction we might need to change our strategy
+		// in the presence of other transactions
+		string other_transactions;
+		for (auto &active_transaction : active_transactions) {
+			if (!RefersToSameObject(*active_transaction, transaction)) {
+				if (!other_transactions.empty()) {
+					other_transactions += ", ";
 				}
-				i--;
+				other_transactions += "[" + to_string(active_transaction->transaction_id) + "]";
+			}
+		}
+		if (!other_transactions.empty()) {
+			// there are other transactions!
+			// these active transactions might need data from BEFORE this transaction
+			// we might need to change our strategy here based on what changes THIS transaction has made
+			if (undo_properties.has_dropped_entries) {
+				// this transaction has changed the catalog - we cannot checkpoint
+				return CheckpointDecision("Transaction has dropped catalog entries and there are other transactions "
+				                          "active\nActive transactions: " +
+				                          other_transactions);
+			} else if (undo_properties.has_updates) {
+				// this transaction has performed updates - we cannot checkpoint
+				return CheckpointDecision(
+				    "Transaction has performed updates and there are other transactions active\nActive transactions: " +
+				    other_transactions);
+			} else {
+				// this transaction has performed deletes - we cannot vacuum - initiate a concurrent checkpoint instead
+				D_ASSERT(undo_properties.has_deletes);
+				checkpoint_type = CheckpointType::CONCURRENT_CHECKPOINT;
 			}
-			D_ASSERT(CanCheckpoint(nullptr).can_checkpoint);
 		}
 	}
-	storage_manager.CreateCheckpoint();
+	return CheckpointDecision(checkpoint_type);
 }
 
-DuckTransactionManager::CheckpointDecision
-DuckTransactionManager::CanCheckpoint(optional_ptr<DuckTransaction> current) {
-	if (db.IsSystem()) {
-		return {false, "system transaction"};
-	}
+void DuckTransactionManager::Checkpoint(ClientContext &context, bool force) {
 	auto &storage_manager = db.GetStorageManager();
 	if (storage_manager.InMemory()) {
-		return {false, "in memory db"};
-	}
-	auto trans_to_string = [](const unique_ptr<DuckTransaction> &t) {
-		return std::to_string(t->transaction_id);
-	};
-	if (!recently_committed_transactions.empty()) {
-		return {false, "recently committed transactions: [" +
-		                   StringUtil::Join(recently_committed_transactions, recently_committed_transactions.size(),
-		                                    ",", trans_to_string) +
-		                   "]"};
+		return;
 	}
-	if (!old_transactions.empty()) {
-		return {false, "old transactions: [" +
-		                   StringUtil::Join(old_transactions, old_transactions.size(), ",", trans_to_string) + "]"};
+
+	auto current = Transaction::TryGet(context, db);
+	if (current) {
+		if (force) {
+			throw TransactionException(
+			    "Cannot FORCE CHECKPOINT: the current transaction has been started for this database");
+		} else {
+			auto &duck_transaction = current->Cast<DuckTransaction>();
+			if (duck_transaction.ChangesMade()) {
+				throw TransactionException("Cannot CHECKPOINT: the current transaction has transaction local changes");
+			}
+		}
 	}
 
-	for (auto &transaction : active_transactions) {
-		if (transaction.get() != current.get()) {
-			return {false, "current transaction [" + std::to_string(current->transaction_id) + "] isn't active"};
+	unique_ptr<StorageLockKey> lock;
+	if (!force) {
+		// not a force checkpoint
+		// try to get the checkpoint lock
+		lock = checkpoint_lock.TryGetExclusiveLock();
+		if (!lock) {
+			// we could not manage to get the lock - cancel
+			throw TransactionException(
+			    "Cannot CHECKPOINT: there are other write transactions active. Use FORCE CHECKPOINT to abort "
+			    "the other transactions and force a checkpoint");
+		}
+
+	} else {
+		// force checkpoint - wait to get an exclusive lock
+		// grab the start_transaction_lock to prevent new transactions from starting
+		lock_guard<mutex> start_lock(start_transaction_lock);
+		// wait until any active transactions are finished
+		while (!lock) {
+			if (context.interrupted) {
+				throw InterruptException();
+			}
+			lock = checkpoint_lock.TryGetExclusiveLock();
 		}
 	}
-	return {true, ""};
+	CheckpointOptions options;
+	if (GetLastCommit() > LowestActiveStart()) {
+		// we cannot do a full checkpoint if any transaction needs to read old data
+		options.type = CheckpointType::CONCURRENT_CHECKPOINT;
+	}
+	storage_manager.CreateCheckpoint(options);
+}
+
+unique_ptr<StorageLockKey> DuckTransactionManager::SharedCheckpointLock() {
+	return checkpoint_lock.GetSharedLock();
+}
+
+unique_ptr<StorageLockKey> DuckTransactionManager::TryUpgradeCheckpointLock(StorageLockKey &lock) {
+	return checkpoint_lock.TryUpgradeCheckpointLock(lock);
+}
+
+transaction_t DuckTransactionManager::GetCommitTimestamp() {
+	auto commit_ts = current_start_timestamp++;
+	last_commit = commit_ts;
+	return commit_ts;
 }
 
 ErrorData DuckTransactionManager::CommitTransaction(ClientContext &context, Transaction &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
-	auto checkpoint_decision = thread_is_checkpointing ? CheckpointDecision {false, "another thread is checkpointing"}
-	                                                   : CanCheckpoint(&transaction);
-	if (checkpoint_decision.can_checkpoint) {
-		if (transaction.AutomaticCheckpoint(db)) {
-			checkpoint_lock.Lock();
-		} else {
-			checkpoint_decision = {false, "no reason to automatically checkpoint"};
+	unique_lock<mutex> tlock(transaction_lock);
+	if (!db.IsSystem() && !db.IsTemporary()) {
+		if (transaction.ChangesMade()) {
+			if (transaction.IsReadOnly()) {
+				throw InternalException("Attempting to commit a transaction that is read-only but has made changes - "
+				                        "this should not be possible");
+			}
 		}
 	}
-	OnCommitCheckpointDecision(checkpoint_decision, transaction);
-
 	// obtain a commit id for the transaction
-	transaction_t commit_id = current_start_timestamp++;
+	transaction_t commit_id = GetCommitTimestamp();
+
+	// check if we can checkpoint
+	unique_ptr<StorageLockKey> lock;
+	auto undo_properties = transaction.GetUndoProperties();
+	auto checkpoint_decision = CanCheckpoint(transaction, lock, undo_properties);
 	// commit the UndoBuffer of the transaction
 	auto error = transaction.Commit(db, commit_id, checkpoint_decision.can_checkpoint);
 	if (error.HasError()) {
 		// commit unsuccessful: rollback the transaction instead
-		checkpoint_decision = CheckpointDecision {false, error.Message()};
+		checkpoint_decision = CheckpointDecision(error.Message());
 		transaction.commit_id = 0;
 		transaction.Rollback();
 	}
-	if (!checkpoint_decision.can_checkpoint) {
-		// we won't checkpoint after all: unlock the clients again
-		checkpoint_lock.Unlock();
-		client_locks.clear();
+	OnCommitCheckpointDecision(checkpoint_decision, transaction);
+
+	if (!checkpoint_decision.can_checkpoint && lock) {
+		// we won't checkpoint after all: unlock the checkpoint lock again
+		lock.reset();
 	}
 
 	// commit successful: remove the transaction id from the list of active transactions
 	// potentially resulting in garbage collection
-	RemoveTransaction(transaction);
+	bool store_transaction = undo_properties.has_updates || undo_properties.has_catalog_changes || error.HasError();
+	RemoveTransaction(transaction, store_transaction);
 	// now perform a checkpoint if (1) we are able to checkpoint, and (2) the WAL has reached sufficient size to
 	// checkpoint
 	if (checkpoint_decision.can_checkpoint) {
+		D_ASSERT(lock);
+		// we can unlock the transaction lock while checkpointing
+		tlock.unlock();
 		// checkpoint the database to disk
 		auto &storage_manager = db.GetStorageManager();
-		storage_manager.CreateCheckpoint(false, true);
+		CheckpointOptions options;
+		options.action = CheckpointAction::FORCE_CHECKPOINT;
+		options.type = checkpoint_decision.type;
+		storage_manager.CreateCheckpoint(options);
 	}
 	return error;
 }
@@ -239,7 +267,10 @@ void DuckTransactionManager::RollbackTransaction(Transaction &transaction_p) {
 }
 
 void DuckTransactionManager::RemoveTransaction(DuckTransaction &transaction) noexcept {
-	bool changes_made = transaction.ChangesMade();
+	RemoveTransaction(transaction, transaction.ChangesMade());
+}
+
+void DuckTransactionManager::RemoveTransaction(DuckTransaction &transaction, bool store_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
@@ -263,7 +294,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 (changes_made) {
+	if (store_transaction) {
 		// if the transaction made any changes we need to keep it around
 		if (transaction.commit_id != 0) {
 			// the transaction was committed, add it to the list of recently
@@ -275,9 +306,11 @@ void DuckTransactionManager::RemoveTransaction(DuckTransaction &transaction) noe
 			current_transaction->highest_active_query = current_query;
 			old_transactions.push_back(std::move(current_transaction));
 		}
+	} else if (transaction.ChangesMade()) {
+		transaction.Cleanup();
 	}
 	// remove the transaction from the set of currently active transactions
-	active_transactions.erase(active_transactions.begin() + t_index);
+	active_transactions.unsafe_erase_at(t_index);
 	// traverse the recently_committed transactions to see if we can remove any
 	idx_t i = 0;
 	for (; i < recently_committed_transactions.size(); i++) {
@@ -311,7 +344,7 @@ void DuckTransactionManager::RemoveTransaction(DuckTransaction &transaction) noe
 	if (i > 0) {
 		// we garbage collected transactions: remove them from the list
 		recently_committed_transactions.erase(recently_committed_transactions.begin(),
-		                                      recently_committed_transactions.begin() + i);
+		                                      recently_committed_transactions.begin() + static_cast<int64_t>(i));
 	}
 	// check if we can free the memory of any old transactions
 	i = active_transactions.empty() ? old_transactions.size() : 0;
@@ -326,7 +359,7 @@ void DuckTransactionManager::RemoveTransaction(DuckTransaction &transaction) noe
 	}
 	if (i > 0) {
 		// we garbage collected transactions: remove them from the list
-		old_transactions.erase(old_transactions.begin(), old_transactions.begin() + i);
+		old_transactions.erase(old_transactions.begin(), old_transactions.begin() + static_cast<int64_t>(i));
 	}
 }
 

package/src/duckdb/src/transaction/meta_transaction.cpp

@@ -24,6 +24,11 @@ Transaction &Transaction::Get(ClientContext &context, AttachedDatabase &db) {
 	return meta_transaction.GetTransaction(db);
 }
 
+optional_ptr<Transaction> Transaction::TryGet(ClientContext &context, AttachedDatabase &db) {
+	auto &meta_transaction = MetaTransaction::Get(context);
+	return meta_transaction.TryGetTransaction(db);
+}
+
 #ifdef DEBUG
 static void VerifyAllTransactionsUnique(AttachedDatabase &db, vector<reference<AttachedDatabase>> &all_transactions) {
 	for (auto &tx : all_transactions) {
@@ -34,6 +39,16 @@ static void VerifyAllTransactionsUnique(AttachedDatabase &db, vector<reference<A
 }
 #endif
 
+optional_ptr<Transaction> MetaTransaction::TryGetTransaction(AttachedDatabase &db) {
+	lock_guard<mutex> guard(lock);
+	auto entry = transactions.find(db);
+	if (entry == transactions.end()) {
+		return nullptr;
+	} else {
+		return &entry->second.get();
+	}
+}
+
 Transaction &MetaTransaction::GetTransaction(AttachedDatabase &db) {
 	lock_guard<mutex> guard(lock);
 	auto entry = transactions.find(db);
@@ -63,7 +78,7 @@ void MetaTransaction::RemoveTransaction(AttachedDatabase &db) {
 	for (idx_t i = 0; i < all_transactions.size(); i++) {
 		auto &db_entry = all_transactions[i];
 		if (RefersToSameObject(db_entry.get(), db)) {
-			all_transactions.erase(all_transactions.begin() + i);
+			all_transactions.erase_at(i);
 			break;
 		}
 	}
@@ -134,6 +149,9 @@ void MetaTransaction::ModifyDatabase(AttachedDatabase &db) {
 	}
 	if (!modified_database) {
 		modified_database = &db;
+
+		auto &transaction = GetTransaction(db);
+		transaction.SetReadWrite();
 		return;
 	}
 	if (&db != modified_database.get()) {

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

@@ -39,6 +39,8 @@ void RollbackState::RollbackEntry(UndoFlags type, data_ptr_t data) {
 		info->segment->RollbackUpdate(*info);
 		break;
 	}
+	case UndoFlags::SEQUENCE_VALUE:
+		break;
 	default: // LCOV_EXCL_START
 		D_ASSERT(type == UndoFlags::EMPTY_ENTRY);
 		break;

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

@@ -6,19 +6,19 @@
 namespace duckdb {
 
 Transaction::Transaction(TransactionManager &manager_p, ClientContext &context_p)
-    : manager(manager_p), context(context_p.shared_from_this()), active_query(MAXIMUM_QUERY_ID) {
+    : manager(manager_p), context(context_p.shared_from_this()), active_query(MAXIMUM_QUERY_ID), is_read_only(true) {
 }
 
 Transaction::~Transaction() {
 }
 
 bool Transaction::IsReadOnly() {
-	auto ctxt = context.lock();
-	if (!ctxt) {
-		throw InternalException("Transaction::IsReadOnly() called after client context has been destroyed");
-	}
-	auto &db = manager.GetDB();
-	return MetaTransaction::Get(*ctxt).ModifiedDatabase().get() != &db;
+	return is_read_only;
+}
+
+void Transaction::SetReadWrite() {
+	D_ASSERT(is_read_only);
+	is_read_only = false;
 }
 
 } // namespace duckdb

package/src/duckdb/src/transaction/undo_buffer.cpp

@@ -10,6 +10,7 @@
 #include "duckdb/transaction/cleanup_state.hpp"
 #include "duckdb/transaction/commit_state.hpp"
 #include "duckdb/transaction/rollback_state.hpp"
+#include "duckdb/execution/index/bound_index.hpp"
 
 namespace duckdb {
 constexpr uint32_t UNDO_ENTRY_HEADER_SIZE = sizeof(UndoFlags) + sizeof(uint32_t);
@@ -99,31 +100,55 @@ void UndoBuffer::ReverseIterateEntries(T &&callback) {
 }
 
 bool UndoBuffer::ChangesMade() {
+	// we need to search for any index creation entries
 	return !allocator.IsEmpty();
 }
 
-idx_t UndoBuffer::EstimatedSize() {
-
-	idx_t estimated_size = 0;
+UndoBufferProperties UndoBuffer::GetProperties() {
+	UndoBufferProperties properties;
+	if (!ChangesMade()) {
+		return properties;
+	}
 	auto node = allocator.GetHead();
 	while (node) {
-		estimated_size += node->current_position;
+		properties.estimated_size += node->current_position;
 		node = node->next.get();
 	}
 
 	// we need to search for any index creation entries
 	IteratorState iterator_state;
 	IterateEntries(iterator_state, [&](UndoFlags entry_type, data_ptr_t data) {
-		if (entry_type == UndoFlags::CATALOG_ENTRY) {
+		switch (entry_type) {
+		case UndoFlags::UPDATE_TUPLE:
+			properties.has_updates = true;
+			break;
+		case UndoFlags::DELETE_TUPLE:
+			properties.has_deletes = true;
+			break;
+		case UndoFlags::CATALOG_ENTRY: {
+			properties.has_catalog_changes = true;
+
 			auto catalog_entry = Load<CatalogEntry *>(data);
-			if (catalog_entry->Parent().type == CatalogType::INDEX_ENTRY) {
-				auto &index = catalog_entry->Parent().Cast<DuckIndexEntry>();
-				estimated_size += index.initial_index_size;
+			auto &parent = catalog_entry->Parent();
+			switch (parent.type) {
+			case CatalogType::DELETED_ENTRY:
+				properties.has_dropped_entries = true;
+				break;
+			case CatalogType::INDEX_ENTRY: {
+				auto &index = parent.Cast<DuckIndexEntry>();
+				properties.estimated_size += index.initial_index_size;
+				break;
 			}
+			default:
+				break;
+			}
+			break;
+		}
+		default:
+			break;
 		}
 	});
-
-	return estimated_size;
+	return properties;
 }
 
 void UndoBuffer::Cleanup() {
@@ -140,13 +165,8 @@ void UndoBuffer::Cleanup() {
 	IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CleanupEntry(type, data); });
 
 	// possibly vacuum indexes
-	for (const auto &table : state.indexed_tables) {
-		table.second->info->indexes.Scan([&](Index &index) {
-			if (!index.IsUnknown()) {
-				index.Vacuum();
-			}
-			return false;
-		});
+	for (auto &table : state.indexed_tables) {
+		table.second->VacuumIndexes();
 	}
 }
 

package/src/duckdb/third_party/concurrentqueue/concurrentqueue.h

@@ -1942,7 +1942,7 @@ private:
 					// block size (in order to get a correct signed block count offset in all cases):
 					auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
 					auto blockBaseIndex = index & ~static_cast<index_t>(BLOCK_SIZE - 1);
-					auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(blockBaseIndex - headBase) / BLOCK_SIZE);
+					auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(blockBaseIndex - headBase) / static_cast<typename std::make_signed<index_t>::type>(BLOCK_SIZE));
 					auto block = localBlockIndex->entries[(localBlockIndexHead + offset) & (localBlockIndex->size - 1)].block;
 					
 					// Dequeue
@@ -2202,7 +2202,7 @@ private:
 					
 					auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
 					auto firstBlockBaseIndex = firstIndex & ~static_cast<index_t>(BLOCK_SIZE - 1);
-					auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(firstBlockBaseIndex - headBase) / BLOCK_SIZE);
+					auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(firstBlockBaseIndex - headBase) / static_cast<typename std::make_signed<index_t>::type>(BLOCK_SIZE));
 					auto indexIndex = (localBlockIndexHead + offset) & (localBlockIndex->size - 1);
 					
 					// Iterate the blocks and dequeue
@@ -2875,7 +2875,7 @@ private:
 			assert(tailBase != INVALID_BLOCK_BASE);
 			// Note: Must use division instead of shift because the index may wrap around, causing a negative
 			// offset, whose negativity we want to preserve
-			auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(index - tailBase) / BLOCK_SIZE);
+			auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(index - tailBase) / static_cast<typename std::make_signed<index_t>::type>(BLOCK_SIZE));
 			size_t idx = (tail + offset) & (localBlockIndex->capacity - 1);
 			assert(localBlockIndex->index[idx]->key.load(std::memory_order_relaxed) == index && localBlockIndex->index[idx]->value.load(std::memory_order_relaxed) != nullptr);
 			return idx;
@@ -3630,7 +3630,7 @@ ConsumerToken::ConsumerToken(ConcurrentQueue<T, Traits>& queue)
 	: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
 {
 	initialOffset = queue.nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
-	lastKnownGlobalOffset = -1;
+	lastKnownGlobalOffset = uint32_t(-1);
 }
 
 template<typename T, typename Traits>
@@ -3638,7 +3638,7 @@ ConsumerToken::ConsumerToken(BlockingConcurrentQueue<T, Traits>& queue)
 	: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
 {
 	initialOffset = reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
-	lastKnownGlobalOffset = -1;
+	lastKnownGlobalOffset = uint32_t(-1);
 }
 
 template<typename T, typename Traits>

package/src/duckdb/third_party/fsst/fsst.h

@@ -184,7 +184,7 @@ duckdb_fsst_decompress(
          code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code]; 
          code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code]; 
      } else { 
-         unsigned long firstEscapePos=__builtin_ctzl((unsigned long long) escapeMask)>>3;
+         unsigned long firstEscapePos=static_cast<unsigned long>(__builtin_ctzl((unsigned long long) escapeMask)>>3);
          switch(firstEscapePos) { /* Duff's device */
          case 3: code = strIn[posIn++]; FSST_UNALIGNED_STORE(strOut+posOut, symbol[code]); posOut += len[code];
 			 DUCKDB_FSST_EXPLICIT_FALLTHROUGH;

package/src/duckdb/third_party/jaro_winkler/details/common.hpp

@@ -91,7 +91,7 @@ struct BitvectorHashmap {
     void insert_mask(CharT key, uint64_t mask)
     {
         uint64_t i = lookup(static_cast<uint64_t>(key));
-        m_map[i].key = key;
+        m_map[i].key = static_cast<uint64_t>(key);
         m_map[i].value |= mask;
     }
 
@@ -150,7 +150,7 @@ struct PatternMatchVector {
         for (int64_t i = 0; i < std::distance(first, last); ++i) {
             auto key = first[i];
             if (key >= 0 && key <= 255) {
-                m_extendedAscii[key] |= mask;
+                m_extendedAscii[static_cast<size_t>(key)] |= mask;
             }
             else {
                 m_map.insert_mask(key, mask);
@@ -175,7 +175,7 @@ struct PatternMatchVector {
     uint64_t get(CharT key) const
     {
         if (key >= 0 && key <= 255) {
-            return m_extendedAscii[key];
+            return m_extendedAscii[static_cast<size_t>(key)];
         }
         else {
             return m_map.get(key);
@@ -215,10 +215,10 @@ struct BlockPatternMatchVector {
 
         assert(block < m_block_count);
         if (key >= 0 && key <= 255) {
-            m_extendedAscii[key * m_block_count + block] |= mask;
+            m_extendedAscii[static_cast<size_t>(key * m_block_count + block)] |= mask;
         }
         else {
-            m_map[block].insert_mask(key, mask);
+            m_map[static_cast<size_t>(block)].insert_mask(key, mask);
         }
     }
 
@@ -227,8 +227,8 @@ struct BlockPatternMatchVector {
     {
         int64_t len = std::distance(first, last);
         m_block_count = ceildiv(len, 64);
-        m_map.resize(m_block_count);
-        m_extendedAscii.resize(m_block_count * 256);
+        m_map.resize(static_cast<size_t>(m_block_count));
+        m_extendedAscii.resize(static_cast<size_t>(m_block_count * 256));
 
         for (int64_t i = 0; i < len; ++i) {
             int64_t block = i / 64;
@@ -251,10 +251,10 @@ struct BlockPatternMatchVector {
     {
         assert(block < m_block_count);
         if (key >= 0 && key <= 255) {
-            return m_extendedAscii[key * m_block_count + block];
+            return m_extendedAscii[static_cast<size_t>(key * m_block_count + block)];
         }
         else {
-            return m_map[block].get(key);
+            return m_map[static_cast<size_t>(block)].get(key);
         }
     }