From 5647e32d60450adb265186f291c775f74d414d41 Mon Sep 17 00:00:00 2001 From: Xander Date: Mon, 16 Nov 2026 18:06:23 +0000 Subject: [PATCH 1/2] fix(transaction): keep only the first requirement on each value Each action derives its requirements from the transaction-local table, so a second action asserts state that an earlier action in the same transaction wrote. Catalogs check requirements against the transaction base, so two fast appends in one transaction failed with "Requirement failed: Branch or tag `main` not found". The first requirement on each value is the one derived from the base; later ones on the same value are now dropped. Refs are matched by name. Prior art: #3075, which took the same approach alongside other changes. --- crates/iceberg/src/transaction/mod.rs | 108 +++++++++++++++++++++++++- 1 file changed, 106 insertions(+), 2 deletions(-) diff --git a/crates/iceberg/src/transaction/mod.rs b/crates/iceberg/src/transaction/mod.rs index 2018af2fc1..c91b8949ce 100644 --- a/crates/iceberg/src/transaction/mod.rs +++ b/crates/iceberg/src/transaction/mod.rs @@ -125,11 +125,37 @@ impl Transaction { let updated_table = Self::update_table_metadata(table, &updates)?; existing_updates.extend(updates); - existing_requirements.extend(requirements); + Self::merge_requirements(existing_requirements, requirements); Ok(updated_table) } + /// Catalogs check requirements against the transaction base, which only the first + /// requirement on each value was derived from, so later ones on the same value are dropped. + fn merge_requirements( + existing_requirements: &mut Vec, + requirements: Vec, + ) { + for requirement in requirements { + if !existing_requirements + .iter() + .any(|existing| Self::asserts_same_value(existing, &requirement)) + { + existing_requirements.push(requirement); + } + } + } + + fn asserts_same_value(left: &TableRequirement, right: &TableRequirement) -> bool { + match (left, right) { + ( + TableRequirement::RefSnapshotIdMatch { r#ref: left, .. }, + TableRequirement::RefSnapshotIdMatch { r#ref: right, .. }, + ) => left == right, + _ => std::mem::discriminant(left) == std::mem::discriminant(right), + } + } + /// Sets table to a new version. pub fn upgrade_table_version(&self) -> UpgradeFormatVersionAction { UpgradeFormatVersionAction::new() @@ -271,7 +297,7 @@ mod tests { use crate::table::{StaticTable, Table}; use crate::test_utils::{make_encrypted_table, test_runtime}; use crate::transaction::{ApplyTransactionAction, Transaction}; - use crate::{Catalog, Error, ErrorKind, TableCreation, TableIdent}; + use crate::{Catalog, Error, ErrorKind, TableCreation, TableIdent, TableRequirement}; pub fn make_v1_table() -> Table { let file = File::open(format!( @@ -647,6 +673,84 @@ mod tests { assert_eq!(summary.get("total-files-size").unwrap(), "300"); } + #[tokio::test] + async fn test_commit_two_fast_appends_in_one_transaction() { + let catalog = new_memory_catalog().await; + let table = make_v3_minimal_table_in_catalog(&catalog).await; + let data_file = |path: &str| { + DataFileBuilder::default() + .content(DataContentType::Data) + .file_path(path.to_string()) + .file_format(DataFileFormat::Parquet) + .file_size_in_bytes(100) + .record_count(10) + .partition(Struct::from_iter([Some(Literal::long(1))])) + .partition_spec_id(0) + .build() + .unwrap() + }; + + let tx = Transaction::new(&table); + let tx = tx + .fast_append() + .add_data_files(vec![data_file("test/1.parquet")]) + .apply(tx) + .unwrap(); + let tx = tx + .fast_append() + .add_data_files(vec![data_file("test/2.parquet")]) + .apply(tx) + .unwrap(); + let table = tx.commit(&catalog).await.unwrap(); + + let current = table.metadata().current_snapshot().unwrap(); + let parent = table + .metadata() + .snapshot_by_id(current.parent_snapshot_id().unwrap()) + .unwrap(); + assert_eq!( + ( + table.metadata().snapshots().count(), + parent.parent_snapshot_id(), + current.summary().additional_properties["total-data-files"].as_str(), + ), + (2, None, "2") + ); + } + + #[test] + fn test_merge_requirements_keeps_the_first_requirement_on_each_value() { + let main = |snapshot_id| TableRequirement::RefSnapshotIdMatch { + r#ref: "main".to_string(), + snapshot_id, + }; + let branch = TableRequirement::RefSnapshotIdMatch { + r#ref: "branch".to_string(), + snapshot_id: Some(2), + }; + let mut requirements = vec![main(None), TableRequirement::CurrentSchemaIdMatch { + current_schema_id: 0, + }]; + + Transaction::merge_requirements(&mut requirements, vec![ + main(Some(1)), + branch.clone(), + TableRequirement::CurrentSchemaIdMatch { + current_schema_id: 1, + }, + TableRequirement::DefaultSpecIdMatch { default_spec_id: 0 }, + ]); + + assert_eq!(requirements, vec![ + main(None), + TableRequirement::CurrentSchemaIdMatch { + current_schema_id: 0 + }, + branch, + TableRequirement::DefaultSpecIdMatch { default_spec_id: 0 }, + ]); + } + #[tokio::test] async fn test_commit_to_encrypted_table() { let table = make_encrypted_table().await.with_metadata_location( From e13645d73e9d6df0d49f34198061d2fd214ffeaa Mon Sep 17 00:00:00 2001 From: Xander Date: Tue, 17 Nov 2026 11:59:55 +0000 Subject: [PATCH 2/2] docs(transaction): shorten merge_requirements comment --- crates/iceberg/src/transaction/mod.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/crates/iceberg/src/transaction/mod.rs b/crates/iceberg/src/transaction/mod.rs index c91b8949ce..50b51fe90f 100644 --- a/crates/iceberg/src/transaction/mod.rs +++ b/crates/iceberg/src/transaction/mod.rs @@ -130,8 +130,7 @@ impl Transaction { Ok(updated_table) } - /// Catalogs check requirements against the transaction base, which only the first - /// requirement on each value was derived from, so later ones on the same value are dropped. + // Catalogs check against the base, so keep only the first requirement per value. fn merge_requirements( existing_requirements: &mut Vec, requirements: Vec,