duckdb 1.3.2-dev0.0 → 1.3.2

package/src/duckdb/src/storage/compression/roaring/compress.cpp

@@ -308,24 +308,30 @@ void RoaringCompressState::FlushSegment() {
 	base_ptr += sizeof(idx_t);
 
 	// Size of the 'd' part
-	idx_t data_size = NumericCast<idx_t>(data_ptr - base_ptr);
-	data_size = AlignValue(data_size);
+	auto unaligned_data_size = NumericCast<idx_t>(data_ptr - base_ptr);
+	auto data_size = AlignValue(unaligned_data_size);
+	data_ptr += data_size - unaligned_data_size;
 
 	// Size of the 'm' part
-	idx_t metadata_size = metadata_collection.GetMetadataSizeForSegment();
-
+	auto metadata_size = metadata_collection.GetMetadataSizeForSegment();
 	if (current_segment->count.load() == 0) {
 		D_ASSERT(metadata_size == 0);
 		return;
 	}
 
-	idx_t serialized_metadata_size = metadata_collection.Serialize(data_ptr);
+	auto serialized_metadata_size = metadata_collection.Serialize(data_ptr);
+	if (metadata_size != serialized_metadata_size) {
+		throw InternalException("mismatch in metadata size during RoaringCompressState::FlushSegment");
+	}
+
 	metadata_collection.FlushSegment();
-	(void)serialized_metadata_size;
-	D_ASSERT(metadata_size == serialized_metadata_size);
-	idx_t metadata_start = static_cast<idx_t>(data_ptr - base_ptr);
+	auto metadata_start = static_cast<idx_t>(data_ptr - base_ptr);
+	if (metadata_start > info.GetBlockSize()) {
+		throw InternalException("metadata start outside of block size during RoaringCompressState::FlushSegment");
+	}
+
 	Store<idx_t>(metadata_start, handle.Ptr());
-	idx_t total_segment_size = sizeof(idx_t) + data_size + metadata_size;
+	auto total_segment_size = sizeof(idx_t) + data_size + metadata_size;
 	state.FlushSegment(std::move(current_segment), std::move(handle), total_segment_size);
 }
 

package/src/duckdb/src/storage/compression/roaring/scan.cpp

@@ -203,11 +203,20 @@ void BitsetContainerScanState::Verify() const {
 RoaringScanState::RoaringScanState(ColumnSegment &segment) : segment(segment) {
 	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
 	handle = buffer_manager.Pin(segment.block);
-	auto base_ptr = handle.Ptr() + segment.GetBlockOffset();
+	auto segment_size = segment.SegmentSize();
+	auto segment_block_offset = segment.GetBlockOffset();
+	if (segment_block_offset >= segment_size) {
+		throw InternalException("invalid segment_block_offset in RoaringScanState constructor");
+	}
+
+	auto base_ptr = handle.Ptr() + segment_block_offset;
 	data_ptr = base_ptr + sizeof(idx_t);
 
 	// Deserialize the container metadata for this segment
 	auto metadata_offset = Load<idx_t>(base_ptr);
+	if (metadata_offset >= segment_size) {
+		throw InternalException("invalid metadata offset in RoaringScanState constructor");
+	}
 	auto metadata_ptr = data_ptr + metadata_offset;
 
 	auto segment_count = segment.count.load();

package/src/duckdb/src/storage/data_table.cpp

@@ -415,7 +415,7 @@ TableStorageInfo DataTable::GetStorageInfo() {
 //===--------------------------------------------------------------------===//
 void DataTable::Fetch(DuckTransaction &transaction, DataChunk &result, const vector<StorageIndex> &column_ids,
                       const Vector &row_identifiers, idx_t fetch_count, ColumnFetchState &state) {
-	auto lock = info->checkpoint_lock.GetSharedLock();
+	auto lock = transaction.SharedLockTable(*info);
 	row_groups->Fetch(transaction, result, column_ids, row_identifiers, fetch_count, state);
 }
 

package/src/duckdb/src/storage/statistics/numeric_stats.cpp

@@ -375,7 +375,8 @@ Value NumericValueUnionToValue(const LogicalType &type, const NumericValueUnion
 }
 
 bool NumericStats::HasMinMax(const BaseStatistics &stats) {
-	return NumericStats::HasMin(stats) && NumericStats::HasMax(stats);
+	return NumericStats::HasMin(stats) && NumericStats::HasMax(stats) &&
+	       NumericStats::Min(stats) <= NumericStats::Max(stats);
 }
 
 bool NumericStats::HasMin(const BaseStatistics &stats) {

package/src/duckdb/src/storage/storage_info.cpp

@@ -81,6 +81,7 @@ static const StorageVersionInfo storage_version_info[] = {
 	{"v1.2.2", 65},
 	{"v1.3.0", 66},
 	{"v1.3.1", 66},
+	{"v1.3.2", 66},
 	{nullptr, 0}
 };
 // END OF STORAGE VERSION INFO
@@ -104,6 +105,7 @@ static const SerializationVersionInfo serialization_version_info[] = {
 	{"v1.2.2", 4},
 	{"v1.3.0", 5},
 	{"v1.3.1", 5},
+	{"v1.3.2", 5},
 	{"latest", 5},
 	{nullptr, 0}
 };

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

@@ -117,7 +117,9 @@ void ColumnCheckpointState::FlushSegment(unique_ptr<ColumnSegment> segment, Buff
 
 void ColumnCheckpointState::FlushSegmentInternal(unique_ptr<ColumnSegment> segment, idx_t segment_size) {
 	auto block_size = partial_block_manager.GetBlockManager().GetBlockSize();
-	D_ASSERT(segment_size <= block_size);
+	if (segment_size > block_size) {
+		throw InternalException("segment size exceeds block size in ColumnCheckpointState::FlushSegmentInternal");
+	}
 
 	auto tuple_count = segment->count.load();
 	if (tuple_count == 0) { // LCOV_EXCL_START

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

@@ -269,14 +269,17 @@ ErrorData DuckTransactionManager::CommitTransaction(ClientContext &context, Tran
 	if (!error.HasError()) {
 		error = transaction.Commit(db, commit_id, std::move(commit_state));
 	}
+
 	if (error.HasError()) {
-		// commit unsuccessful: rollback the transaction instead
+		// COMMIT not successful: ROLLBACK.
 		checkpoint_decision = CheckpointDecision(error.Message());
 		transaction.commit_id = 0;
+
 		auto rollback_error = transaction.Rollback();
 		if (rollback_error.HasError()) {
-			throw FatalException("Failed to rollback transaction. Cannot continue operation.\nError: %s",
-			                     rollback_error.Message());
+			throw FatalException(
+			    "Failed to rollback transaction. Cannot continue operation.\nOriginal Error: %s\nRollback Error: %s",
+			    error.Message(), rollback_error.Message());
 		}
 	} else {
 		// check if catalog changes were made