duckdb 1.2.1-dev6.0 → 1.2.1

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

@@ -430,14 +430,13 @@ bool RowGroup::CheckZonemap(ScanFilterInfo &filters) {
 		if (prune_result == FilterPropagateResult::FILTER_ALWAYS_FALSE) {
 			return false;
 		}
-		if (prune_result == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-			// filter is always true - no need to check it
-			// label the filter as always true so we don't need to check it anymore
-			filters.SetFilterAlwaysTrue(i);
-		}
 		if (filter.filter_type == TableFilterType::OPTIONAL_FILTER) {
 			// these are only for row group checking, set as always true so we don't check it
 			filters.SetFilterAlwaysTrue(i);
+		} else if (prune_result == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
+			// filter is always true - no need to check it
+			// label the filter as always true so we don't need to check it anymore
+			filters.SetFilterAlwaysTrue(i);
 		}
 	}
 	return true;
@@ -619,7 +618,7 @@ void RowGroup::TemplatedScan(TransactionData transaction, CollectionScanState &s
 						if (prune_result == FilterPropagateResult::FILTER_ALWAYS_FALSE) {
 							// We can just break out of the loop here.
 							approved_tuple_count = 0;
-							break;
+							continue;
 						}
 
 						// Generate row ids

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

@@ -25,6 +25,9 @@ void TableScanState::Initialize(vector<StorageIndex> column_ids_p, optional_ptr<
 	if (table_sampling) {
 		sampling_info.do_system_sample = table_sampling->method == SampleMethod::SYSTEM_SAMPLE;
 		sampling_info.sample_rate = table_sampling->sample_size.GetValue<double>() / 100.0;
+		if (table_sampling->seed.IsValid()) {
+			table_state.random.SetSeed(table_sampling->seed.GetIndex());
+		}
 	}
 }
 
@@ -96,6 +99,9 @@ void ScanFilterInfo::CheckAllFilters() {
 
 void ScanFilterInfo::SetFilterAlwaysTrue(idx_t filter_idx) {
 	auto &filter = filter_list[filter_idx];
+	if (filter.always_true) {
+		return;
+	}
 	filter.always_true = true;
 	column_has_filter[filter.scan_column_index] = false;
 	always_true_filters++;

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

@@ -192,6 +192,7 @@ bool DuckTransaction::ShouldWriteToWAL(AttachedDatabase &db) {
 }
 
 ErrorData DuckTransaction::WriteToWAL(AttachedDatabase &db, unique_ptr<StorageCommitState> &commit_state) noexcept {
+	ErrorData error_data;
 	try {
 		D_ASSERT(ShouldWriteToWAL(db));
 		auto &storage_manager = db.GetStorageManager();
@@ -206,13 +207,20 @@ ErrorData DuckTransaction::WriteToWAL(AttachedDatabase &db, unique_ptr<StorageCo
 			storage_manager.GetBlockManager().FileSync();
 		}
 	} catch (std::exception &ex) {
-		if (commit_state) {
+		// Call RevertCommit() outside this try-catch as it itself may throw
+		error_data = ErrorData(ex);
+	}
+
+	if (commit_state && error_data.HasError()) {
+		try {
 			commit_state->RevertCommit();
 			commit_state.reset();
+		} catch (std::exception &) {
+			// Ignore this error. If we fail to RevertCommit(), just return the original exception
 		}
-		return ErrorData(ex);
 	}
-	return ErrorData();
+
+	return error_data;
 }
 
 ErrorData DuckTransaction::Commit(AttachedDatabase &db, transaction_t new_commit_id,

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

@@ -194,7 +194,7 @@ void DuckTransactionManager::Checkpoint(ClientContext &context, bool force) {
 		// we cannot do a full checkpoint if any transaction needs to read old data
 		options.type = CheckpointType::CONCURRENT_CHECKPOINT;
 	}
-	storage_manager.CreateCheckpoint(options);
+	storage_manager.CreateCheckpoint(context, options);
 }
 
 unique_ptr<StorageLockKey> DuckTransactionManager::SharedCheckpointLock() {
@@ -295,7 +295,7 @@ ErrorData DuckTransactionManager::CommitTransaction(ClientContext &context, Tran
 		options.action = CheckpointAction::ALWAYS_CHECKPOINT;
 		options.type = checkpoint_decision.type;
 		auto &storage_manager = db.GetStorageManager();
-		storage_manager.CreateCheckpoint(options);
+		storage_manager.CreateCheckpoint(context, options);
 	}
 	return error;
 }

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

@@ -1254,6 +1254,23 @@ public:
 		return size;
 	}
 	
+
+	// Returns the number of producers currently associated with the queue.
+	size_t size_producers_approx() const
+	{
+		size_t size = 0;
+		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+			size += 1;
+		}
+		return size;
+	}
+
+	// Returns the number of elements currently in the queue for a specific producer.
+	size_t size_producer_approx(producer_token_t const& producer) const
+	{
+		return static_cast<ExplicitProducer*>(producer.producer)->size_approx();
+	}
+
 	
 	// Returns true if the underlying atomic variables used by
 	// the queue are lock-free (they should be on most platforms).

package/src/duckdb/ub_src_parallel.cpp

@@ -26,6 +26,8 @@
 
 #include "src/parallel/task_executor.cpp"
 
+#include "src/parallel/task_notifier.cpp"
+
 #include "src/parallel/task_scheduler.cpp"
 
 #include "src/parallel/thread_context.cpp"