duckdb 1.4.0 → 1.4.1

package/src/duckdb/src/storage/table/update_segment.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/transaction/update_info.hpp"
 #include "duckdb/transaction/undo_buffer.hpp"
+#include "duckdb/storage/data_table.hpp"
 
 #include <algorithm>
 
@@ -104,9 +105,10 @@ idx_t UpdateInfo::GetAllocSize(idx_t type_size) {
 	return AlignValue<idx_t>(sizeof(UpdateInfo) + (sizeof(sel_t) + type_size) * STANDARD_VECTOR_SIZE);
 }
 
-void UpdateInfo::Initialize(UpdateInfo &info, transaction_t transaction_id) {
+void UpdateInfo::Initialize(UpdateInfo &info, DataTable &data_table, transaction_t transaction_id) {
 	info.max = STANDARD_VECTOR_SIZE;
 	info.version_number = transaction_id;
+	info.table = &data_table;
 	info.segment = nullptr;
 	info.prev.entry = nullptr;
 	info.next.entry = nullptr;
@@ -1236,11 +1238,11 @@ static idx_t SortSelectionVector(SelectionVector &sel, idx_t count, row_t *ids)
 	return pos;
 }
 
-UpdateInfo *CreateEmptyUpdateInfo(TransactionData transaction, idx_t type_size, idx_t count,
+UpdateInfo *CreateEmptyUpdateInfo(TransactionData transaction, DataTable &data_table, idx_t type_size, idx_t count,
                                   unsafe_unique_array<char> &data) {
 	data = make_unsafe_uniq_array_uninitialized<char>(UpdateInfo::GetAllocSize(type_size));
 	auto update_info = reinterpret_cast<UpdateInfo *>(data.get());
-	UpdateInfo::Initialize(*update_info, transaction.transaction_id);
+	UpdateInfo::Initialize(*update_info, data_table, transaction.transaction_id);
 	return update_info;
 }
 
@@ -1258,8 +1260,8 @@ void UpdateSegment::InitializeUpdateInfo(idx_t vector_idx) {
 	}
 }
 
-void UpdateSegment::Update(TransactionData transaction, idx_t column_index, Vector &update_p, row_t *ids, idx_t count,
-                           Vector &base_data) {
+void UpdateSegment::Update(TransactionData transaction, DataTable &data_table, idx_t column_index, Vector &update_p,
+                           row_t *ids, idx_t count, Vector &base_data) {
 	// obtain an exclusive lock
 	auto write_lock = lock.GetExclusiveLock();
 
@@ -1322,10 +1324,10 @@ void UpdateSegment::Update(TransactionData transaction, idx_t column_index, Vect
 			// no updates made yet by this transaction: initially the update info to empty
 			if (transaction.transaction) {
 				auto &dtransaction = transaction.transaction->Cast<DuckTransaction>();
-				node_ref = dtransaction.CreateUpdateInfo(type_size, count);
+				node_ref = dtransaction.CreateUpdateInfo(type_size, data_table, count);
 				node = &UpdateInfo::Get(node_ref);
 			} else {
-				node = CreateEmptyUpdateInfo(transaction, type_size, count, update_info_data);
+				node = CreateEmptyUpdateInfo(transaction, data_table, type_size, count, update_info_data);
 			}
 			node->segment = this;
 			node->vector_index = vector_index;
@@ -1360,7 +1362,7 @@ void UpdateSegment::Update(TransactionData transaction, idx_t column_index, Vect
 		idx_t alloc_size = UpdateInfo::GetAllocSize(type_size);
 		auto handle = root->allocator.Allocate(alloc_size);
 		auto &update_info = UpdateInfo::Get(handle);
-		UpdateInfo::Initialize(update_info, TRANSACTION_ID_START - 1);
+		UpdateInfo::Initialize(update_info, data_table, TRANSACTION_ID_START - 1);
 		update_info.column_index = column_index;
 
 		InitializeUpdateInfo(update_info, ids, sel, count, vector_index, vector_offset);
@@ -1370,10 +1372,10 @@ void UpdateSegment::Update(TransactionData transaction, idx_t column_index, Vect
 		UndoBufferReference node_ref;
 		optional_ptr<UpdateInfo> transaction_node;
 		if (transaction.transaction) {
-			node_ref = transaction.transaction->CreateUpdateInfo(type_size, count);
+			node_ref = transaction.transaction->CreateUpdateInfo(type_size, data_table, count);
 			transaction_node = &UpdateInfo::Get(node_ref);
 		} else {
-			transaction_node = CreateEmptyUpdateInfo(transaction, type_size, count, update_info_data);
+			transaction_node = CreateEmptyUpdateInfo(transaction, data_table, type_size, count, update_info_data);
 		}
 
 		InitializeUpdateInfo(*transaction_node, ids, sel, count, vector_index, vector_offset);

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

@@ -165,6 +165,12 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 	case UndoFlags::INSERT_TUPLE: {
 		// append:
 		auto info = reinterpret_cast<AppendInfo *>(data);
+		if (!info->table->IsMainTable()) {
+			auto table_name = info->table->GetTableName();
+			auto table_modification = info->table->TableModification();
+			throw TransactionException("Attempting to modify table %s but another transaction has %s this table",
+			                           table_name, table_modification);
+		}
 		// mark the tuples as committed
 		info->table->CommitAppend(commit_id, info->start_row, info->count);
 		break;
@@ -172,6 +178,12 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 	case UndoFlags::DELETE_TUPLE: {
 		// deletion:
 		auto info = reinterpret_cast<DeleteInfo *>(data);
+		if (!info->table->IsMainTable()) {
+			auto table_name = info->table->GetTableName();
+			auto table_modification = info->table->TableModification();
+			throw TransactionException("Attempting to modify table %s but another transaction has %s this table",
+			                           table_name, table_modification);
+		}
 		// mark the tuples as committed
 		info->version_info->CommitDelete(info->vector_idx, commit_id, *info);
 		break;
@@ -179,6 +191,12 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 	case UndoFlags::UPDATE_TUPLE: {
 		// update:
 		auto info = reinterpret_cast<UpdateInfo *>(data);
+		if (!info->table->IsMainTable()) {
+			auto table_name = info->table->GetTableName();
+			auto table_modification = info->table->TableModification();
+			throw TransactionException("Attempting to modify table %s but another transaction has %s this table",
+			                           table_name, table_modification);
+		}
 		info->version_number = commit_id;
 		break;
 	}

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

@@ -126,11 +126,11 @@ void DuckTransaction::PushAppend(DataTable &table, idx_t start_row, idx_t row_co
 	append_info->count = row_count;
 }
 
-UndoBufferReference DuckTransaction::CreateUpdateInfo(idx_t type_size, idx_t entries) {
+UndoBufferReference DuckTransaction::CreateUpdateInfo(idx_t type_size, DataTable &data_table, idx_t entries) {
 	idx_t alloc_size = UpdateInfo::GetAllocSize(type_size);
 	auto undo_entry = undo_buffer.CreateEntry(UndoFlags::UPDATE_TUPLE, alloc_size);
 	auto &update_info = UpdateInfo::Get(undo_entry);
-	UpdateInfo::Initialize(update_info, transaction_id);
+	UpdateInfo::Initialize(update_info, data_table, transaction_id);
 	return undo_entry;
 }
 
@@ -246,14 +246,6 @@ ErrorData DuckTransaction::Commit(AttachedDatabase &db, transaction_t new_commit
 		// no need to flush anything if we made no changes
 		return ErrorData();
 	}
-	for (auto &entry : modified_tables) {
-		auto &tbl = entry.first.get();
-		if (!tbl.IsMainTable()) {
-			return ErrorData(
-			    TransactionException("Attempting to modify table %s but another transaction has %s this table",
-			                         tbl.GetTableName(), tbl.TableModification()));
-		}
-	}
 	D_ASSERT(db.IsSystem() || db.IsTemporary() || !IsReadOnly());
 
 	UndoBuffer::IteratorState iterator_state;

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

@@ -27,10 +27,10 @@ WALWriteState::WALWriteState(DuckTransaction &transaction_p, WriteAheadLog &log,
     : transaction(transaction_p), log(log), commit_state(commit_state), current_table_info(nullptr) {
 }
 
-void WALWriteState::SwitchTable(DataTableInfo *table_info, UndoFlags new_op) {
-	if (current_table_info != table_info) {
+void WALWriteState::SwitchTable(DataTableInfo &table_info, UndoFlags new_op) {
+	if (current_table_info != &table_info) {
 		// write the current table to the log
-		log.WriteSetTable(table_info->GetSchemaName(), table_info->GetTableName());
+		log.WriteSetTable(table_info.GetSchemaName(), table_info.GetTableName());
 		current_table_info = table_info;
 	}
 }
@@ -171,7 +171,7 @@ void WALWriteState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
 
 void WALWriteState::WriteDelete(DeleteInfo &info) {
 	// switch to the current table, if necessary
-	SwitchTable(info.table->GetDataTableInfo().get(), UndoFlags::DELETE_TUPLE);
+	SwitchTable(*info.table->GetDataTableInfo(), UndoFlags::DELETE_TUPLE);
 
 	if (!delete_chunk) {
 		delete_chunk = make_uniq<DataChunk>();
@@ -198,7 +198,7 @@ void WALWriteState::WriteUpdate(UpdateInfo &info) {
 	auto &column_data = info.segment->column_data;
 	auto &table_info = column_data.GetTableInfo();
 
-	SwitchTable(&table_info, UndoFlags::UPDATE_TUPLE);
+	SwitchTable(table_info, UndoFlags::UPDATE_TUPLE);
 
 	// initialize the update chunk
 	vector<LogicalType> update_types;

package/src/duckdb/third_party/httplib/httplib.hpp

@@ -7077,7 +7077,12 @@ inline bool ClientImpl::redirect(Request &req, Response &res, Error &error) {
   }
 
   auto location = res.get_header_value("location");
-  if (location.empty()) { return false; }
+  if (location.empty()) {
+    // s3 requests will not return a location header, and instead a
+    // X-Amx-Region-Bucket header. Return true so all response headers
+    // are returned to the httpfs/calling extension
+    return true;
+  }
 
   const Regex re(
       R"((?:(https?):)?(?://(?:\[([\d:]+)\]|([^:/?#]+))(?::(\d+))?)?([^?#]*)(\?[^#]*)?(?:#.*)?)");

package/src/duckdb/ub_src_function_table_system.cpp

@@ -1,3 +1,5 @@
+#include "src/function/table/system/duckdb_connection_count.cpp"
+
 #include "src/function/table/system/duckdb_approx_database_count.cpp"
 
 #include "src/function/table/system/duckdb_columns.cpp"