[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_6323":6324,"_6325":62,"_6326":18,"_6327":18,"_6328":18,"_6329":62,"_6330":18,"_6331":18,"_6332":18,"_6333":18,"_6334":-5,"_6335":6336},"routes/s.$postId",{"_9":10,"_11":12,"_13":-7,"_14":-7,"_15":16,"_17":18,"_19":18,"_20":-5,"_21":22},"kind","post_with_profile","postWithProfile",{"_23":24,"_25":26},"messagingRoomId","referrer","imagegenOgImagePolicy","current_wide","preferIntrinsicAspectRatioForOgImage",false,"enforceRenderedOgImg","ogImageVariantOverride","defaultOgDescription","ChatGPT helps you get answers, find inspiration, and be more productive.","post",{"_45":46,"_47":48,"_49":-5,"_50":-5,"_51":-5,"_52":-5,"_53":54,"_55":56,"_38":57,"_58":59,"_60":18},"profile",{"_27":28,"_29":28,"_30":31,"_32":-5,"_33":-5,"_34":35,"_36":18,"_37":-5,"_38":-5,"_39":-5,"_40":18,"_41":-5,"_42":-5,"_43":-5,"_44":18},"user_id","anonymous","username","profile_picture_url","https://cdn.openai.com/sora/images/profile_placeholder_v4.png","profile_picture_id","is_default_profile_picture","follower_count",0,"is_following","display_name","permalink","can_cameo","verified","character_count","owner_profile","social_context","follows_you","id","cd_69fc383cce148191b9466b7f15d9eeff","posted_at",1778137148.805109,"text","og_title","og_description","og_image_variant","attachments",[68],"preview_image_url","https://ogimg.chatgpt.com/?postId=cd_69fc383cce148191b9466b7f15d9eeff","https://chatgpt.com/s/cd_69fc383cce148191b9466b7f15d9eeff","permissions",{"_61":62,"_63":18,"_64":18,"_65":62,"_66":67},"use_experimental_unfurl","can_read",true,"can_write","can_delete","can_remix","share_setting","public",{"_45":69,"_70":71,"_9":72,"_73":74,"_75":76,"_77":78,"_79":80,"_81":82,"_83":-5},"cd_69fc383cce148191b9466b7f15d9eeff-attachment-0","tags",[],"codex","task",{"_45":6278,"_138":6279,"_352":6280,"_6281":62,"_86":87,"_6282":18,"_6283":6284,"_243":18,"_6285":6286,"_6287":-5,"_6288":6289},"current_user_turn",{"_112":284,"_45":104,"_116":284,"_285":6274,"_287":-5,"_288":289,"_150":102,"_138":290},"current_assistant_turn",{"_112":113,"_45":87,"_114":-5,"_115":-5,"_116":113,"_117":6251,"_119":6252,"_121":122,"_123":6253,"_125":-5,"_126":6254,"_128":6255,"_130":6256,"_132":133,"_134":-5,"_135":136,"_137":-5,"_138":139,"_140":-5,"_141":142,"_143":6257,"_145":146,"_147":-5,"_148":-5,"_149":-5,"_150":104,"_151":6258,"_153":-5,"_154":-5,"_155":18,"_156":157,"_158":-5},"current_diff_task_turn",{"_112":113,"_45":102,"_114":-5,"_115":-5,"_116":113,"_117":6185,"_119":6186,"_121":122,"_123":-5,"_125":-5,"_126":6187,"_128":6188,"_130":6189,"_132":304,"_134":-5,"_135":305,"_137":6190,"_138":307,"_140":-5,"_141":142,"_143":6191,"_145":146,"_147":309,"_148":310,"_149":-5,"_150":100,"_151":6192,"_153":-5,"_154":-5,"_155":18,"_156":157,"_158":-5},"turns",{"_84":85,"_86":87},"example_task_info","turn_mapping",{"_88":89,"_90":91,"_92":93,"_94":95,"_96":97,"_98":99,"_100":101,"_102":103,"_104":105,"_87":106},"current_turn_id","task_e_69fc383a26d08330884ce8c58eaec061~assttrn_e_69fd5a298cac8330a0230e91c653b0ad","task_e_69fc383a26d08330884ce8c58eaec061~usertrn_e_69fc383b182c833092e333f20c19ffdd",{"_45":88,"_107":6144,"_109":6145,"_111":-5},"task_e_69fc383a26d08330884ce8c58eaec061~assttrn_e_69fc383b38e483309e0f5d0912b6093e",{"_45":90,"_107":6079,"_109":6080,"_111":88},"task_e_69fc383a26d08330884ce8c58eaec061~usertrn_e_69fc4186cbd8833095c4df57f09d7de7",{"_45":92,"_107":6071,"_109":6072,"_111":90},"task_e_69fc383a26d08330884ce8c58eaec061~assttrn_e_69fc418791808330a2f29c856f13f23b",{"_45":94,"_107":5295,"_109":5296,"_111":92},"task_e_69fc383a26d08330884ce8c58eaec061~usertrn_e_69fd4b66aabc8330b862b43741b86587",{"_45":96,"_107":5287,"_109":5288,"_111":94},"task_e_69fc383a26d08330884ce8c58eaec061~assttrn_e_69fd4b6781148330a381fd64974ec8b5",{"_45":98,"_107":4425,"_109":4426,"_111":96},"task_e_69fc383a26d08330884ce8c58eaec061~usertrn_e_69fd5169b1c88330854295600e12c0ff",{"_45":100,"_107":4417,"_109":4418,"_111":98},"task_e_69fc383a26d08330884ce8c58eaec061~assttrn_e_69fd516a89148330a1fd5e7859285839",{"_45":102,"_107":297,"_109":298,"_111":100},"task_e_69fc383a26d08330884ce8c58eaec061~usertrn_e_69fd5a28b1f8833087494363e98ff560",{"_45":104,"_107":282,"_109":283,"_111":102},{"_45":87,"_107":108,"_109":110,"_111":104},"turn",{"_112":113,"_45":87,"_114":-5,"_115":-5,"_116":113,"_117":118,"_119":120,"_121":122,"_123":124,"_125":-5,"_126":127,"_128":129,"_130":131,"_132":133,"_134":-5,"_135":136,"_137":-5,"_138":139,"_140":-5,"_141":142,"_143":144,"_145":146,"_147":-5,"_148":-5,"_149":-5,"_150":104,"_151":152,"_153":-5,"_154":-5,"_155":18,"_156":157,"_158":-5},"children",[],"parent","type","assistant","sibling_turn_ids","attempt_placement","role","output_items",[],"child_turns",[],"conversation_id","None","error",{"_278":279,"_280":281},"latest_event","worklog",{"_276":277},"app_server_events",{"_273":275},"thread_events",{"_273":274},"turn_status","failed","cancellation_requested_at","pull_request_status","not_created","pull_request_data","created_at",1778211369.549603,"internal_only_rollouts","environment_id","69fb6bd5ae788191b3711cf6039f8788","environment",{"_45":142,"_160":161,"_162":163,"_164":18,"_165":166,"_167":168,"_169":170,"_171":-5,"_172":173,"_174":18,"_175":176,"_177":166,"_178":166,"_179":180,"_181":182,"_183":184,"_185":-5,"_186":187,"_188":189,"_190":191,"_192":193,"_58":-5,"_138":194,"_195":196,"_197":198,"_199":200,"_201":18,"_202":18},"branch","add-unknown-datatype","base_commit_sha","branch_name","direct_push_pushed_commit_sha","previous_turn_id","logs",{"_151":159},"proxy_events","debug_metadata","discarded","model_version","gpt-5.5-codex-1p-codexswic-ev3","languages",[],"machine_id","wham-public/wham-universal","label","manuzhang/iceberg-rust","is_pinned","description","","workspace_dir","/workspace","agent_network_access",{"_266":267,"_268":-5,"_269":-5,"_270":-5,"_271":-5,"_272":-5},"codex_github_direct","github_connector_id","connector_76869538009648d5b282a4bb21c3d157","enable_gitlab_webhooks","repos",[224],"setup","maintenance_setup","repo_map",{"_224":225},"env_vars",{"_206":207,"_208":209,"_210":211,"_212":213,"_214":215,"_216":217,"_218":219,"_220":221,"_222":223},"secrets",{},"secrets_with_domains","task_count",12,"creator_id","user-z9wCykQT0XfWip3TwhwKo4o9","share_settings","workspace","share_targets",[],1778084822.29144,"auto_setup_settings",{"_205":62},"cache_settings",{"_203":62,"_204":166},"etag","\"7300a0ba-0000-0200-0000-69fd579e0000\"","enable_authtranslator","enable_docker_in_docker","post_setup_cache_enabled","cache_invalidation_key","use_auto_setup","CODEX_ENV_PYTHON_VERSION","3.12","CODEX_ENV_NODE_VERSION","20","CODEX_ENV_RUBY_VERSION","3.4.4","CODEX_ENV_RUST_VERSION","1.89.0","CODEX_ENV_GO_VERSION","1.24.3","CODEX_ENV_BUN_VERSION","1.2.14","CODEX_ENV_PHP_VERSION","8.4","CODEX_ENV_JAVA_VERSION","21","CODEX_ENV_SWIFT_VERSION","6.1","github-725189608",{"_45":226,"_227":228,"_229":230,"_231":163,"_232":233,"_234":235,"_236":237,"_238":239,"_240":241,"_242":67,"_243":18,"_244":18,"_245":62,"_246":62,"_247":62,"_248":18,"_249":-5,"_250":251,"_252":-5,"_58":253},"725189608","name","iceberg-rust","owner",{"_258":259,"_45":260,"_112":261,"_262":263,"_264":265},"repository_full_name","clone_url","https://github.com/manuzhang/iceberg-rust.git","default_branch","main","git_commits_url","https://api.github.com/repos/manuzhang/iceberg-rust/git/commits{/sha}","git_refs_url","https://api.github.com/repos/manuzhang/iceberg-rust/git/refs{/sha}","git_url","git://github.com/manuzhang/iceberg-rust.git","visibility","archived","allow_auto_merge","allow_merge_commit","allow_rebase_merge","allow_squash_merge","allow_update_branch","language","size",11552,"master_branch",{"_254":62,"_255":18,"_256":62,"_257":62},"admin","maintain","push","pull","login","manuzhang",1191767,"User","avatar_url","https://avatars.githubusercontent.com/u/1191767?v=4","url","https://api.github.com/users/manuzhang","mode","off","preset_allowlist","allowlist_domains","allowlist_rules","denylist_domains","safe_methods_only","events",[],[],"messages",[],"code","unknown_error","message","An unknown error occurred",{"_112":284,"_45":104,"_116":284,"_285":286,"_287":-5,"_288":289,"_150":102,"_138":290},[87],"user","input_items",[291],"external_post_config","user_model_slug","slug",1778211368.83842,{"_112":280,"_116":284,"_292":293},"content",[294],{"_295":49,"_49":296},"content_type","resolve conflicts",{"_112":113,"_45":102,"_114":-5,"_115":-5,"_116":113,"_117":299,"_119":300,"_121":122,"_123":-5,"_125":-5,"_126":301,"_128":302,"_130":303,"_132":304,"_134":-5,"_135":305,"_137":306,"_138":307,"_140":-5,"_141":142,"_143":308,"_145":146,"_147":309,"_148":310,"_149":-5,"_150":100,"_151":311,"_153":-5,"_154":-5,"_155":18,"_156":157,"_158":-5},[104],[377,378,379,380],[],{"_276":376},{"_273":375},{"_273":374},"completed","created",{"_344":345,"_264":346,"_347":348,"_349":18,"_350":18,"_351":18,"_352":353,"_354":355,"_356":146,"_357":310,"_358":359,"_360":361,"_362":-5,"_363":-5,"_364":-5,"_284":365,"_366":345,"_367":368,"_369":370,"_371":372},1778209130.535591,{"_45":142,"_160":161,"_162":163,"_164":18,"_165":166,"_167":168,"_169":331,"_171":-5,"_172":173,"_174":18,"_175":332,"_177":166,"_178":166,"_179":333,"_181":334,"_183":335,"_185":-5,"_186":336,"_188":189,"_190":191,"_192":337,"_58":-5,"_138":194,"_195":338,"_197":339,"_199":340,"_201":18,"_202":18},"65769afc0bf2e103c2f03285cad23507262e4684","codex/github-mention-featspec-add-unknown-datatype-support",{"_151":312},[313,314,315],{"_316":327,"_318":328},{"_316":323,"_318":324},{"_316":317,"_318":319},"key",{"_227":320,"_112":321,"_138":322},"value","file_00000000e96871f78c852db7304083f8","auto_setup","UserSetupScript","2026-05-08T02:14:21.913563",{"_227":325,"_112":321,"_138":326},"file_00000000b2c871f7a1ce3dd476efec82","warm_up_git_repo_1778209137","2026-05-08T02:58:57.059940",{"_227":329,"_112":321,"_138":330},"file_00000000795471f79d7b890ea7624a0c","setup_autodetect","2026-05-08T02:14:09.064867",{"_266":267,"_268":-5,"_269":-5,"_270":-5,"_271":-5,"_272":-5},[224],{"_224":341},{"_206":207,"_208":209,"_210":211,"_212":213,"_214":215,"_216":217,"_218":219,"_220":221,"_222":223},{},9,[],{"_205":62},{"_203":62,"_204":166},"\"7200926c-0000-0200-0000-69fd4b670000\"",{"_45":226,"_227":228,"_229":342,"_231":163,"_232":233,"_234":235,"_236":237,"_238":239,"_240":241,"_242":67,"_243":18,"_244":18,"_245":62,"_246":62,"_247":62,"_248":18,"_249":-5,"_250":251,"_252":-5,"_58":343},{"_258":259,"_45":260,"_112":261,"_262":263,"_264":265},{"_254":62,"_255":18,"_256":62,"_257":62},"number",3,"https://github.com/manuzhang/iceberg-rust/pull/3","state","open","merged","mergeable","draft","title","Validate unknown types against format version and improve field-default parsing errors","body","### Motivation\n\n- Ensure that `unknown` primitive types are only used with table format version v3 and improve error reporting when parsing field defaults from JSON.\n\n### Description\n\n- Added `parse_field_default` helper to convert optional `JsonValue` defaults into `Literal` with contextual error messages including the field name and whether it was `initial-default` or `write-default` used in `TryFrom`.\n- Added `Schema::contains_unknown_type` and a recursive `field_contains_unknown_type` helper to detect presence of `Type::Primitive(Unknown)` inside nested types (structs, lists, maps).\n- Enforced format-version restrictions by validating schemas during metadata normalization via `TableMetadata::validate_schema_format_versions` and when adding schemas via `TableMetadataBuilder::validate_schema_format_version`, rejecting schemas that contain `unknown` types on format versions < `V3`.\n- Updated and added unit tests to cover both `initial-default` and `write-default` parsing errors for `unknown` types and to assert that `unknown` types require format version `V3`; also added helper `schema_with_unknown_type()` for tests.\n\n### Testing\n\n- Ran unit tests for the crate including updated tests `test_unknown_type_deserialization_rejects_non_null_defaults` and `test_unknown_type_requires_format_version_v3`; all tests passed.\n\n------\n[Codex Task](https://chatgpt.com/codex/cloud/tasks/task_e_69fc383a26d08330884ce8c58eaec061)","base","head","base_sha","043dbd5bb484a94593f2b9e1a331da4ef41a3efd","head_sha","e6679ab83873d15c1cd817c18bf99bd211765e86","merge_commit_sha","comments","diff",{"_258":259,"_227":259,"_373":-5,"_262":263,"_45":260},"commits","changed_files",11,"additions",373,"deletions",34,"email",[],[],[],{"_112":4408,"_385":4409},{"_112":280,"_116":113,"_292":4375},{"_112":406,"_407":408},{"_112":381,"_382":353,"_383":384,"_385":386,"_387":-5},"pr","pr_title","pr_message","### Motivation\n\n- Ensure that `unknown` primitive types are only used with table format version v3 and improve error reporting when parsing field defaults from JSON.\n\n### Description\n\n- Added `parse_field_default` helper to convert optional `JsonValue` defaults into `Literal` with contextual error messages including the field name and whether it was `initial-default` or `write-default` used in `TryFrom`.\n- Added `Schema::contains_unknown_type` and a recursive `field_contains_unknown_type` helper to detect presence of `Type::Primitive(Unknown)` inside nested types (structs, lists, maps).\n- Enforced format-version restrictions by validating schemas during metadata normalization via `TableMetadata::validate_schema_format_versions` and when adding schemas via `TableMetadataBuilder::validate_schema_format_version`, rejecting schemas that contain `unknown` types on format versions < `V3`.\n- Updated and added unit tests to cover both `initial-default` and `write-default` parsing errors for `unknown` types and to assert that `unknown` types require format version `V3`; also added helper `schema_with_unknown_type()` for tests.\n\n### Testing\n\n- Ran unit tests for the crate including updated tests `test_unknown_type_deserialization_rejects_non_null_defaults` and `test_unknown_type_requires_format_version_v3`; all tests passed.","output_diff",{"_112":385,"_388":163,"_147":309,"_389":-5,"_364":390,"_391":392,"_393":394,"_395":396,"_397":398,"_399":400,"_401":402},"pre_apply_patch","repo_id","preapply_patch_base_commit_sha","diff --git a/crates/iceberg/src/spec/datatypes.rs b/crates/iceberg/src/spec/datatypes.rs\nindex 14595ee6d0c7d5ee7f03d03760b459dcb89fa5b5..963093f5955b1e97ee51579ceb8ed9c0460f25c2 100644\n--- a/crates/iceberg/src/spec/datatypes.rs\n+++ b/crates/iceberg/src/spec/datatypes.rs\n@@ -544,64 +544,89 @@ pub struct NestedField {\n pub field_type: Box,\n /// Fields may have an optional comment or doc string.\n pub doc: Option,\n /// Used to populate the field’s value for all records that were written before the field was added to the schema\n pub initial_default: Option,\n /// Used to populate the field’s value for any records written after the field was added to the schema, if the writer does not supply the field’s value\n pub write_default: Option,\n }\n \n #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]\n #[serde(rename_all = \"kebab-case\")]\n struct SerdeNestedField {\n pub id: i32,\n pub name: String,\n pub required: bool,\n #[serde(rename = \"type\")]\n pub field_type: Box,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub doc: Option,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub initial_default: Option,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub write_default: Option,\n }\n \n+fn parse_field_default(\n+ default: Option,\n+ field_type: &Type,\n+ field_name: &str,\n+ default_name: &'static str,\n+) -> Result> {\n+ default\n+ .map(|value| {\n+ Literal::try_from_json(value, field_type).map_err(|err| {\n+ crate::Error::new(\n+ err.kind(),\n+ format!(\n+ \"Invalid {default_name} for field {field_name}: {}\",\n+ err.message()\n+ ),\n+ )\n+ .with_source(err)\n+ })\n+ })\n+ .transpose()\n+ .map(Option::flatten)\n+}\n+\n impl TryFrom for NestedField {\n type Error = crate::Error;\n \n fn try_from(value: SerdeNestedField) -> Result {\n- let initial_default = value\n- .initial_default\n- .map(|x| Literal::try_from_json(x, &value.field_type))\n- .transpose()?\n- .flatten();\n- let write_default = value\n- .write_default\n- .map(|x| Literal::try_from_json(x, &value.field_type))\n- .transpose()?\n- .flatten();\n+ let initial_default = parse_field_default(\n+ value.initial_default,\n+ &value.field_type,\n+ &value.name,\n+ \"initial-default\",\n+ )?;\n+ let write_default = parse_field_default(\n+ value.write_default,\n+ &value.field_type,\n+ &value.name,\n+ \"write-default\",\n+ )?;\n \n Ok(NestedField {\n id: value.id,\n name: value.name,\n required: value.required,\n initial_default,\n write_default,\n field_type: value.field_type,\n doc: value.doc,\n })\n }\n }\n \n impl From for SerdeNestedField {\n fn from(value: NestedField) -> Self {\n let initial_default = value.initial_default.map(|x| x.try_into_json(&value.field_type).expect(\"We should have checked this in NestedField::with_initial_default, it can't be converted to json value\"));\n let write_default = value.write_default.map(|x| x.try_into_json(&value.field_type).expect(\"We should have checked this in NestedField::with_write_default, it can't be converted to json value\"));\n SerdeNestedField {\n id: value.id,\n name: value.name,\n required: value.required,\n field_type: value.field_type,\n doc: value.doc,\n initial_default,\n write_default,\ndiff --git a/crates/iceberg/src/spec/schema/mod.rs b/crates/iceberg/src/spec/schema/mod.rs\nindex 4d43e411552e83d011a379fa2e58a83245cb8399..6df22bd58593b195377709710434afe7925384c7 100644\n--- a/crates/iceberg/src/spec/schema/mod.rs\n+++ b/crates/iceberg/src/spec/schema/mod.rs\n@@ -390,95 +390,116 @@ impl Schema {\n /// Get field by alias.\n pub fn field_by_alias(&self, alias: &str) -> Option<&NestedFieldRef> {\n self.alias_to_id\n .get_by_left(alias)\n .and_then(|id| self.field_by_id(*id))\n }\n \n /// Returns [`highest_field_id`].\n #[inline]\n pub fn highest_field_id(&self) -> i32 {\n self.highest_field_id\n }\n \n /// Returns [`schema_id`].\n #[inline]\n pub fn schema_id(&self) -> SchemaId {\n self.schema_id\n }\n \n /// Returns [`r#struct`].\n #[inline]\n pub fn as_struct(&self) -> &StructType {\n &self.r#struct\n }\n \n+ /// Returns true when this schema contains an `unknown` type field.\n+ pub(crate) fn contains_unknown_type(&self) -> bool {\n+ self.as_struct()\n+ .fields()\n+ .iter()\n+ .any(field_contains_unknown_type)\n+ }\n+\n /// Returns [`identifier_field_ids`].\n #[inline]\n pub fn identifier_field_ids(&self) -> impl ExactSizeIterator + '_ {\n self.identifier_field_ids.iter().copied()\n }\n \n /// Get field id by full name.\n pub fn field_id_by_name(&self, name: &str) -> Option {\n self.name_to_id.get(name).copied()\n }\n \n /// Get full name by field id.\n pub fn name_by_field_id(&self, field_id: i32) -> Option<&str> {\n self.id_to_name.get(&field_id).map(String::as_str)\n }\n \n /// Get an accessor for retrieving data in a struct\n pub fn accessor_by_field_id(&self, field_id: i32) -> Option> {\n self.field_id_to_accessor.get(&field_id).cloned()\n }\n \n /// Check if this schema is identical to another schema semantically - excluding schema id.\n pub(crate) fn is_same_schema(&self, other: &SchemaRef) -> bool {\n self.as_struct().eq(other.as_struct())\n && self.identifier_field_ids().eq(other.identifier_field_ids())\n }\n \n /// Change the schema id of this schema.\n // This is redundant with the `with_schema_id` method on the builder, but useful\n // as it is infallible in contrast to the builder `build()` method.\n pub(crate) fn with_schema_id(self, schema_id: SchemaId) -> Self {\n Self { schema_id, ..self }\n }\n \n /// Return A HashMap matching field ids to field names.\n pub fn field_id_to_name_map(&self) -> &HashMap {\n &self.id_to_name\n }\n \n /// Return a hashmap matching field ids to nested fields.\n pub fn field_id_to_fields(&self) -> &HashMap {\n &self.id_to_field\n }\n }\n \n+fn field_contains_unknown_type(field: &NestedFieldRef) -> bool {\n+ match field.field_type.as_ref() {\n+ Type::Primitive(PrimitiveType::Unknown) => true,\n+ Type::Struct(struct_type) => struct_type.fields().iter().any(field_contains_unknown_type),\n+ Type::List(list_type) => field_contains_unknown_type(&list_type.element_field),\n+ Type::Map(map_type) => {\n+ field_contains_unknown_type(&map_type.key_field)\n+ || field_contains_unknown_type(&map_type.value_field)\n+ }\n+ Type::Primitive(_) => false,\n+ }\n+}\n+\n impl Display for Schema {\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n writeln!(f, \"table {{\")?;\n for field in self.as_struct().fields() {\n writeln!(f, \" {field}\")?;\n }\n writeln!(f, \"}}\")\n }\n }\n \n #[cfg(test)]\n mod tests {\n use std::collections::HashMap;\n \n use bimap::BiHashMap;\n \n use crate::spec::datatypes::Type::{List, Map, Primitive, Struct};\n use crate::spec::datatypes::{\n ListType, MapType, NestedField, NestedFieldRef, PrimitiveType, StructType, Type,\n };\n use crate::spec::schema::Schema;\n use crate::spec::values::Map as MapValue;\n use crate::spec::{Datum, Literal};\n \n #[test]\n@@ -1244,72 +1265,90 @@ table {\n assert!(\n Schema::builder()\n .with_schema_id(1)\n .with_identifier_field_ids(vec![1])\n .with_fields(vec![\n NestedField::required(1, \"Required\", Type::Primitive(PrimitiveType::String),)\n .into()\n ])\n .build()\n .is_ok()\n );\n assert!(\n Schema::builder()\n .with_schema_id(1)\n .with_identifier_field_ids(vec![1])\n .with_fields(vec![\n NestedField::optional(1, \"Optional\", Type::Primitive(PrimitiveType::String),)\n .into()\n ])\n .build()\n .is_err()\n );\n }\n \n #[test]\n- fn test_unknown_type_deserialization_rejects_non_null_default() {\n- let schema_json = serde_json::json!({\n- \"type\": \"struct\",\n- \"schema-id\": 1,\n- \"fields\": [\n- {\n- \"id\": 1,\n- \"name\": \"empty\",\n- \"required\": false,\n- \"type\": \"unknown\",\n- \"initial-default\": 1\n- }\n- ]\n- });\n+ fn test_unknown_type_deserialization_rejects_non_null_defaults() {\n+ for default_name in [\"initial-default\", \"write-default\"] {\n+ let field_json = serde_json::json!({\n+ \"id\": 1,\n+ \"name\": \"empty\",\n+ \"required\": false,\n+ \"type\": \"unknown\",\n+ default_name: 1\n+ });\n+\n+ let field_error = serde_json::from_value::(field_json).unwrap_err();\n+ assert!(\n+ field_error\n+ .to_string()\n+ .contains(&format!(\"Invalid {default_name} for field empty\")),\n+ \"unexpected error for {default_name}: {field_error}\"\n+ );\n \n- let error = serde_json::from_value::(schema_json).unwrap_err();\n- assert!(\n- error\n- .to_string()\n- .contains(\"did not match any variant of untagged enum SchemaEnum\"),\n- \"unexpected error: {error}\"\n- );\n+ let schema_json = serde_json::json!({\n+ \"type\": \"struct\",\n+ \"schema-id\": 1,\n+ \"fields\": [\n+ {\n+ \"id\": 1,\n+ \"name\": \"empty\",\n+ \"required\": false,\n+ \"type\": \"unknown\",\n+ default_name: 1\n+ }\n+ ]\n+ });\n+\n+ let schema_error = serde_json::from_value::(schema_json).unwrap_err();\n+ assert!(\n+ schema_error\n+ .to_string()\n+ .contains(\"did not match any variant of untagged enum SchemaEnum\"),\n+ \"unexpected error for {default_name}: {schema_error}\"\n+ );\n+ }\n }\n \n #[test]\n fn test_unknown_type_deserialization_accepts_null_defaults() {\n let schema_json = serde_json::json!({\n \"type\": \"struct\",\n \"schema-id\": 1,\n \"fields\": [\n {\n \"id\": 1,\n \"name\": \"empty\",\n \"required\": false,\n \"type\": \"unknown\",\n \"initial-default\": null,\n \"write-default\": null\n }\n ]\n });\n \n serde_json::from_value::(schema_json).unwrap();\n }\n \n #[test]\n fn test_unknown_type_must_be_optional_with_null_defaults() {\n assert!(\ndiff --git a/crates/iceberg/src/spec/table_metadata.rs b/crates/iceberg/src/spec/table_metadata.rs\nindex 607fd98350dfd4e932be1fed185652bc7ddcc188..b1029c1f9c7408922df9ef4dc488f23f9eb17639 100644\n--- a/crates/iceberg/src/spec/table_metadata.rs\n+++ b/crates/iceberg/src/spec/table_metadata.rs\n@@ -505,63 +505,82 @@ impl TableMetadata {\n CompressionCodec::Gzip(_) => codec.compress(json_data)?,\n CompressionCodec::None => json_data,\n _ => {\n return Err(Error::new(\n ErrorKind::DataInvalid,\n format!(\"Unsupported metadata compression codec: {codec:?}\"),\n ));\n }\n };\n \n file_io\n .new_output(metadata_location.to_string())?\n .write(data_to_write.into())\n .await\n }\n \n /// Normalize this partition spec.\n ///\n /// This is an internal method\n /// meant to be called after constructing table metadata from untrusted sources.\n /// We run this method after json deserialization.\n /// All constructors for `TableMetadata` which are part of `iceberg-rust`\n /// should return normalized `TableMetadata`.\n pub(super) fn try_normalize(&mut self) -> Result<&mut Self> {\n self.validate_current_schema()?;\n+ self.validate_schema_format_versions()?;\n self.normalize_current_snapshot()?;\n self.construct_refs();\n self.validate_refs()?;\n self.validate_chronological_snapshot_logs()?;\n self.validate_chronological_metadata_logs()?;\n // Normalize location (remove trailing slash)\n self.location = self.location.trim_end_matches('/').to_string();\n self.validate_snapshot_sequence_number()?;\n self.try_normalize_partition_spec()?;\n self.try_normalize_sort_order()?;\n Ok(self)\n }\n \n+ fn validate_schema_format_versions(&self) -> Result<()> {\n+ if self.format_version < FormatVersion::V3\n+ && let Some(schema_id) = self\n+ .schemas\n+ .iter()\n+ .find_map(|(schema_id, schema)| schema.contains_unknown_type().then_some(schema_id))\n+ {\n+ return Err(Error::new(\n+ ErrorKind::DataInvalid,\n+ format!(\n+ \"Schema {schema_id} contains unknown type, which is only supported in table format version v3\"\n+ ),\n+ ));\n+ }\n+\n+ Ok(())\n+ }\n+\n /// If the default partition spec is not present in specs, add it\n fn try_normalize_partition_spec(&mut self) -> Result<()> {\n if self\n .partition_spec_by_id(self.default_spec.spec_id())\n .is_none()\n {\n self.partition_specs.insert(\n self.default_spec.spec_id(),\n Arc::new(Arc::unwrap_or_clone(self.default_spec.clone())),\n );\n }\n \n Ok(())\n }\n \n /// If the default sort order is unsorted but the sort order is not present, add it\n fn try_normalize_sort_order(&mut self) -> Result<()> {\n // Validate that sort order ID 0 (reserved for unsorted) has no fields\n if let Some(sort_order) = self.sort_order_by_id(SortOrder::UNSORTED_ORDER_ID)\n && !sort_order.fields.is_empty()\n {\n return Err(Error::new(\n ErrorKind::Unexpected,\n format!(\n \"Sort order ID {} is reserved for unsorted order\",\ndiff --git a/crates/iceberg/src/spec/table_metadata_builder.rs b/crates/iceberg/src/spec/table_metadata_builder.rs\nindex 65dbae1bfcd3a7743cc14d1c1fbd67e616e5a006..a7825ef50d4ab0508f2894e051db4d7d950dff56 100644\n--- a/crates/iceberg/src/spec/table_metadata_builder.rs\n+++ b/crates/iceberg/src/spec/table_metadata_builder.rs\n@@ -618,50 +618,51 @@ impl TableMetadataBuilder {\n self.changes.push(TableUpdate::SetPartitionStatistics {\n partition_statistics: partition_statistics_file,\n });\n self\n }\n \n /// Remove partition statistics\n pub fn remove_partition_statistics(mut self, snapshot_id: i64) -> Self {\n let previous = self.metadata.partition_statistics.remove(&snapshot_id);\n if previous.is_some() {\n self.changes\n .push(TableUpdate::RemovePartitionStatistics { snapshot_id });\n }\n self\n }\n \n /// Add a schema to the table metadata.\n ///\n /// The provided `schema.schema_id` may not be used.\n ///\n /// Important: Use this method with caution. The builder does not check\n /// if the added schema is compatible with the current schema.\n pub fn add_schema(mut self, schema: Schema) -> Result {\n // Validate that new schema fields don't conflict with existing partition field names\n self.validate_schema_field_names(&schema)?;\n+ self.validate_schema_format_version(&schema)?;\n \n let new_schema_id = self.reuse_or_create_new_schema_id(&schema);\n let schema_found = self.metadata.schemas.contains_key(&new_schema_id);\n \n if schema_found {\n if self.last_added_schema_id != Some(new_schema_id) {\n self.changes.push(TableUpdate::AddSchema {\n schema: schema.clone(),\n });\n self.last_added_schema_id = Some(new_schema_id);\n }\n \n return Ok(self);\n }\n \n // New schemas might contain only old columns. In this case last_column_id should not be\n // reduced.\n self.metadata.last_column_id =\n std::cmp::max(self.metadata.last_column_id, schema.highest_field_id());\n \n // Set schema-id\n let schema = match new_schema_id == schema.schema_id() {\n true => schema,\n false => schema.with_schema_id(new_schema_id),\n };\n@@ -740,50 +741,64 @@ impl TableMetadataBuilder {\n /// # Errors\n /// - Schema field name conflicts with partition field name but doesn't exist in any historical schema.\n fn validate_schema_field_names(&self, schema: &Schema) -> Result<()> {\n if self.metadata.schemas.is_empty() {\n return Ok(());\n }\n \n for field_name in schema.field_id_to_name_map().values() {\n let has_partition_conflict = self.metadata.partition_name_exists(field_name);\n let is_new_field = !self.metadata.name_exists_in_any_schema(field_name);\n \n if has_partition_conflict && is_new_field {\n return Err(Error::new(\n ErrorKind::DataInvalid,\n format!(\n \"Cannot add schema field '{field_name}' because it conflicts with existing partition field name. \\\n Schema evolution cannot introduce field names that match existing partition field names.\"\n ),\n ));\n }\n }\n \n Ok(())\n }\n \n+ fn validate_schema_format_version(&self, schema: &Schema) -> Result<()> {\n+ if self.metadata.format_version < FormatVersion::V3 && schema.contains_unknown_type() {\n+ return Err(Error::new(\n+ ErrorKind::DataInvalid,\n+ format!(\n+ \"Cannot add schema with unknown type to table format version {}: unknown type is only supported in v3\",\n+ self.metadata.format_version\n+ ),\n+ ));\n+ }\n+\n+ Ok(())\n+ }\n+\n /// Validate partition field names against schema field names across all historical schemas.\n ///\n /// Due to Iceberg's multi-version property, partition fields can share names with schema fields\n /// if they meet specific requirements (identity transform + matching source field ID).\n /// This validation enforces those rules across all historical schema versions.\n ///\n /// # Errors\n /// - Partition field name conflicts with schema field name but doesn't use identity transform.\n /// - Partition field uses identity transform but references wrong source field ID.\n fn validate_partition_field_names(&self, unbound_spec: &UnboundPartitionSpec) -> Result<()> {\n if self.metadata.schemas.is_empty() {\n return Ok(());\n }\n \n let current_schema = self.get_current_schema()?;\n for partition_field in unbound_spec.fields() {\n let exists_in_any_schema = self\n .metadata\n .name_exists_in_any_schema(&partition_field.name);\n \n // Skip if partition field name doesn't conflict with any schema field\n if !exists_in_any_schema {\n continue;\n }\n \n@@ -1466,90 +1481,133 @@ mod tests {\n \n use super::*;\n use crate::TableIdent;\n use crate::io::FileIO;\n use crate::spec::{\n BlobMetadata, NestedField, NullOrder, Operation, PartitionSpec, PrimitiveType, Schema,\n SnapshotRetention, SortDirection, SortField, StructType, Summary, TableProperties,\n Transform, Type, UnboundPartitionField,\n };\n use crate::table::Table;\n \n const TEST_LOCATION: &str = \"s3://bucket/test/location\";\n const LAST_ASSIGNED_COLUMN_ID: i32 = 3;\n \n fn schema() -> Schema {\n Schema::builder()\n .with_fields(vec![\n NestedField::required(1, \"x\", Type::Primitive(PrimitiveType::Long)).into(),\n NestedField::required(2, \"y\", Type::Primitive(PrimitiveType::Long)).into(),\n NestedField::required(3, \"z\", Type::Primitive(PrimitiveType::Long)).into(),\n ])\n .build()\n .unwrap()\n }\n \n+ fn schema_with_unknown_type() -> Schema {\n+ Schema::builder()\n+ .with_fields(vec![\n+ NestedField::required(1, \"x\", Type::Primitive(PrimitiveType::Long)).into(),\n+ NestedField::optional(2, \"unknown\", Type::Primitive(PrimitiveType::Unknown)).into(),\n+ ])\n+ .build()\n+ .unwrap()\n+ }\n+\n fn sort_order() -> SortOrder {\n let schema = schema();\n SortOrder::builder()\n .with_order_id(1)\n .with_sort_field(SortField {\n source_id: 3,\n transform: Transform::Bucket(4),\n direction: SortDirection::Descending,\n null_order: NullOrder::First,\n })\n .build(&schema)\n .unwrap()\n }\n \n fn partition_spec() -> UnboundPartitionSpec {\n UnboundPartitionSpec::builder()\n .with_spec_id(0)\n .add_partition_field(2, \"y\", Transform::Identity)\n .unwrap()\n .build()\n }\n \n fn builder_without_changes(format_version: FormatVersion) -> TableMetadataBuilder {\n TableMetadataBuilder::new(\n schema(),\n partition_spec(),\n sort_order(),\n TEST_LOCATION.to_string(),\n format_version,\n HashMap::new(),\n )\n .unwrap()\n .build()\n .unwrap()\n .metadata\n .into_builder(Some(\n \"s3://bucket/test/location/metadata/metadata1.json\".to_string(),\n ))\n }\n \n+ #[test]\n+ fn test_unknown_type_requires_format_version_v3() {\n+ let v2_error = TableMetadataBuilder::new(\n+ schema_with_unknown_type(),\n+ UnboundPartitionSpec::builder().build(),\n+ SortOrder::unsorted_order(),\n+ TEST_LOCATION.to_string(),\n+ FormatVersion::V2,\n+ HashMap::new(),\n+ )\n+ .unwrap_err();\n+ assert!(\n+ v2_error\n+ .message()\n+ .contains(\"unknown type is only supported in v3\"),\n+ \"unexpected error: {v2_error}\"\n+ );\n+\n+ let v3_metadata = TableMetadataBuilder::new(\n+ schema_with_unknown_type(),\n+ UnboundPartitionSpec::builder().build(),\n+ SortOrder::unsorted_order(),\n+ TEST_LOCATION.to_string(),\n+ FormatVersion::V3,\n+ HashMap::new(),\n+ )\n+ .unwrap()\n+ .build()\n+ .unwrap()\n+ .metadata;\n+ assert_eq!(v3_metadata.format_version(), FormatVersion::V3);\n+ }\n+\n #[test]\n fn test_minimal_build() {\n let metadata = TableMetadataBuilder::new(\n schema(),\n partition_spec(),\n sort_order(),\n TEST_LOCATION.to_string(),\n FormatVersion::V1,\n HashMap::new(),\n )\n .unwrap()\n .build()\n .unwrap()\n .metadata;\n \n assert_eq!(metadata.format_version, FormatVersion::V1);\n assert_eq!(metadata.location, TEST_LOCATION);\n assert_eq!(metadata.current_schema_id, 0);\n assert_eq!(metadata.default_spec.spec_id(), 0);\n assert_eq!(metadata.default_sort_order_id, 1);\n assert_eq!(metadata.last_partition_id, 1000);\n assert_eq!(metadata.last_column_id, 3);\n assert_eq!(metadata.snapshots.len(), 0);\n assert_eq!(metadata.current_snapshot_id, None);\n assert_eq!(metadata.refs.len(), 0);\n","external_storage_diff",{"_403":404,"_405":-5},"files_modified",4,"lines_added",172,"lines_removed",31,"commit_message","fix(spec): require v3 for unknown type schemas","additional_parent_commit_shas",[],"file_id","file_000000003fd871f7b8771e4b2edf53b0","ttl","partial_repo_snapshot","files",[409,410,411],{"_412":3697,"_414":-5,"_415":3698,"_417":-5},{"_412":2039,"_414":-5,"_415":2040,"_417":-5},{"_412":413,"_414":-5,"_415":416,"_417":-5},"path","crates/iceberg/src/spec/table_metadata_builder.rs","contents","line_range_contents",[418],"missing_reason",{"_419":420,"_421":422,"_292":423,"_424":62},"line_range_start",1,"line_range_end",3668,[425,426,427,428,429,430,431,432,433,432,434,435,436,437,438,439,166,440,441,166,442,166,443,444,445,446,447,448,449,450,451,452,166,453,166,454,455,456,457,458,459,460,455,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,166,476,477,478,479,480,481,482,483,484,475,166,485,486,487,166,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,166,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,166,545,546,547,548,549,550,551,166,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,541,542,538,570,551,166,571,572,573,574,575,576,577,578,579,580,581,166,582,583,584,585,586,587,588,589,590,591,166,592,576,577,593,575,580,579,594,551,166,595,596,597,598,599,570,166,600,551,166,601,489,602,603,604,605,606,584,607,608,609,610,611,570,166,612,613,614,615,616,617,618,619,620,616,621,618,622,623,619,620,616,624,570,166,625,551,166,626,489,627,628,629,489,602,630,631,632,633,634,635,636,637,166,638,606,584,607,639,640,610,611,570,166,641,642,570,166,643,644,645,591,166,625,551,166,646,647,489,602,648,649,650,651,166,652,633,653,635,636,637,166,638,606,584,607,654,640,610,611,570,166,655,656,570,166,657,658,659,660,570,166,625,551,166,661,662,663,664,665,666,660,667,570,166,600,551,166,668,489,602,669,670,671,672,673,674,675,676,677,678,679,606,584,680,611,570,166,681,682,683,679,606,584,607,684,685,686,610,611,570,166,687,688,689,690,691,692,693,694,695,696,697,698,624,570,166,699,700,701,702,703,606,584,607,704,705,706,610,611,570,166,707,708,709,710,711,712,713,714,715,716,717,616,166,718,719,691,692,693,720,697,698,624,570,166,721,722,723,724,725,726,727,712,728,729,730,570,166,731,732,733,591,166,734,735,736,677,737,166,625,551,166,738,739,489,602,740,741,742,166,743,744,691,692,745,698,624,166,746,747,748,749,750,751,752,753,754,755,624,544,166,756,551,166,757,758,759,760,761,166,762,763,764,765,719,766,624,591,166,767,768,769,660,570,166,770,736,771,772,166,600,551,166,773,489,602,774,775,675,676,771,776,777,679,642,570,166,778,606,584,607,779,780,610,611,544,166,781,782,783,591,784,785,570,166,786,787,788,789,790,719,791,792,790,793,166,794,750,795,660,570,166,796,797,798,591,799,166,625,551,166,800,489,801,802,787,803,570,166,804,805,806,660,570,166,600,551,166,807,808,736,809,810,811,812,591,600,551,166,813,814,815,816,817,818,570,600,551,166,819,820,821,822,561,823,824,825,826,827,828,591,600,551,166,829,830,831,816,817,832,570,600,551,166,833,489,834,489,835,836,837,838,839,840,166,841,842,166,843,844,845,846,847,848,624,166,642,570,166,849,850,851,852,166,853,854,855,856,544,166,736,857,858,166,859,166,860,166,625,551,166,861,489,862,489,863,864,865,866,867,868,869,692,870,871,872,544,873,166,874,642,570,166,875,583,584,876,586,587,166,877,878,879,880,166,881,166,882,883,884,660,748,817,885,570,166,625,551,166,886,887,888,889,551,166,890,489,891,892,893,489,602,894,895,896,897,570,166,898,899,900,166,901,691,692,693,902,903,697,698,624,570,166,904,551,166,905,906,606,584,607,907,908,610,611,570,166,904,551,166,909,489,910,911,912,489,602,913,914,915,896,897,570,166,916,917,918,723,919,166,920,921,922,624,166,923,924,925,926,927,166,928,711,712,713,929,930,716,717,616,166,931,711,712,713,932,933,934,716,717,616,624,570,166,904,551,166,935,489,936,937,489,938,489,602,939,940,941,942,166,943,944,166,945,946,166,947,948,949,166,950,951,952,953,166,954,955,956,957,958,624,166,642,570,166,959,606,584,960,611,570,166,961,962,963,736,964,965,966,967,166,968,969,970,166,625,551,166,971,489,972,973,974,975,976,977,978,979,676,964,980,981,982,983,166,984,985,986,987,988,989,990,991,992,993,616,994,995,983,166,996,997,998,999,551,166,1000,489,602,1001,1002,1003,1004,1005,869,692,1006,871,872,570,166,1007,642,570,166,1008,606,584,1009,611,570,166,1010,676,964,1011,1012,869,692,693,1013,697,871,1014,1015,1016,1017,1018,1019,166,1020,1021,1022,660,748,1023,570,166,625,551,166,1024,1025,1026,1027,551,166,1028,1029,1030,489,602,1031,1032,1033,606,584,1034,611,570,166,1035,1036,1037,1038,624,591,166,1039,1040,1041,660,570,166,625,551,166,1042,489,1043,937,489,1044,489,602,1045,1046,1047,1048,1049,166,1050,1051,1052,1053,847,1054,624,166,642,570,166,1055,1056,1057,1058,1059,1060,869,692,1061,871,1062,872,166,1063,736,1064,1065,1066,166,625,551,166,1067,489,602,1068,1069,1070,1071,1072,869,692,1073,871,872,570,166,1074,642,570,166,1075,606,584,607,1076,610,611,570,166,1077,166,1078,1079,1080,660,748,817,1081,570,166,625,551,166,1082,1083,1084,1085,551,166,1086,1087,1088,1089,1090,1091,570,166,1092,1093,1094,591,600,551,166,1095,1096,1097,1098,1099,660,570,600,551,166,1100,1101,1102,700,1103,166,1104,1105,1106,942,1107,166,1108,1109,1110,1111,826,1112,1113,1114,1058,1115,166,1116,1117,166,1118,1119,570,1120,166,1121,1122,1123,1124,999,551,166,1125,1126,676,1127,1128,1129,1130,1131,166,1132,1133,1134,1135,1136,748,1137,570,551,166,1138,1139,1140,1141,653,1142,166,1143,897,570,166,1144,1145,1146,1147,1148,1149,616,1150,1151,1152,1153,1154,1155,1156,624,570,166,1157,1158,1159,691,692,1160,698,624,544,166,1161,904,551,166,1162,489,1163,1164,1165,1166,1167,1168,1169,1170,1171,1141,653,1172,1173,1174,995,1175,166,966,653,1172,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,616,1174,995,1192,551,166,1193,493,1194,495,1195,1196,1197,1198,1199,1200,1201,949,166,1202,1203,1204,1205,869,692,693,1206,1207,697,871,872,1208,1209,570,1210,166,1211,1212,1213,1205,869,692,693,1214,1215,697,871,872,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,570,1228,166,1229,551,166,1230,736,857,653,1231,1232,551,166,1233,1234,676,857,634,1235,1236,551,166,1237,736,857,1238,1012,869,692,693,1239,1240,697,871,995,551,166,1241,736,1064,1242,1243,1012,869,692,693,1244,1245,697,871,995,551,166,1246,1247,736,964,653,1248,1249,1250,1251,1252,995,551,166,1253,1254,551,166,1255,1256,1257,1258,570,166,736,1064,653,1259,1260,995,1249,1261,1262,1263,995,551,166,1264,1265,551,166,1266,1267,1268,1269,606,584,1270,611,570,166,1271,642,570,166,1272,1273,1274,1275,765,719,766,624,591,166,1276,1277,591,166,625,551,475,166,1278,1279,1280,551,475,166,1281,1282,1283,1284,1285,166,1286,1287,1288,1289,1290,1291,1292,1293,1294,166,1295,1296,166,1297,1298,1299,1300,1301,1302,1303,1304,1305,551,166,1306,1298,1299,1300,1307,1303,1304,1305,551,166,1308,1309,1114,1310,1311,1312,1313,1314,1315,995,1059,1305,551,166,1316,1317,1318,1319,1305,1304,551,166,1320,1321,1322,1323,1324,1325,580,1326,594,1327,1328,1327,1329,1330,1331,1332,551,166,1333,1334,1335,1336,1337,1338,1325,1339,1326,594,1340,1341,1342,1343,1344,1345,826,166,1346,1336,1337,1338,1325,1347,1326,594,1327,1328,1327,1348,1349,551,166,1333,1350,1351,1322,1323,1324,1325,1352,1326,594,1327,1328,1327,1348,166,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,166,1367,1368,166,1369,1370,1371,1372,1373,1374,1305,1304,1305,1375,166,1376,1368,551,166,1333,1377,1378,1351,1379,1380,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1376,1354,1355,1356,1381,1382,1383,1360,1361,1362,1363,1364,1365,551,166,1333,1384,1385,1386,1299,1387,1388,1389,1390,1391,1392,1393,1394,1395,871,1396,1397,1303,1304,1398,1399,1400,1401,1305,1402,1305,1304,1398,1056,1403,1404,1405,1406,1315,1407,1408,1059,1398,166,501,1409,166,1410,1299,1411,1412,1389,1413,1391,1392,1414,1394,1395,871,1396,1415,1303,1304,1398,166,1416,1318,1401,1305,1402,1305,1304,1398,166,1417,1403,1418,1405,1406,1315,1407,1310,1419,1398,166,1420,1421,1422,551,166,1333,1423,1424,166,1351,576,1323,1324,1325,1352,1326,594,1327,1328,1327,1348,166,1355,1425,551,166,1333,1426,1427,1322,1323,1324,1325,1352,1428,594,1327,1328,1327,1429,166,1430,1431,1432,537,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1446,1448,537,1449,1450,1451,537,1452,1453,1454,1455,1456,1457,624,1458,551,166,1333,1459,1378,1427,1379,1460,1338,1325,1352,1326,594,1327,1328,1327,1429,166,1430,1431,1432,537,1461,1462,537,1434,1435,1436,1437,1463,1439,1447,1446,1448,537,1449,1450,1464,537,1452,1458,551,166,1333,1465,1466,166,1467,1468,1469,1470,1471,1472,1473,1474,1475,755,1470,1476,1477,1473,1478,1479,755,1303,1305,1480,166,1481,1482,1305,1304,1398,166,1483,1484,1485,1486,1487,1488,1405,1489,1490,995,1305,1487,1491,1405,1312,1492,995,1305,1304,1398,166,1493,1494,1495,1496,826,1497,1498,1499,1500,591,166,1501,1502,676,1371,1372,1373,1503,1305,1304,1398,166,1493,1504,1505,551,166,1333,1506,1466,1507,1467,1468,1508,1305,1480,166,1481,1482,1305,1509,1305,1304,1398,166,1510,1486,1487,1511,1512,1418,1492,995,1305,1304,1398,166,1513,1514,1515,1435,1516,1517,537,1518,1458,551,166,1333,1519,1466,1520,1521,1481,1522,1305,1509,1305,1304,1398,166,1513,1523,1524,591,1525,1526,591,1494,1527,1528,1529,1530,1446,586,826,166,1531,1502,676,1371,1372,1373,1532,1305,1304,1398,166,1493,1533,1534,591,1494,1527,1528,1535,1530,1446,586,826,551,166,1333,1536,1466,166,1537,1408,1403,1418,1405,1406,1315,1407,1538,1398,166,1481,1539,1305,1304,1398,166,1540,166,1493,1541,1542,1543,1544,826,1545,1546,591,551,166,1333,1547,1466,166,1548,1549,1299,1300,1301,1302,1550,1303,1304,1398,166,1481,1551,1305,1304,1398,166,1513,1552,1542,1553,1554,826,1555,1556,591,1557,1558,591,551,166,1333,1559,1466,166,1548,1549,1299,1300,1301,1302,1550,1303,1304,1398,166,1481,1560,1305,1561,1305,1304,1398,166,1513,1557,1558,591,551,166,1333,1562,1563,1322,1323,1324,1325,1339,1326,594,1327,1328,1564,166,1565,551,166,1333,1566,1567,1568,1304,1305,1375,1569,166,1570,1571,1572,1573,1574,1575,1305,1304,1398,166,1576,551,166,1333,1577,1578,1579,1322,1323,1324,1325,1339,1326,594,1327,1328,1327,1329,1580,166,1581,1582,1398,166,1583,166,1576,1494,1584,1585,826,551,166,1333,1586,1466,166,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,697,1599,1600,1601,1602,995,1480,166,1603,166,1341,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,826,166,1481,1617,1618,751,1619,753,754,755,995,1305,1304,1398,1620,1494,1621,1622,826,1623,1624,1625,1626,551,166,1333,1627,1466,166,1628,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,697,1599,1600,1601,1602,995,1480,166,1629,1630,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,697,1599,1600,1601,1602,995,1480,166,1631,1632,1305,1617,1618,751,1619,753,754,755,995,1305,1633,1305,1304,1398,166,1634,1635,1636,1637,1638,551,166,1333,1639,1466,166,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,697,1599,1600,1601,1602,995,1480,166,1631,1640,1305,1617,1618,751,1619,753,754,755,995,1305,1304,1398,166,1641,1642,1643,1644,166,1645,1646,676,1371,1647,1373,1648,1304,1398,166,1649,1650,1651,1652,1653,1494,1654,1655,1656,624,826,551,166,1333,1657,1466,166,1587,1630,1589,1590,1591,1592,1593,1594,1658,995,1480,166,1481,1659,1305,1304,1398,166,1660,1635,1661,1662,1663,1664,537,544,166,1665,1494,1666,1667,826,1515,1668,1669,1670,1671,624,1458,551,166,1333,1672,1466,166,1587,1630,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,697,1599,1600,1601,1602,995,1480,166,1603,1673,551,166,1333,1674,1466,166,1548,1549,1675,1304,1398,166,1676,1677,1305,1304,1678,166,1341,1679,1680,826,551,166,1333,1681,1682,166,1467,1468,1469,1470,1472,1473,1474,1475,755,1470,1477,1473,1478,1683,755,1303,1305,1480,166,1684,1685,1686,1687,551,166,1333,1688,1466,1689,1572,1690,1691,1575,1305,1304,1398,1692,1693,166,1370,676,1694,1572,1695,1696,1575,1305,1304,1398,166,1697,1693,166,1370,676,1694,1572,1695,1691,1575,1305,1304,1398,1697,1698,551,166,1333,1699,1466,166,1587,1588,1589,1700,1591,1701,1593,1594,1658,995,1480,166,1581,1640,1305,1617,1618,751,1619,753,754,755,995,1398,166,1587,1630,1589,1590,1591,1702,1703,1593,1594,1658,995,1480,166,1676,1704,1678,1341,1679,1705,826,551,166,1333,1706,1466,166,1707,551,166,1333,1708,1466,166,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,525,1720,544,1721,166,1494,1722,1723,826,1724,1725,1637,166,1726,1727,1481,1728,1304,1398,166,1729,1730,1731,1637,166,1732,1727,1481,1728,1304,1398,1729,1733,551,166,1333,1734,1466,166,1735,1710,1736,1737,544,166,1481,1738,1304,1398,1494,1739,1723,826,1515,1740,1741,624,1458,166,1726,1727,1481,1742,1304,1398,1743,1515,1744,1745,624,1458,166,1732,1727,1481,1742,1304,1398,1743,1733,551,166,1333,1746,1466,166,1747,1748,1749,166,1570,1371,1372,1373,1572,1573,1574,1575,1305,1304,1398,166,1341,1750,1751,1752,1753,826,551,166,1333,1754,1755,1756,1757,1758,1759,1332,1564,1760,1761,166,1762,1763,1764,1765,1766,1304,1398,166,1494,1767,1768,826,551,166,1333,1769,1466,1770,551,166,1333,1771,1756,1757,1758,1759,1332,1564,1760,1761,166,1762,1763,1764,1765,1766,1304,1398,166,1772,166,679,1773,1774,1775,570,166,1776,1777,1778,1779,1780,1781,1782,166,1783,1784,1785,719,1786,793,1787,551,166,1333,1788,1789,1299,1790,1303,1304,1398,166,1791,1318,1792,1305,1480,166,1351,1793,1794,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1795,1796,1797,653,1798,983,1799,166,1800,1299,1790,1801,1802,1303,1304,1398,166,1803,1331,1687,166,1804,1805,166,1806,1807,1808,1809,1810,551,166,1333,1811,1789,1299,1790,1303,1304,1398,166,1812,1318,1813,1305,1480,166,1351,1793,577,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1814,1299,1790,1815,1303,1304,1398,166,1816,1817,1818,1819,1820,1305,1480,166,1821,551,166,1333,1822,1789,1299,1790,1823,1824,1303,1304,1398,166,1812,1318,1825,1305,1480,166,1351,1793,577,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1803,1331,1687,166,1826,1486,1827,1305,1480,166,1828,166,1806,1807,1808,1829,1830,1831,1687,1832,551,166,1333,1833,1834,1789,1299,1790,1823,1824,1303,1304,1398,166,1812,1318,1792,1305,1480,166,1351,1793,577,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1835,1836,1299,1790,1837,1824,1303,1304,1398,166,1370,1819,1838,1305,1304,1305,1375,166,1839,1840,1841,1842,1299,1790,1837,1824,1843,1824,1303,1304,1398,166,1844,1818,1845,166,1846,1847,1821,166,1848,1849,1850,1299,1790,1837,1824,1843,1824,1851,1852,1303,1304,1398,166,1853,1854,166,1855,1856,1857,1858,1859,551,166,1333,1860,1861,1789,1299,1790,1862,1824,1303,1304,1398,166,1812,1318,1863,1305,1480,166,1351,1793,577,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1864,1800,1299,1790,1862,1824,1837,1824,1303,1304,1398,166,1865,1817,1819,1866,166,1821,551,166,1333,1867,1868,1789,1299,1790,1303,1304,1398,166,1812,1318,1792,1305,1480,166,1351,1793,577,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1869,1850,1299,1790,1870,1802,1303,1304,1398,166,1871,1872,166,1855,1856,1806,1807,1859,551,166,1333,1873,1789,1299,1790,1823,1824,1303,1304,1398,166,1812,1318,1825,1305,1480,166,1351,1793,577,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1803,1331,1687,166,1874,1875,1486,1876,1305,1480,166,1877,166,1821,551,166,1333,1878,1879,1880,1304,1305,1375,1881,1882,1883,1590,1591,1884,1885,1593,1594,1658,995,1886,1480,166,1887,1571,1888,1305,1304,1305,1375,166,1889,166,1890,1588,1891,1700,1591,1884,1892,1593,1594,1658,995,1893,1480,166,1894,1571,1895,1305,1304,1305,1375,1896,551,166,1333,1897,1879,1880,1304,1305,1375,166,1898,1881,1882,1883,1590,1591,1884,1885,1593,1594,1658,995,1886,1480,166,1899,1571,1900,1305,1304,1305,1375,166,1901,1588,1902,1700,1591,1884,1892,1593,1594,1658,995,1903,1904,1480,166,1905,1571,1906,1678,1341,1907,1908,586,826,551,166,1333,1909,1910,1911,166,1912,166,1913,1880,1304,1305,1375,166,1914,1915,166,1916,1917,1588,1883,1590,1591,1884,1885,1593,1594,1658,995,1918,1480,166,1919,1571,1920,1305,1304,1305,1375,166,1921,1922,166,1923,1924,1925,677,1926,1398,1927,166,1928,1929,166,1930,1931,1630,1932,1700,1591,1933,1885,1593,1594,1658,995,1934,1480,166,1935,1571,1936,1305,1617,1937,751,752,753,754,755,995,1305,1304,1305,1375,166,1938,1939,1940,166,1941,1942,166,1943,1944,1945,1946,1947,1591,1948,1949,1593,1594,1658,995,1950,1480,166,1951,1571,1952,1305,1304,1305,1375,166,1953,1954,1955,677,1956,1398,1957,166,1958,1959,551,166,1333,1960,1466,166,1961,1962,1963,1964,1965,1966,1967,1968,1575,1480,166,1969,1970,1971,1972,1973,1480,166,1974,1481,1975,1304,1398,166,1493,1976,1494,1977,1978,826,1979,1980,591,166,1981,1502,676,1371,1372,1373,1982,1304,1398,166,1493,1983,1494,1977,1978,826,1494,1984,1985,826,1979,1986,591,166,1987,1502,676,1371,1647,1373,1975,1304,1398,166,1733,1983,166,1988,1502,676,1371,1989,1373,1990,1304,1398,166,1493,1976,1991,1494,1984,1985,826,1992,1993,591,166,1994,1502,676,1371,1995,1373,1996,1304,1398,166,1733,1976,166,1997,1998,676,1999,637,2000,2001,166,2002,1502,676,1371,2003,1373,2004,1304,1398,166,1493,2005,2006,1992,2007,591,166,2008,2009,2010,551,166,1333,2011,1385,1299,2012,2013,2014,1824,1303,1304,1398,166,2015,2016,2017,1305,1480,166,2018,576,2019,1338,2020,1339,1326,594,1327,1328,1327,1348,166,2021,2022,2023,1305,1480,2024,2025,2026,166,2027,2028,2029,2030,1305,2031,1305,2032,1305,1480,2033,2034,166,2035,2036,2037,2038,551,475],"contains_end_of_file","// Licensed to the Apache Software Foundation (ASF) under one","// or more contributor license agreements. See the NOTICE file","// distributed with this work for additional information","// regarding copyright ownership. The ASF licenses this file","// to you under the Apache License, Version 2.0 (the","// \"License\"); you may not use this file except in compliance","// with the License. You may obtain a copy of the License at","//","// http://www.apache.org/licenses/LICENSE-2.0","// Unless required by applicable law or agreed to in writing,","// software distributed under the License is distributed on an","// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY","// KIND, either express or implied. See the License for the","// specific language governing permissions and limitations","// under the License.","use std::collections::{HashMap, HashSet};","use std::sync::Arc;","use uuid::Uuid;","use super::{"," DEFAULT_PARTITION_SPEC_ID, DEFAULT_SCHEMA_ID, FormatVersion, MAIN_BRANCH, MetadataLog,"," ONE_MINUTE_MS, PartitionSpec, PartitionSpecBuilder, PartitionStatisticsFile, Schema, SchemaRef,"," Snapshot, SnapshotLog, SnapshotReference, SnapshotRetention, SortOrder, SortOrderRef,"," StatisticsFile, StructType, TableMetadata, TableProperties, UNPARTITIONED_LAST_ASSIGNED_ID,"," UnboundPartitionSpec,","};","use crate::error::{Error, ErrorKind, Result};","use crate::spec::{EncryptedKey, INITIAL_ROW_ID, MIN_FORMAT_VERSION_ROW_LINEAGE};","use crate::{TableCreation, TableUpdate};","pub(crate) const FIRST_FIELD_ID: i32 = 1;","/// Manipulating table metadata.","///","/// For this builder the order of called functions matters. Functions are applied in-order.","/// All operations applied to the `TableMetadata` are tracked in `changes` as a chronologically","/// ordered vec of `TableUpdate`.","/// If an operation does not lead to a change of the `TableMetadata`, the corresponding update","/// is omitted from `changes`.","/// Unlike a typical builder pattern, the order of function calls matters.","/// Some basic rules:","/// - `add_schema` must be called before `set_current_schema`.","/// - If a new partition spec and schema are added, the schema should be added first.","#[derive(Debug, Clone)]","pub struct TableMetadataBuilder {"," metadata: TableMetadata,"," changes: Vec,"," last_added_schema_id: Option,"," last_added_spec_id: Option,"," last_added_order_id: Option,"," // None if this is a new table (from_metadata) method not used"," previous_history_entry: Option,"," last_updated_ms: Option,","}","#[derive(Debug, Clone, PartialEq)]","/// Result of modifying or creating a `TableMetadata`.","pub struct TableMetadataBuildResult {"," /// The new `TableMetadata`."," pub metadata: TableMetadata,"," /// The changes that were applied to the metadata."," pub changes: Vec,"," /// Expired metadata logs"," pub expired_metadata_logs: Vec,","impl TableMetadataBuilder {"," /// Proxy id for \"last added\" items, including schema, partition spec, sort order."," pub const LAST_ADDED: i32 = -1;"," /// Create a `TableMetadata` object from scratch."," ///"," /// This method re-assign ids of fields in the schema, schema.id, sort_order.id and"," /// spec.id. It should only be used to create new table metadata from scratch."," pub fn new("," schema: Schema,"," spec: impl Into,"," sort_order: SortOrder,"," location: String,"," format_version: FormatVersion,"," properties: HashMap,"," ) -> Result {"," // Re-assign field_ids, schema.id, sort_order.id and spec.id for a new table."," let (fresh_schema, fresh_spec, fresh_sort_order) ="," Self::reassign_ids(schema, spec.into(), sort_order)?;"," let schema_id = fresh_schema.schema_id();"," let builder = Self {"," metadata: TableMetadata {"," format_version,"," table_uuid: Uuid::now_v7(),"," location: \"\".to_string(), // Overwritten immediately by set_location"," last_sequence_number: 0,"," last_updated_ms: 0, // Overwritten by build() if not set before"," last_column_id: -1, // Overwritten immediately by add_current_schema"," current_schema_id: -1, // Overwritten immediately by add_current_schema"," schemas: HashMap::new(),"," partition_specs: HashMap::new(),"," default_spec: Arc::new("," // The spec id (-1) is just a proxy value and can be any negative number."," // 0 would lead to wrong changes in the builder if the provided spec by the user is"," // also unpartitioned."," // The `default_spec` value is always replaced at the end of this method by he `add_default_partition_spec`"," // method."," PartitionSpec::unpartition_spec().with_spec_id(-1),"," ), // Overwritten immediately by add_default_partition_spec"," default_partition_type: StructType::new(vec![]),"," last_partition_id: UNPARTITIONED_LAST_ASSIGNED_ID,"," properties: HashMap::new(),"," current_snapshot_id: None,"," snapshots: HashMap::new(),"," snapshot_log: vec![],"," sort_orders: HashMap::new(),"," metadata_log: vec![],"," default_sort_order_id: -1, // Overwritten immediately by add_default_sort_order"," refs: HashMap::default(),"," statistics: HashMap::new(),"," partition_statistics: HashMap::new(),"," encryption_keys: HashMap::new(),"," next_row_id: INITIAL_ROW_ID,"," },"," last_updated_ms: None,"," changes: vec![],"," last_added_schema_id: Some(schema_id),"," last_added_spec_id: None,"," last_added_order_id: None,"," previous_history_entry: None,"," };"," builder"," .set_location(location)"," .add_current_schema(fresh_schema)?"," .add_default_partition_spec(fresh_spec.into_unbound())?"," .add_default_sort_order(fresh_sort_order)?"," .set_properties(properties)"," }"," /// Creates a new table metadata builder from the given metadata to modify it."," /// `current_file_location` is the location where the current version"," /// of the metadata file is stored. This is used to update the metadata log."," /// If `current_file_location` is `None`, the metadata log will not be updated."," /// This should only be used to stage-create tables."," #[must_use]"," pub fn new_from_metadata("," previous: TableMetadata,"," current_file_location: Option,"," ) -> Self {"," Self {"," previous_history_entry: current_file_location.map(|l| MetadataLog {"," metadata_file: l,"," timestamp_ms: previous.last_updated_ms,"," }),"," metadata: previous,"," changes: Vec::default(),"," last_added_schema_id: None,"," }"," /// Creates a new table metadata builder from the given table creation."," pub fn from_table_creation(table_creation: TableCreation) -> Result {"," let TableCreation {"," name: _,"," location,"," schema,"," partition_spec,"," sort_order,"," properties,"," format_version,"," } = table_creation;"," let location = location.ok_or_else(|| {"," Error::new("," ErrorKind::DataInvalid,"," \"Can't create table without location\","," )"," })?;"," let partition_spec = partition_spec.unwrap_or(UnboundPartitionSpec {"," spec_id: None,"," fields: vec![],"," });"," Self::new("," sort_order.unwrap_or(SortOrder::unsorted_order()),"," )"," /// Changes uuid of table metadata."," pub fn assign_uuid(mut self, uuid: Uuid) -> Self {"," if self.metadata.table_uuid != uuid {"," self.metadata.table_uuid = uuid;"," self.changes.push(TableUpdate::AssignUuid { uuid });"," self"," /// Upgrade `FormatVersion`. Downgrades are not allowed."," /// # Errors"," /// - Cannot downgrade to older format versions."," pub fn upgrade_format_version(mut self, format_version: FormatVersion) -> Result {"," if format_version < self.metadata.format_version {"," return Err(Error::new("," format!("," \"Cannot downgrade FormatVersion from {} to {}\","," self.metadata.format_version, format_version"," ),"," ));"," if format_version != self.metadata.format_version {"," match format_version {"," FormatVersion::V1 => {"," // No changes needed for V1"," }"," FormatVersion::V2 => {"," self.metadata.format_version = format_version;"," self.changes"," .push(TableUpdate::UpgradeFormatVersion { format_version });"," FormatVersion::V3 => {"," // Set next-row-id to 0 when upgrading to v3 as per Iceberg spec"," self.metadata.next_row_id = INITIAL_ROW_ID;"," }"," Ok(self)"," /// Set properties. If a property already exists, it will be overwritten."," /// If a reserved property is set, the corresponding action is performed and the property is not persisted."," /// Currently the following reserved properties are supported:"," /// * format-version: Set the format version of the table."," /// - If properties contains a reserved property"," pub fn set_properties(mut self, properties: HashMap) -> Result {"," // List of specified properties that are RESERVED and should not be persisted."," let reserved_properties = properties"," .keys()"," .filter(|key| TableProperties::RESERVED_PROPERTIES.contains(&key.as_str()))"," .map(ToString::to_string)"," .collect::>();"," if !reserved_properties.is_empty() {"," \"Table properties should not contain reserved properties, but got: [{}]\","," reserved_properties.join(\", \")"," if properties.is_empty() {"," return Ok(self);"," self.metadata.properties.extend(properties.clone());"," self.changes.push(TableUpdate::SetProperties {"," updates: properties,"," /// Remove properties from the table metadata."," /// Does nothing if the key is not present."," /// - If properties to remove contains a reserved property"," pub fn remove_properties(mut self, properties: &[String]) -> Result {"," // remove duplicates"," let properties = properties.iter().cloned().collect::>();"," // disallow removal of reserved properties"," .iter()"," \"Table properties to remove contain reserved properties: [{}]\","," for property in &properties {"," self.metadata.properties.remove(property);"," if !properties.is_empty() {"," self.changes.push(TableUpdate::RemoveProperties {"," removals: properties.into_iter().collect(),"," });"," /// Set the location of the table, stripping any trailing slashes."," pub fn set_location(mut self, location: String) -> Self {"," let location = location.trim_end_matches('/').to_string();"," if self.metadata.location != location {"," self.changes.push(TableUpdate::SetLocation {"," location: location.clone(),"," self.metadata.location = location;"," /// Add a snapshot to the table metadata."," /// - Snapshot id already exists."," /// - For format version > 1: the sequence number of the snapshot is lower than the highest sequence number specified so far."," /// - For format version >= 3: the first-row-id of the snapshot is lower than the next-row-id of the table."," /// - For format version >= 3: added-rows is null or first-row-id is null."," /// - For format version >= 3: next-row-id would overflow when adding added-rows."," pub fn add_snapshot(mut self, snapshot: Snapshot) -> Result {"," if self"," .metadata"," .snapshots"," .contains_key(&snapshot.snapshot_id())"," {"," format!(\"Snapshot already exists for: '{}'\", snapshot.snapshot_id()),"," if self.metadata.format_version != FormatVersion::V1"," && snapshot.sequence_number() <= self.metadata.last_sequence_number"," && snapshot.parent_snapshot_id().is_some()"," \"Cannot add snapshot with sequence number {} older than last sequence number {}\","," snapshot.sequence_number(),"," self.metadata.last_sequence_number"," if let Some(last) = self.metadata.snapshot_log.last() {"," // commits can happen concurrently from different machines."," // A tolerance helps us avoid failure for small clock skew"," if snapshot.timestamp_ms() - last.timestamp_ms < -ONE_MINUTE_MS {"," return Err(Error::new("," ErrorKind::DataInvalid,"," format!("," \"Invalid snapshot timestamp {}: before last snapshot timestamp {}\","," snapshot.timestamp_ms(),"," last.timestamp_ms"," ),"," ));"," let max_last_updated = self"," .last_updated_ms"," .unwrap_or_default()"," .max(self.metadata.last_updated_ms);"," if snapshot.timestamp_ms() - max_last_updated < -ONE_MINUTE_MS {"," \"Invalid snapshot timestamp {}: before last updated timestamp {}\","," snapshot.timestamp_ms(),"," max_last_updated"," let mut added_rows = None;"," if self.metadata.format_version >= MIN_FORMAT_VERSION_ROW_LINEAGE {"," if let Some((first_row_id, added_rows_count)) = snapshot.row_range() {"," if first_row_id < self.metadata.next_row_id {"," return Err(Error::new("," ErrorKind::DataInvalid,"," format!("," \"Cannot add a snapshot, first-row-id is behind table next-row-id: {first_row_id} < {}\","," self.metadata.next_row_id"," ),"," ));"," added_rows = Some(added_rows_count);"," } else {"," \"Cannot add a snapshot: first-row-id is null. first-row-id must be set for format version >= {MIN_FORMAT_VERSION_ROW_LINEAGE}\","," if let Some(added_rows) = added_rows {"," self.metadata.next_row_id = self"," .metadata"," .next_row_id"," .checked_add(added_rows)"," .ok_or_else(|| {"," Error::new("," \"Cannot add snapshot: next-row-id overflowed when adding added-rows\","," )"," })?;"," // Mutation happens in next line - must be infallible from here"," self.changes.push(TableUpdate::AddSnapshot {"," snapshot: snapshot.clone(),"," self.last_updated_ms = Some(snapshot.timestamp_ms());"," self.metadata.last_sequence_number = snapshot.sequence_number();"," self.metadata"," .insert(snapshot.snapshot_id(), snapshot.into());"," /// Append a snapshot to the specified branch."," /// Retention settings from the `branch` are re-used."," /// - Any of the preconditions of `self.add_snapshot` are not met."," pub fn set_branch_snapshot(self, snapshot: Snapshot, branch: &str) -> Result {"," let reference = self.metadata.refs.get(branch).cloned();"," let reference = if let Some(mut reference) = reference {"," if !reference.is_branch() {"," format!(\"Cannot append snapshot to non-branch reference '{branch}'\",),"," reference.snapshot_id = snapshot.snapshot_id();"," reference"," } else {"," SnapshotReference {"," snapshot_id: snapshot.snapshot_id(),"," retention: SnapshotRetention::Branch {"," min_snapshots_to_keep: None,"," max_snapshot_age_ms: None,"," max_ref_age_ms: None,"," },"," self.add_snapshot(snapshot)?.set_ref(branch, reference)"," /// Remove snapshots by its ids from the table metadata."," /// Does nothing if a snapshot id is not present."," /// Keeps as changes only the snapshots that were actually removed."," pub fn remove_snapshots(mut self, snapshot_ids: &[i64]) -> Self {"," let mut removed_snapshots = Vec::with_capacity(snapshot_ids.len());"," self.metadata.snapshots.retain(|k, _| {"," if snapshot_ids.contains(k) {"," removed_snapshots.push(*k);"," false"," true"," if !removed_snapshots.is_empty() {"," self.changes.push(TableUpdate::RemoveSnapshots {"," snapshot_ids: removed_snapshots,"," // Remove refs that are no longer valid"," .refs"," .retain(|_, v| self.metadata.snapshots.contains_key(&v.snapshot_id));"," /// Set a reference to a snapshot."," /// - The snapshot id is unknown."," pub fn set_ref(mut self, ref_name: &str, reference: SnapshotReference) -> Result {"," .get(ref_name)"," .is_some_and(|snap_ref| snap_ref.eq(&reference))"," let Some(snapshot) = self.metadata.snapshots.get(&reference.snapshot_id) else {"," \"Cannot set '{ref_name}' to unknown snapshot: '{}'\","," reference.snapshot_id"," // Update last_updated_ms to the exact timestamp of the snapshot if it was added in this commit"," let is_added_snapshot = self.changes.iter().any(|update| {"," matches!(update, TableUpdate::AddSnapshot { snapshot: snap } if snap.snapshot_id() == snapshot.snapshot_id())"," if is_added_snapshot {"," self.last_updated_ms = Some(snapshot.timestamp_ms());"," // Current snapshot id is set only for the main branch"," if ref_name == MAIN_BRANCH {"," self.metadata.current_snapshot_id = Some(snapshot.snapshot_id());"," let timestamp_ms = if let Some(last_updated_ms) = self.last_updated_ms {"," last_updated_ms"," let last_updated_ms = chrono::Utc::now().timestamp_millis();"," self.last_updated_ms = Some(last_updated_ms);"," };"," self.metadata.snapshot_log.push(SnapshotLog {"," timestamp_ms,"," self.changes.push(TableUpdate::SetSnapshotRef {"," ref_name: ref_name.to_string(),"," reference: reference.clone(),"," self.metadata.refs.insert(ref_name.to_string(), reference);"," /// Remove a reference"," /// If `ref_name='main'` the current snapshot id is set to `None`."," pub fn remove_ref(mut self, ref_name: &str) -> Self {"," self.metadata.current_snapshot_id = None;"," if self.metadata.refs.remove(ref_name).is_some() || ref_name == MAIN_BRANCH {"," self.changes.push(TableUpdate::RemoveSnapshotRef {"," ref_name: ref_name.to_string(),"," /// Set statistics for a snapshot"," pub fn set_statistics(mut self, statistics: StatisticsFile) -> Self {"," .statistics"," .insert(statistics.snapshot_id, statistics.clone());"," self.changes.push(TableUpdate::SetStatistics {"," statistics: statistics.clone(),"," /// Remove statistics for a snapshot"," pub fn remove_statistics(mut self, snapshot_id: i64) -> Self {"," let previous = self.metadata.statistics.remove(&snapshot_id);"," if previous.is_some() {"," self.changes"," .push(TableUpdate::RemoveStatistics { snapshot_id });"," /// Set partition statistics"," pub fn set_partition_statistics("," mut self,"," partition_statistics_file: PartitionStatisticsFile,"," self.metadata.partition_statistics.insert("," partition_statistics_file.snapshot_id,"," partition_statistics_file.clone(),"," );"," self.changes.push(TableUpdate::SetPartitionStatistics {"," partition_statistics: partition_statistics_file,"," /// Remove partition statistics"," pub fn remove_partition_statistics(mut self, snapshot_id: i64) -> Self {"," let previous = self.metadata.partition_statistics.remove(&snapshot_id);"," .push(TableUpdate::RemovePartitionStatistics { snapshot_id });"," /// Add a schema to the table metadata."," /// The provided `schema.schema_id` may not be used."," /// Important: Use this method with caution. The builder does not check"," /// if the added schema is compatible with the current schema."," pub fn add_schema(mut self, schema: Schema) -> Result {"," // Validate that new schema fields don't conflict with existing partition field names"," self.validate_schema_field_names(&schema)?;"," self.validate_schema_format_version(&schema)?;"," let new_schema_id = self.reuse_or_create_new_schema_id(&schema);"," let schema_found = self.metadata.schemas.contains_key(&new_schema_id);"," if schema_found {"," if self.last_added_schema_id != Some(new_schema_id) {"," self.changes.push(TableUpdate::AddSchema {"," schema: schema.clone(),"," });"," self.last_added_schema_id = Some(new_schema_id);"," // New schemas might contain only old columns. In this case last_column_id should not be"," // reduced."," self.metadata.last_column_id ="," std::cmp::max(self.metadata.last_column_id, schema.highest_field_id());"," // Set schema-id"," let schema = match new_schema_id == schema.schema_id() {"," true => schema,"," false => schema.with_schema_id(new_schema_id),"," .schemas"," .insert(new_schema_id, schema.clone().into());"," self.changes.push(TableUpdate::AddSchema { schema });"," self.last_added_schema_id = Some(new_schema_id);"," /// Set the current schema id."," /// If `schema_id` is -1, the last added schema is set as the current schema."," /// Errors:"," /// - provided `schema_id` is -1 but no schema has been added via `add_schema`."," /// - No schema with the provided `schema_id` exists."," pub fn set_current_schema(mut self, mut schema_id: i32) -> Result {"," if schema_id == Self::LAST_ADDED {"," schema_id = self.last_added_schema_id.ok_or_else(|| {"," Error::new("," \"Cannot set current schema to last added schema: no schema has been added.\","," )"," })?;"," let schema_id = schema_id; // Make immutable"," if schema_id == self.metadata.current_schema_id {"," let _schema = self.metadata.schemas.get(&schema_id).ok_or_else(|| {"," format!(\"Cannot set current schema to unknown schema with id: '{schema_id}'\"),"," // Old partition specs and sort-orders should be preserved even if they are not compatible with the new schema,"," // so that older metadata can still be interpreted."," // Default partition spec and sort order are checked in the build() method"," // which allows other default partition specs and sort orders to be set before the build."," self.metadata.current_schema_id = schema_id;"," if self.last_added_schema_id == Some(schema_id) {"," self.changes.push(TableUpdate::SetCurrentSchema {"," schema_id: Self::LAST_ADDED,"," .push(TableUpdate::SetCurrentSchema { schema_id });"," /// Add a schema and set it as the current schema."," pub fn add_current_schema(self, schema: Schema) -> Result {"," self.add_schema(schema)?"," .set_current_schema(Self::LAST_ADDED)"," /// Validate schema field names against partition field names across all historical schemas."," /// Due to Iceberg's multi-version property, this check ignores existing schema fields"," /// that match partition names (schema evolution allows re-adding previously removed fields)."," /// Only NEW field names that conflict with partition names are rejected."," /// - Schema field name conflicts with partition field name but doesn't exist in any historical schema."," fn validate_schema_field_names(&self, schema: &Schema) -> Result<()> {"," if self.metadata.schemas.is_empty() {"," return Ok(());"," for field_name in schema.field_id_to_name_map().values() {"," let has_partition_conflict = self.metadata.partition_name_exists(field_name);"," let is_new_field = !self.metadata.name_exists_in_any_schema(field_name);"," if has_partition_conflict && is_new_field {"," \"Cannot add schema field '{field_name}' because it conflicts with existing partition field name. \\"," Schema evolution cannot introduce field names that match existing partition field names.\""," Ok(())"," fn validate_schema_format_version(&self, schema: &Schema) -> Result<()> {"," if self.metadata.format_version < FormatVersion::V3 && schema.contains_unknown_type() {"," \"Cannot add schema with unknown type to table format version {}: unknown type is only supported in v3\","," self.metadata.format_version"," /// Validate partition field names against schema field names across all historical schemas."," /// Due to Iceberg's multi-version property, partition fields can share names with schema fields"," /// if they meet specific requirements (identity transform + matching source field ID)."," /// This validation enforces those rules across all historical schema versions."," /// - Partition field name conflicts with schema field name but doesn't use identity transform."," /// - Partition field uses identity transform but references wrong source field ID."," fn validate_partition_field_names(&self, unbound_spec: &UnboundPartitionSpec) -> Result<()> {"," let current_schema = self.get_current_schema()?;"," for partition_field in unbound_spec.fields() {"," let exists_in_any_schema = self"," .name_exists_in_any_schema(&partition_field.name);"," // Skip if partition field name doesn't conflict with any schema field"," if !exists_in_any_schema {"," continue;"," // If name exists in schemas, validate against current schema rules"," if let Some(schema_field) = current_schema.field_by_name(&partition_field.name) {"," let is_identity_transform ="," partition_field.transform == crate::spec::Transform::Identity;"," let has_matching_source_id = schema_field.id == partition_field.source_id;"," if !is_identity_transform {"," \"Cannot create partition with name '{}' that conflicts with schema field and is not an identity transform.\","," partition_field.name"," if !has_matching_source_id {"," \"Cannot create identity partition sourced from different field in schema. \\"," Field name '{}' has id `{}` in schema but partition source id is `{}`\","," partition_field.name, schema_field.id, partition_field.source_id"," /// Add a partition spec to the table metadata."," /// The spec is bound eagerly to the current schema."," /// If a schema is added in the same set of changes, the schema should be added first."," /// Even if `unbound_spec.spec_id` is provided as `Some`, it may not be used."," /// - The partition spec cannot be bound to the current schema."," /// - The partition spec has non-sequential field ids and the table format version is 1."," pub fn add_partition_spec(mut self, unbound_spec: UnboundPartitionSpec) -> Result {"," let schema = self.get_current_schema()?.clone();"," // Check if partition field names conflict with schema field names across all schemas"," self.validate_partition_field_names(&unbound_spec)?;"," // Reuse field IDs for equivalent fields from existing partition specs"," let unbound_spec = self.reuse_partition_field_ids(unbound_spec)?;"," let spec = PartitionSpecBuilder::new_from_unbound(unbound_spec.clone(), schema)?"," .with_last_assigned_field_id(self.metadata.last_partition_id)"," .build()?;"," let new_spec_id = self.reuse_or_create_new_spec_id(&spec);"," let spec_found = self.metadata.partition_specs.contains_key(&new_spec_id);"," let spec = spec.with_spec_id(new_spec_id);"," let unbound_spec = unbound_spec.with_spec_id(new_spec_id);"," if spec_found {"," if self.last_added_spec_id != Some(new_spec_id) {"," self.changes"," .push(TableUpdate::AddSpec { spec: unbound_spec });"," self.last_added_spec_id = Some(new_spec_id);"," if self.metadata.format_version <= FormatVersion::V1 && !spec.has_sequential_ids() {"," \"Cannot add partition spec with non-sequential field ids to format version 1 table\","," let highest_field_id = spec"," .highest_field_id()"," .unwrap_or(UNPARTITIONED_LAST_ASSIGNED_ID);"," .partition_specs"," .insert(new_spec_id, Arc::new(spec));"," self.changes"," .push(TableUpdate::AddSpec { spec: unbound_spec });"," self.last_added_spec_id = Some(new_spec_id);"," self.metadata.last_partition_id ="," std::cmp::max(self.metadata.last_partition_id, highest_field_id);"," /// Reuse partition field IDs for equivalent fields from existing partition specs."," /// According to the Iceberg spec, partition field IDs must be reused if an existing"," /// partition spec contains an equivalent field (same source_id and transform)."," fn reuse_partition_field_ids("," &self,"," unbound_spec: UnboundPartitionSpec,"," ) -> Result {"," // Build a map of (source_id, transform) -> field_id from existing specs"," let equivalent_field_ids: HashMap<_, _> = self"," .values()"," .flat_map(|spec| spec.fields())"," .map(|field| ((field.source_id, &field.transform), field.field_id))"," .collect();"," // Create new fields with reused field IDs where possible"," let fields = unbound_spec"," .fields"," .into_iter()"," .map(|mut field| {"," if field.field_id.is_none()"," && let Some(&existing_field_id) ="," equivalent_field_ids.get(&(field.source_id, &field.transform))"," {"," field.field_id = Some(existing_field_id);"," field"," })"," Ok(UnboundPartitionSpec {"," spec_id: unbound_spec.spec_id,"," fields,"," })"," /// Set the default partition spec."," /// - spec_id is -1 but no spec has been added via `add_partition_spec`."," /// - No partition spec with the provided `spec_id` exists."," pub fn set_default_partition_spec(mut self, mut spec_id: i32) -> Result {"," if spec_id == Self::LAST_ADDED {"," spec_id = self.last_added_spec_id.ok_or_else(|| {"," \"Cannot set default partition spec to last added spec: no spec has been added.\","," if self.metadata.default_spec.spec_id() == spec_id {"," if !self.metadata.partition_specs.contains_key(&spec_id) {"," format!(\"Cannot set default partition spec to unknown spec with id: '{spec_id}'\",),"," let schemaless_spec = self"," .get(&spec_id)"," .ok_or_else(|| {"," \"Cannot set default partition spec to unknown spec with id: '{spec_id}'\","," })?"," .clone();"," let spec = Arc::unwrap_or_clone(schemaless_spec);"," let spec_type = spec.partition_type(self.get_current_schema()?)?;"," self.metadata.default_spec = Arc::new(spec);"," self.metadata.default_partition_type = spec_type;"," if self.last_added_spec_id == Some(spec_id) {"," self.changes.push(TableUpdate::SetDefaultSpec {"," spec_id: Self::LAST_ADDED,"," self.changes.push(TableUpdate::SetDefaultSpec { spec_id });"," /// Add a partition spec and set it as the default"," pub fn add_default_partition_spec(self, unbound_spec: UnboundPartitionSpec) -> Result {"," self.add_partition_spec(unbound_spec)?"," .set_default_partition_spec(Self::LAST_ADDED)"," /// Remove partition specs by their ids from the table metadata."," /// Does nothing if a spec id is not present. Active partition specs"," /// should not be removed."," /// - Cannot remove the default partition spec."," pub fn remove_partition_specs(mut self, spec_ids: &[i32]) -> Result {"," if spec_ids.contains(&self.metadata.default_spec.spec_id()) {"," \"Cannot remove default partition spec\","," let mut removed_specs = Vec::with_capacity(spec_ids.len());"," spec_ids.iter().for_each(|id| {"," if self.metadata.partition_specs.remove(id).is_some() {"," removed_specs.push(*id);"," if !removed_specs.is_empty() {"," self.changes.push(TableUpdate::RemovePartitionSpecs {"," spec_ids: removed_specs,"," /// Add a sort order to the table metadata."," /// The spec is bound eagerly to the current schema and must be valid for it."," /// Even if `sort_order.order_id` is provided, it may not be used."," /// - Sort order id to add already exists."," /// - Sort order is incompatible with the current schema."," pub fn add_sort_order(mut self, sort_order: SortOrder) -> Result {"," let new_order_id = self.reuse_or_create_new_sort_id(&sort_order);"," let sort_order_found = self.metadata.sort_orders.contains_key(&new_order_id);"," if sort_order_found {"," if self.last_added_order_id != Some(new_order_id) {"," self.changes.push(TableUpdate::AddSortOrder {"," sort_order: sort_order.clone().with_order_id(new_order_id),"," self.last_added_order_id = Some(new_order_id);"," let schema = self.get_current_schema()?.clone().as_ref().clone();"," let sort_order = SortOrder::builder()"," .with_order_id(new_order_id)"," .with_fields(sort_order.fields)"," .build(&schema)"," .map_err(|e| {"," format!(\"Sort order to add is incompatible with current schema: {e}\"),"," .with_source(e)"," self.last_added_order_id = Some(new_order_id);"," .sort_orders"," .insert(new_order_id, sort_order.clone().into());"," self.changes.push(TableUpdate::AddSortOrder { sort_order });"," /// Set the default sort order. If `sort_order_id` is -1, the last added sort order is set as default."," /// - sort_order_id is -1 but no sort order has been added via `add_sort_order`."," /// - No sort order with the provided `sort_order_id` exists."," pub fn set_default_sort_order(mut self, mut sort_order_id: i64) -> Result {"," if sort_order_id == Self::LAST_ADDED as i64 {"," sort_order_id = self.last_added_order_id.ok_or_else(|| {"," \"Cannot set default sort order to last added order: no order has been added.\","," if self.metadata.default_sort_order_id == sort_order_id {"," if !self.metadata.sort_orders.contains_key(&sort_order_id) {"," \"Cannot set default sort order to unknown order with id: '{sort_order_id}'\""," self.metadata.default_sort_order_id = sort_order_id;"," if self.last_added_order_id == Some(sort_order_id) {"," self.changes.push(TableUpdate::SetDefaultSortOrder {"," sort_order_id: Self::LAST_ADDED as i64,"," .push(TableUpdate::SetDefaultSortOrder { sort_order_id });"," /// Add a sort order and set it as the default"," fn add_default_sort_order(self, sort_order: SortOrder) -> Result {"," self.add_sort_order(sort_order)?"," .set_default_sort_order(Self::LAST_ADDED as i64)"," /// Add an encryption key to the table metadata."," pub fn add_encryption_key(mut self, key: EncryptedKey) -> Self {"," let key_id = key.key_id().to_string();"," if self.metadata.encryption_keys.contains_key(&key_id) {"," // already exists"," return self;"," self.metadata.encryption_keys.insert(key_id, key.clone());"," self.changes.push(TableUpdate::AddEncryptionKey {"," encryption_key: key,"," /// Remove an encryption key from the table metadata."," pub fn remove_encryption_key(mut self, key_id: &str) -> Self {"," if self.metadata.encryption_keys.remove(key_id).is_some() {"," self.changes.push(TableUpdate::RemoveEncryptionKey {"," key_id: key_id.to_string(),"," /// Build the table metadata."," pub fn build(mut self) -> Result {"," self.metadata.last_updated_ms = self"," .unwrap_or_else(|| chrono::Utc::now().timestamp_millis());"," // Check compatibility of the current schema to the default partition spec and sort order."," // We use the `get_xxx` methods from the builder to avoid using the panicking"," // `TableMetadata.default_partition_spec` etc. methods."," let sort_order = Arc::unwrap_or_clone(self.get_default_sort_order()?);"," self.metadata.default_spec = Arc::new("," Arc::unwrap_or_clone(self.metadata.default_spec)"," .into_unbound()"," .bind(schema.clone())?,"," self.metadata.default_partition_type ="," self.metadata.default_spec.partition_type(&schema)?;"," SortOrder::builder()"," .build(&schema)?;"," self.update_snapshot_log()?;"," self.metadata.try_normalize()?;"," if let Some(hist_entry) = self.previous_history_entry.take() {"," self.metadata.metadata_log.push(hist_entry);"," let expired_metadata_logs = self.expire_metadata_log();"," Ok(TableMetadataBuildResult {"," metadata: self.metadata,"," changes: self.changes,"," expired_metadata_logs,"," fn expire_metadata_log(&mut self) -> Vec {"," let max_size = self"," .properties"," .get(TableProperties::PROPERTY_METADATA_PREVIOUS_VERSIONS_MAX)"," .and_then(|v| v.parse::().ok())"," .unwrap_or(TableProperties::PROPERTY_METADATA_PREVIOUS_VERSIONS_MAX_DEFAULT)"," .max(1);"," if self.metadata.metadata_log.len() > max_size {"," self.metadata"," .metadata_log"," .drain(0..self.metadata.metadata_log.len() - max_size)"," .collect()"," Vec::new()"," fn update_snapshot_log(&mut self) -> Result<()> {"," let intermediate_snapshots = self.get_intermediate_snapshots();"," let has_removed_snapshots = self"," .changes"," .any(|update| matches!(update, TableUpdate::RemoveSnapshots { .. }));"," if intermediate_snapshots.is_empty() && !has_removed_snapshots {"," let mut new_snapshot_log = Vec::new();"," for log_entry in &self.metadata.snapshot_log {"," let snapshot_id = log_entry.snapshot_id;"," if self.metadata.snapshots.contains_key(&snapshot_id) {"," if !intermediate_snapshots.contains(&snapshot_id) {"," new_snapshot_log.push(log_entry.clone());"," } else if has_removed_snapshots {"," // any invalid entry causes the history before it to be removed. otherwise, there could be"," // history gaps that cause time-travel queries to produce incorrect results. for example,"," // if history is [(t1, s1), (t2, s2), (t3, s3)] and s2 is removed, the history cannot be"," // [(t1, s1), (t3, s3)] because it appears that s3 was current during the time between t2"," // and t3 when in fact s2 was the current snapshot."," new_snapshot_log.clear();"," if let Some(current_snapshot_id) = self.metadata.current_snapshot_id {"," let last_id = new_snapshot_log.last().map(|entry| entry.snapshot_id);"," if last_id != Some(current_snapshot_id) {"," \"Cannot set invalid snapshot log: latest entry is not the current snapshot\","," self.metadata.snapshot_log = new_snapshot_log;"," /// Finds intermediate snapshots that have not been committed as the current snapshot."," /// Transactions can create snapshots that are never the current snapshot because several"," /// changes are combined by the transaction into one table metadata update. when each"," /// intermediate snapshot is added to table metadata, it is added to the snapshot log, assuming"," /// that it will be the current snapshot. when there are multiple snapshot updates, the log must"," /// be corrected by suppressing the intermediate snapshot entries."," /// "," /// A snapshot is an intermediate snapshot if it was added but is not the current snapshot."," fn get_intermediate_snapshots(&self) -> HashSet {"," let added_snapshot_ids = self"," .filter_map(|update| match update {"," TableUpdate::AddSnapshot { snapshot } => Some(snapshot.snapshot_id()),"," _ => None,"," .collect::>();"," TableUpdate::SetSnapshotRef {"," ref_name,"," reference,"," } => {"," if added_snapshot_ids.contains(&reference.snapshot_id)"," && ref_name == MAIN_BRANCH"," && reference.snapshot_id"," != self"," .metadata"," .current_snapshot_id"," .unwrap_or(i64::from(Self::LAST_ADDED))"," {"," Some(reference.snapshot_id)"," } else {"," None"," }"," .collect()"," fn reassign_ids("," spec: UnboundPartitionSpec,"," ) -> Result<(Schema, PartitionSpec, SortOrder)> {"," // Re-assign field ids and schema ids for a new table."," let previous_id_to_name = schema.field_id_to_name_map().clone();"," let fresh_schema = schema"," .into_builder()"," .with_schema_id(DEFAULT_SCHEMA_ID)"," .with_reassigned_field_ids(FIRST_FIELD_ID)"," // Re-build partition spec with new ids"," let mut fresh_spec = PartitionSpecBuilder::new(fresh_schema.clone());"," for field in spec.fields() {"," let source_field_name = previous_id_to_name.get(&field.source_id).ok_or_else(|| {"," \"Cannot find source column with id {} for partition column {} in schema.\","," field.source_id, field.name"," fresh_spec ="," fresh_spec.add_partition_field(source_field_name, &field.name, field.transform)?;"," let fresh_spec = fresh_spec.build()?;"," // Re-build sort order with new ids"," let mut fresh_order = SortOrder::builder();"," for mut field in sort_order.fields {"," \"Cannot find source column with id {} for sort column in schema.\","," field.source_id"," let new_field_id = fresh_schema"," .field_by_name(source_field_name)"," .ok_or_else(|| {"," Error::new("," ErrorKind::Unexpected,"," format!("," \"Cannot find source column with name {source_field_name} for sort column in re-assigned schema.\""," ),"," )"," })?.id;"," field.source_id = new_field_id;"," fresh_order.with_sort_field(field);"," let fresh_sort_order = fresh_order.build(&fresh_schema)?;"," Ok((fresh_schema, fresh_spec, fresh_sort_order))"," fn reuse_or_create_new_schema_id(&self, new_schema: &Schema) -> i32 {"," .find_map(|(id, schema)| new_schema.is_same_schema(schema).then_some(*id))"," .unwrap_or_else(|| self.get_highest_schema_id() + 1)"," fn get_highest_schema_id(&self) -> i32 {"," *self"," .max()"," .unwrap_or(&self.metadata.current_schema_id)"," fn get_current_schema(&self) -> Result<&SchemaRef> {"," .get(&self.metadata.current_schema_id)"," \"Current schema with id '{}' not found in table metadata.\","," self.metadata.current_schema_id"," fn get_default_sort_order(&self) -> Result {"," .get(&self.metadata.default_sort_order_id)"," .cloned()"," \"Default sort order with id '{}' not found in table metadata.\","," self.metadata.default_sort_order_id"," /// If a compatible spec already exists, use the same ID. Otherwise, use 1 more than the highest ID."," fn reuse_or_create_new_spec_id(&self, new_spec: &PartitionSpec) -> i32 {"," .find_map(|(id, old_spec)| new_spec.is_compatible_with(old_spec).then_some(*id))"," .unwrap_or_else(|| {"," self.get_highest_spec_id()"," .map(|id| id + 1)"," .unwrap_or(DEFAULT_PARTITION_SPEC_ID)"," fn get_highest_spec_id(&self) -> Option {"," self.metadata.partition_specs.keys().max().copied()"," /// If a compatible sort-order already exists, use the same ID. Otherwise, use 1 more than the highest ID."," fn reuse_or_create_new_sort_id(&self, new_sort_order: &SortOrder) -> i64 {"," if new_sort_order.is_unsorted() {"," return SortOrder::unsorted_order().order_id;"," .find_map(|(id, sort_order)| {"," sort_order.fields.eq(&new_sort_order.fields).then_some(*id)"," self.highest_sort_order_id()"," .unwrap_or(SortOrder::unsorted_order().order_id)"," + 1"," fn highest_sort_order_id(&self) -> Option {"," self.metadata.sort_orders.keys().max().copied()"," /// Remove schemas by their ids from the table metadata."," /// Does nothing if a schema id is not present. Active schemas should not be removed."," pub fn remove_schemas(mut self, schema_id_to_remove: &[i32]) -> Result {"," if schema_id_to_remove.contains(&self.metadata.current_schema_id) {"," \"Cannot remove current schema\","," if schema_id_to_remove.is_empty() {"," let mut removed_schemas = Vec::with_capacity(schema_id_to_remove.len());"," self.metadata.schemas.retain(|id, _schema| {"," if schema_id_to_remove.contains(id) {"," removed_schemas.push(*id);"," self.changes.push(TableUpdate::RemoveSchemas {"," schema_ids: removed_schemas,","impl From for TableMetadata {"," fn from(result: TableMetadataBuildResult) -> Self {"," result.metadata","#[cfg(test)]","mod tests {"," use std::fs::File;"," use std::io::BufReader;"," use std::thread::sleep;"," use super::*;"," use crate::TableIdent;"," use crate::io::FileIO;"," use crate::spec::{"," BlobMetadata, NestedField, NullOrder, Operation, PartitionSpec, PrimitiveType, Schema,"," SnapshotRetention, SortDirection, SortField, StructType, Summary, TableProperties,"," Transform, Type, UnboundPartitionField,"," };"," use crate::table::Table;"," const TEST_LOCATION: &str = \"s3://bucket/test/location\";"," const LAST_ASSIGNED_COLUMN_ID: i32 = 3;"," fn schema() -> Schema {"," Schema::builder()"," .with_fields(vec!["," NestedField::required(1, \"x\", Type::Primitive(PrimitiveType::Long)).into(),"," NestedField::required(2, \"y\", Type::Primitive(PrimitiveType::Long)).into(),"," NestedField::required(3, \"z\", Type::Primitive(PrimitiveType::Long)).into(),"," ])"," .build()"," .unwrap()"," fn schema_with_unknown_type() -> Schema {"," NestedField::optional(2, \"unknown\", Type::Primitive(PrimitiveType::Unknown)).into(),"," fn sort_order() -> SortOrder {"," let schema = schema();"," .with_order_id(1)"," .with_sort_field(SortField {"," source_id: 3,"," transform: Transform::Bucket(4),"," direction: SortDirection::Descending,"," null_order: NullOrder::First,"," fn partition_spec() -> UnboundPartitionSpec {"," UnboundPartitionSpec::builder()"," .with_spec_id(0)"," .add_partition_field(2, \"y\", Transform::Identity)"," fn builder_without_changes(format_version: FormatVersion) -> TableMetadataBuilder {"," TableMetadataBuilder::new("," schema(),"," partition_spec(),"," sort_order(),"," TEST_LOCATION.to_string(),"," HashMap::new(),"," .unwrap()"," .build()"," .metadata"," .into_builder(Some("," \"s3://bucket/test/location/metadata/metadata1.json\".to_string(),"," ))"," #[test]"," fn test_unknown_type_requires_format_version_v3() {"," let v2_error = TableMetadataBuilder::new("," schema_with_unknown_type(),"," UnboundPartitionSpec::builder().build(),"," SortOrder::unsorted_order(),"," FormatVersion::V2,"," .unwrap_err();"," assert!("," v2_error"," .message()"," .contains(\"unknown type is only supported in v3\"),"," \"unexpected error: {v2_error}\""," let v3_metadata = TableMetadataBuilder::new("," FormatVersion::V3,"," .metadata;"," assert_eq!(v3_metadata.format_version(), FormatVersion::V3);"," fn test_minimal_build() {"," let metadata = TableMetadataBuilder::new("," FormatVersion::V1,"," assert_eq!(metadata.format_version, FormatVersion::V1);"," assert_eq!(metadata.location, TEST_LOCATION);"," assert_eq!(metadata.current_schema_id, 0);"," assert_eq!(metadata.default_spec.spec_id(), 0);"," assert_eq!(metadata.default_sort_order_id, 1);"," assert_eq!(metadata.last_partition_id, 1000);"," assert_eq!(metadata.last_column_id, 3);"," assert_eq!(metadata.snapshots.len(), 0);"," assert_eq!(metadata.current_snapshot_id, None);"," assert_eq!(metadata.refs.len(), 0);"," assert_eq!(metadata.properties.len(), 0);"," assert_eq!(metadata.metadata_log.len(), 0);"," assert_eq!(metadata.last_sequence_number, 0);"," assert_eq!(metadata.last_column_id, LAST_ASSIGNED_COLUMN_ID);"," // Test can serialize v1"," let _ = serde_json::to_string(&metadata).unwrap();"," // Test can serialize v2"," let metadata = metadata"," .into_builder(Some("," \"s3://bucket/test/location/metadata/metadata1.json\".to_string(),"," ))"," .upgrade_format_version(FormatVersion::V2)"," .metadata;"," assert_eq!(metadata.format_version, FormatVersion::V2);"," fn test_build_unpartitioned_unsorted() {"," let schema = Schema::builder().build().unwrap();"," schema.clone(),"," PartitionSpec::unpartition_spec(),"," assert_eq!(metadata.default_sort_order_id, 0);"," assert_eq!(metadata.last_partition_id, UNPARTITIONED_LAST_ASSIGNED_ID);"," assert_eq!(metadata.last_column_id, 0);"," fn test_reassigns_ids() {"," let schema = Schema::builder()"," .with_schema_id(10)"," NestedField::required(11, \"a\", Type::Primitive(PrimitiveType::Long)).into(),"," NestedField::required(12, \"b\", Type::Primitive(PrimitiveType::Long)).into(),"," NestedField::required("," 13,"," \"struct\","," Type::Struct(StructType::new(vec!["," NestedField::required(14, \"nested\", Type::Primitive(PrimitiveType::Long))"," .into(),"," ])),"," .into(),"," NestedField::required(15, \"c\", Type::Primitive(PrimitiveType::Long)).into(),"," .unwrap();"," let spec = PartitionSpec::builder(schema.clone())"," .with_spec_id(20)"," .add_partition_field(\"a\", \"a\", Transform::Identity)"," .add_partition_field(\"struct.nested\", \"nested_partition\", Transform::Identity)"," .with_fields(vec![SortField {"," source_id: 11,"," transform: Transform::Identity,"," direction: SortDirection::Ascending,"," }])"," .with_order_id(10)"," TableMetadataBuilder::reassign_ids(schema, spec.into_unbound(), sort_order).unwrap();"," let expected_schema = Schema::builder()"," NestedField::required(1, \"a\", Type::Primitive(PrimitiveType::Long)).into(),"," NestedField::required(2, \"b\", Type::Primitive(PrimitiveType::Long)).into(),"," 3,"," NestedField::required(5, \"nested\", Type::Primitive(PrimitiveType::Long))"," NestedField::required(4, \"c\", Type::Primitive(PrimitiveType::Long)).into(),"," let expected_spec = PartitionSpec::builder(expected_schema.clone())"," let expected_sort_order = SortOrder::builder()"," source_id: 1,"," .build(&expected_schema)"," assert_eq!(fresh_schema, expected_schema);"," assert_eq!(fresh_spec, expected_spec);"," assert_eq!(fresh_sort_order, expected_sort_order);"," fn test_ids_are_reassigned_for_new_metadata() {"," let schema = schema().into_builder().with_schema_id(10).build().unwrap();"," assert_eq!(metadata.current_schema().schema_id(), 0);"," fn test_new_metadata_changes() {"," let changes = TableMetadataBuilder::new("," HashMap::from_iter(vec![(\"property 1\".to_string(), \"value 1\".to_string())]),"," .changes;"," pretty_assertions::assert_eq!(changes, vec!["," TableUpdate::SetLocation {"," location: TEST_LOCATION.to_string()"," TableUpdate::AddSchema { schema: schema() },"," TableUpdate::SetCurrentSchema { schema_id: -1 },"," TableUpdate::AddSpec {"," // Because this is a new tables, field-ids are assigned"," // partition_spec() has None set for field-id"," spec: PartitionSpec::builder(schema())"," .with_spec_id(0)"," .add_unbound_field(UnboundPartitionField {"," name: \"y\".to_string(),"," transform: Transform::Identity,"," source_id: 2,"," field_id: Some(1000)"," })"," .unwrap()"," .build()"," .into_unbound(),"," TableUpdate::SetDefaultSpec { spec_id: -1 },"," TableUpdate::AddSortOrder {"," sort_order: sort_order(),"," TableUpdate::SetDefaultSortOrder { sort_order_id: -1 },"," TableUpdate::SetProperties {"," updates: HashMap::from_iter(vec![("," \"property 1\".to_string(),"," \"value 1\".to_string()"," )]),"," ]);"," fn test_new_metadata_changes_unpartitioned_unsorted() {"," PartitionSpec::unpartition_spec().into_unbound(),"," TableUpdate::AddSchema {"," schema: Schema::builder().build().unwrap(),"," spec: PartitionSpec::builder(schema)"," sort_order: SortOrder::unsorted_order(),"," fn test_add_partition_spec() {"," let builder = builder_without_changes(FormatVersion::V2);"," let added_spec = UnboundPartitionSpec::builder()"," .with_spec_id(10)"," .add_partition_fields(vec!["," UnboundPartitionField {"," // The previous field - has field_id set"," name: \"y\".to_string(),"," transform: Transform::Identity,"," source_id: 2,"," field_id: Some(1000),"," // A new field without field id - should still be without field id in changes"," name: \"z\".to_string(),"," source_id: 3,"," field_id: None,"," .build();"," let build_result = builder"," .add_partition_spec(added_spec.clone())"," // Spec id should be re-assigned"," let expected_change = added_spec.with_spec_id(1);"," let expected_spec = PartitionSpec::builder(schema())"," .with_spec_id(1)"," .add_unbound_field(UnboundPartitionField {"," name: \"y\".to_string(),"," source_id: 2,"," field_id: Some(1000),"," name: \"z\".to_string(),"," field_id: Some(1001),"," assert_eq!(build_result.changes.len(), 1);"," assert_eq!("," build_result.metadata.partition_spec_by_id(1),"," Some(&Arc::new(expected_spec))"," assert_eq!(build_result.metadata.default_spec.spec_id(), 0);"," assert_eq!(build_result.metadata.last_partition_id, 1001);"," pretty_assertions::assert_eq!(build_result.changes[0], TableUpdate::AddSpec {"," spec: expected_change"," // Remove the spec"," let build_result = build_result"," .remove_partition_specs(&[1])"," assert_eq!(build_result.metadata.partition_specs.len(), 1);"," assert!(build_result.metadata.partition_spec_by_id(1).is_none());"," fn test_set_default_partition_spec() {"," let schema = builder.get_current_schema().unwrap().clone();"," .add_partition_field(1, \"y_bucket[2]\", Transform::Bucket(2))"," .set_default_partition_spec(-1)"," let expected_spec = PartitionSpec::builder(schema)"," name: \"y_bucket[2]\".to_string(),"," transform: Transform::Bucket(2),"," assert_eq!(build_result.changes.len(), 2);"," assert_eq!(build_result.metadata.default_spec, Arc::new(expected_spec));"," assert_eq!(build_result.changes, vec!["," // Should contain the actual ID that was used"," spec: added_spec.with_spec_id(1)"," TableUpdate::SetDefaultSpec { spec_id: -1 }"," fn test_set_existing_default_partition_spec() {"," // Add and set an unbound spec as current"," let unbound_spec = UnboundPartitionSpec::builder().with_spec_id(1).build();"," .add_partition_spec(unbound_spec.clone())"," assert_eq!(build_result.changes[0], TableUpdate::AddSpec {"," spec: unbound_spec.clone()"," assert_eq!(build_result.changes[1], TableUpdate::SetDefaultSpec {"," spec_id: -1"," build_result.metadata.default_spec,"," Arc::new("," unbound_spec"," .bind(build_result.metadata.current_schema().clone())"," // Set old spec again"," .set_default_partition_spec(0)"," assert_eq!(build_result.changes[0], TableUpdate::SetDefaultSpec {"," spec_id: 0"," partition_spec()"," fn test_add_sort_order() {"," let added_sort_order = SortOrder::builder()"," .build(&schema())"," .add_sort_order(added_sort_order.clone())"," let expected_sort_order = added_sort_order.with_order_id(2);"," assert_eq!(build_result.metadata.sort_orders.keys().max(), Some(&2));"," pretty_assertions::assert_eq!("," build_result.metadata.sort_order_by_id(2),"," Some(&Arc::new(expected_sort_order.clone()))"," pretty_assertions::assert_eq!(build_result.changes[0], TableUpdate::AddSortOrder {"," sort_order: expected_sort_order"," fn test_add_compatible_schema() {"," let added_schema = Schema::builder()"," .with_schema_id(1)"," NestedField::required(4, \"a\", Type::Primitive(PrimitiveType::Long)).into(),"," .add_current_schema(added_schema.clone())"," assert_eq!(build_result.metadata.schemas.keys().max(), Some(&1));"," build_result.metadata.schema_by_id(1),"," Some(&Arc::new(added_schema.clone()))"," pretty_assertions::assert_eq!(build_result.changes[0], TableUpdate::AddSchema {"," schema: added_schema"," assert_eq!(build_result.changes[1], TableUpdate::SetCurrentSchema {"," schema_id: -1"," fn test_set_current_schema_change_is_minus_one_if_schema_was_added_in_this_change() {"," .add_schema(added_schema.clone())"," .set_current_schema(1)"," fn test_no_metadata_log_for_create_table() {"," let build_result = TableMetadataBuilder::new("," .unwrap();"," assert_eq!(build_result.metadata.metadata_log.len(), 0);"," fn test_no_metadata_log_entry_for_no_previous_location() {"," // Used for first commit after stage-creation of tables"," let metadata = builder_without_changes(FormatVersion::V2)"," assert_eq!(metadata.metadata_log.len(), 1);"," let build_result = metadata"," .into_builder(None)"," .set_properties(HashMap::from_iter(vec![("," \"foo\".to_string(),"," \"bar\".to_string(),"," )]))"," assert_eq!(build_result.metadata.metadata_log.len(), 1);"," fn test_from_metadata_generates_metadata_log() {"," let metadata_path = \"s3://bucket/test/location/metadata/metadata1.json\";"," let builder = TableMetadataBuilder::new("," .into_builder(Some(metadata_path.to_string()));"," let builder = builder"," .add_default_sort_order(SortOrder::unsorted_order())"," let build_result = builder.build().unwrap();"," build_result.metadata.metadata_log[0].metadata_file,"," metadata_path"," fn test_set_ref() {"," let snapshot = Snapshot::builder()"," .with_snapshot_id(1)"," .with_timestamp_ms(builder.metadata.last_updated_ms + 1)"," .with_sequence_number(0)"," .with_schema_id(0)"," .with_manifest_list(\"/snap-1.avro\")"," .with_summary(Summary {"," operation: Operation::Append,"," additional_properties: HashMap::from_iter(vec!["," ("," \"spark.app.id\".to_string(),"," \"local-1662532784305\".to_string(),"," (\"added-data-files\".to_string(), \"4\".to_string()),"," (\"added-records\".to_string(), \"4\".to_string()),"," (\"added-files-size\".to_string(), \"6001\".to_string()),"," ]),"," let builder = builder.add_snapshot(snapshot.clone()).unwrap();"," builder"," .clone()"," .set_ref(MAIN_BRANCH, SnapshotReference {"," snapshot_id: 10,"," retention: SnapshotRetention::Branch {"," min_snapshots_to_keep: Some(10),"," max_snapshot_age_ms: None,"," max_ref_age_ms: None,"," },"," })"," .unwrap_err()"," .to_string()"," .contains(\"Cannot set 'main' to unknown snapshot: '10'\")"," .set_ref(MAIN_BRANCH, SnapshotReference {"," snapshot_id: 1,"," min_snapshots_to_keep: Some(10),"," assert_eq!(build_result.metadata.snapshots.len(), 1);"," build_result.metadata.snapshot_by_id(1),"," Some(&Arc::new(snapshot.clone()))"," assert_eq!(build_result.metadata.snapshot_log, vec![SnapshotLog {"," snapshot_id: 1,"," timestamp_ms: snapshot.timestamp_ms()"," }])"," fn test_snapshot_log_skips_intermediates() {"," let snapshot_1 = Snapshot::builder()"," let snapshot_2 = Snapshot::builder()"," .with_snapshot_id(2)"," let result = builder"," .add_snapshot(snapshot_1)"," .set_branch_snapshot(snapshot_2.clone(), MAIN_BRANCH)"," assert_eq!(result.metadata.snapshot_log, vec![SnapshotLog {"," snapshot_id: 2,"," timestamp_ms: snapshot_2.timestamp_ms()"," }]);"," assert_eq!(result.metadata.current_snapshot().unwrap().snapshot_id(), 2);"," fn test_remove_main_ref_keeps_snapshot_log() {"," .add_snapshot(snapshot.clone())"," // Verify snapshot log was created"," assert_eq!(result.metadata.snapshot_log.len(), 1);"," assert_eq!(result.metadata.snapshot_log[0].snapshot_id, 1);"," assert_eq!(result.metadata.current_snapshot_id, Some(1));"," // Remove the main ref"," let result_after_remove = result"," \"s3://bucket/test/location/metadata/metadata2.json\".to_string(),"," .remove_ref(MAIN_BRANCH)"," // Verify snapshot log is kept even after removing main ref"," assert_eq!(result_after_remove.metadata.snapshot_log.len(), 1);"," assert_eq!(result_after_remove.metadata.snapshot_log[0].snapshot_id, 1);"," assert_eq!(result_after_remove.metadata.current_snapshot_id, None);"," assert_eq!(result_after_remove.changes.len(), 1);"," result_after_remove.changes[0],"," TableUpdate::RemoveSnapshotRef {"," ref_name: MAIN_BRANCH.to_string()"," fn test_set_branch_snapshot_creates_branch_if_not_exists() {"," additional_properties: HashMap::new(),"," .set_branch_snapshot(snapshot.clone(), \"new_branch\")"," let reference = SnapshotReference {"," retention: SnapshotRetention::Branch {"," min_snapshots_to_keep: None,"," max_snapshot_age_ms: None,"," max_ref_age_ms: None,"," assert_eq!(build_result.metadata.refs.len(), 1);"," build_result.metadata.refs.get(\"new_branch\"),"," Some(&reference)"," TableUpdate::AddSnapshot { snapshot },"," TableUpdate::SetSnapshotRef {"," ref_name: \"new_branch\".to_string(),"," reference"," fn test_cannot_add_duplicate_snapshot_id() {"," builder.add_snapshot(snapshot).unwrap_err();"," fn test_add_incompatible_current_schema_fails() {"," .with_fields(vec![])"," let err = builder"," .add_current_schema(added_schema)"," .unwrap_err();"," err.to_string()"," .contains(\"Cannot find partition source field\")"," fn test_add_partition_spec_for_v1_requires_sequential_ids() {"," let builder = builder_without_changes(FormatVersion::V1);"," field_id: Some(1002),"," let err = builder.add_partition_spec(added_spec).unwrap_err();"," assert!(err.to_string().contains("," \"Cannot add partition spec with non-sequential field ids to format version 1 table\""," ));"," fn test_expire_metadata_log() {"," let metadata = builder"," TableProperties::PROPERTY_METADATA_PREVIOUS_VERSIONS_MAX.to_string(),"," \"2\".to_string(),"," assert_eq!(metadata.metadata.metadata_log.len(), 1);"," assert_eq!(metadata.expired_metadata_logs.len(), 0);"," .into_builder(Some(\"path2\".to_string()))"," \"change_nr\".to_string(),"," \"1\".to_string(),"," assert_eq!(metadata.metadata.metadata_log.len(), 2);"," assert_eq!(metadata.expired_metadata_logs.len(), 1);"," fn test_v2_sequence_number_cannot_decrease() {"," .with_sequence_number(1)"," .with_manifest_list(\"/snap-1\")"," .with_manifest_list(\"/snap-0\")"," .with_parent_snapshot_id(Some(1))"," .set_branch_snapshot(snapshot, MAIN_BRANCH)"," .contains(\"Cannot add snapshot with sequence number\")"," fn test_default_spec_cannot_be_removed() {"," builder.remove_partition_specs(&[0]).unwrap_err();"," fn test_statistics() {"," let statistics = StatisticsFile {"," snapshot_id: 3055729675574597004,"," statistics_path: \"s3://a/b/stats.puffin\".to_string(),"," file_size_in_bytes: 413,"," file_footer_size_in_bytes: 42,"," key_metadata: None,"," blob_metadata: vec![BlobMetadata {"," snapshot_id: 3055729675574597004,"," sequence_number: 1,"," fields: vec![1],"," r#type: \"ndv\".to_string(),"," }],"," let build_result = builder.set_statistics(statistics.clone()).build().unwrap();"," build_result.metadata.statistics,"," HashMap::from_iter(vec![(3055729675574597004, statistics.clone())])"," assert_eq!(build_result.changes, vec![TableUpdate::SetStatistics {"," statistics: statistics.clone()"," // Remove"," let builder = build_result.metadata.into_builder(None);"," .remove_statistics(statistics.snapshot_id)"," assert_eq!(build_result.metadata.statistics.len(), 0);"," assert_eq!(build_result.changes, vec![TableUpdate::RemoveStatistics {"," snapshot_id: statistics.snapshot_id"," // Remove again yields no changes"," assert_eq!(build_result.changes.len(), 0);"," fn test_add_partition_statistics() {"," let statistics = PartitionStatisticsFile {"," statistics_path: \"s3://a/b/partition-stats.parquet\".to_string(),"," file_size_in_bytes: 43,"," .set_partition_statistics(statistics.clone())"," build_result.metadata.partition_statistics,"," TableUpdate::SetPartitionStatistics {"," partition_statistics: statistics.clone()"," .remove_partition_statistics(statistics.snapshot_id)"," assert_eq!(build_result.metadata.partition_statistics.len(), 0);"," TableUpdate::RemovePartitionStatistics {"," snapshot_id: statistics.snapshot_id"," fn last_update_increased_for_property_only_update() {"," let metadata = builder.build().unwrap().metadata;"," let last_updated_ms = metadata.last_updated_ms;"," sleep(std::time::Duration::from_millis(2));"," build_result.metadata.last_updated_ms > last_updated_ms,"," \"{} > {}\","," build_result.metadata.last_updated_ms,"," last_updated_ms"," fn test_construct_default_main_branch() {"," // Load the table without ref"," let file = File::open(format!("," \"{}/testdata/table_metadata/{}\","," env!(\"CARGO_MANIFEST_DIR\"),"," \"TableMetadataV2Valid.json\""," let reader = BufReader::new(file);"," let resp = serde_json::from_reader::<_, TableMetadata>(reader).unwrap();"," let table = Table::builder()"," .metadata(resp)"," .metadata_location(\"s3://bucket/test/location/metadata/v1.json\".to_string())"," .identifier(TableIdent::from_strs([\"ns1\", \"test1\"]).unwrap())"," .file_io(FileIO::new_with_memory())"," table.metadata().refs.get(MAIN_BRANCH).unwrap().snapshot_id,"," table.metadata().current_snapshot_id().unwrap()"," fn test_active_schema_cannot_be_removed() {"," builder.remove_schemas(&[0]).unwrap_err();"," fn test_remove_schemas() {"," assert_eq!(2, table.metadata().schemas.len());"," // can not remove active schema"," let meta_data_builder = table.metadata().clone().into_builder(None);"," meta_data_builder.remove_schemas(&[1]).unwrap_err();"," let mut meta_data_builder = table.metadata().clone().into_builder(None);"," meta_data_builder = meta_data_builder.remove_schemas(&[0]).unwrap();"," let build_result = meta_data_builder.build().unwrap();"," assert_eq!(1, build_result.metadata.schemas.len());"," assert_eq!(1, build_result.metadata.current_schema_id);"," assert_eq!(1, build_result.metadata.current_schema().schema_id());"," assert_eq!(1, build_result.changes.len());"," let remove_schema_ids ="," if let TableUpdate::RemoveSchemas { schema_ids } = &build_result.changes[0] {"," schema_ids"," unreachable!(\"Expected RemoveSchema change\")"," assert_eq!(remove_schema_ids, &[0]);"," fn test_schema_evolution_now_correctly_validates_partition_field_name_conflicts() {"," let initial_schema = Schema::builder()"," NestedField::required(1, \"data\", Type::Primitive(PrimitiveType::String)).into(),"," let partition_spec_with_bucket = UnboundPartitionSpec::builder()"," .add_partition_field(1, \"bucket_data\", Transform::Bucket(16))"," initial_schema,"," partition_spec_with_bucket,"," let partition_field_names: Vec = metadata"," .default_partition_spec()"," .fields()"," .map(|f| f.name.clone())"," assert!(partition_field_names.contains(&\"bucket_data\".to_string()));"," let evolved_schema = Schema::builder()"," // Adding a schema field with the same name as an existing partition field"," NestedField::required(2, \"bucket_data\", Type::Primitive(PrimitiveType::Int)).into(),"," let builder = metadata.into_builder(Some("," // Try to add the evolved schema - this should now fail immediately with a clear error"," let result = builder.add_current_schema(evolved_schema);"," assert!(result.is_err());"," let error = result.unwrap_err();"," let error_message = error.message();"," assert!(error_message.contains(\"Cannot add schema field 'bucket_data' because it conflicts with existing partition field name\"));"," assert!(error_message.contains(\"Schema evolution cannot introduce field names that match existing partition field names\"));"," fn test_schema_evolution_should_validate_on_schema_add_not_metadata_build() {"," let partition_spec = UnboundPartitionSpec::builder()"," .add_partition_field(1, \"partition_col\", Transform::Bucket(16))"," let non_conflicting_schema = Schema::builder()"," NestedField::required(2, \"new_field\", Type::Primitive(PrimitiveType::Int)).into(),"," // This should succeed since there's no name conflict"," let result = metadata"," .clone()"," .into_builder(Some(\"test_location\".to_string()))"," .add_current_schema(non_conflicting_schema)"," assert!(result.is_ok());"," fn test_partition_spec_evolution_validates_schema_field_name_conflicts() {"," NestedField::required(2, \"existing_field\", Type::Primitive(PrimitiveType::Int))"," .into(),"," .add_partition_field(1, \"data_bucket\", Transform::Bucket(16))"," let conflicting_partition_spec = UnboundPartitionSpec::builder()"," .add_partition_field(1, \"existing_field\", Transform::Bucket(8))"," let result = builder.add_partition_spec(conflicting_partition_spec);"," // The error comes from our multi-version validation"," assert!(error_message.contains("," \"Cannot create partition with name 'existing_field' that conflicts with schema field\""," assert!(error_message.contains(\"and is not an identity transform\"));"," fn test_schema_evolution_validates_against_all_historical_schemas() {"," // Create a table with an initial schema that has a field \"existing_field\""," // Add a second schema that removes the existing_field but keeps the data field"," let second_schema = Schema::builder()"," NestedField::required(3, \"new_field\", Type::Primitive(PrimitiveType::String))"," .add_current_schema(second_schema)"," // Now try to add a third schema that reintroduces \"existing_field\""," // This should succeed because \"existing_field\" exists in a historical schema,"," // even though there's a partition field named \"bucket_data\""," let third_schema = Schema::builder()"," NestedField::required(4, \"existing_field\", Type::Primitive(PrimitiveType::Int))"," let builder = metadata"," .into_builder(Some(\"test_location\".to_string()));"," // This should succeed because \"existing_field\" exists in a historical schema"," let result = builder.add_current_schema(third_schema);"," // However, trying to add a schema field that conflicts with the partition field"," // and doesn't exist in any historical schema should fail"," let conflicting_schema = Schema::builder()"," NestedField::required(5, \"bucket_data\", Type::Primitive(PrimitiveType::String))"," .into(), // conflicts with partition field"," let builder2 = metadata.into_builder(Some(\"test_location\".to_string()));"," let result2 = builder2.add_current_schema(conflicting_schema);"," // This should fail because \"bucket_data\" conflicts with partition field name"," // and doesn't exist in any historical schema"," assert!(result2.is_err());"," let error = result2.unwrap_err();"," assert!(error.message().contains(\"Cannot add schema field 'bucket_data' because it conflicts with existing partition field name\"));"," fn test_schema_evolution_allows_existing_partition_field_if_exists_in_historical_schema() {"," // Create initial schema with a field"," NestedField::required(2, \"partition_data\", Type::Primitive(PrimitiveType::Int))"," .add_partition_field(2, \"partition_data\", Transform::Identity)"," // Add a new schema that still contains the partition_data field"," // This should succeed because partition_data exists in historical schemas"," .add_current_schema(evolved_schema);"," fn test_schema_evolution_prevents_new_field_conflicting_with_partition_field() {"," // Create initial schema WITHOUT the conflicting field"," // Try to add a schema with a field that conflicts with partition field name"," // This field name conflicts with the partition field \"bucket_data\""," let builder = metadata.into_builder(Some(\"test_location\".to_string()));"," let result = builder.add_current_schema(conflicting_schema);"," fn test_partition_spec_evolution_allows_non_conflicting_names() {"," // Try to add a partition spec with a field name that does NOT conflict with existing schema fields"," let non_conflicting_partition_spec = UnboundPartitionSpec::builder()"," .add_partition_field(2, \"new_partition_field\", Transform::Bucket(8))"," let result = builder.add_partition_spec(non_conflicting_partition_spec);"," fn test_row_lineage_addition() {"," let new_rows = 30;"," let base = builder_without_changes(FormatVersion::V3)"," let add_rows = Snapshot::builder()"," .with_snapshot_id(0)"," .with_timestamp_ms(base.last_updated_ms + 1)"," .with_manifest_list(\"foo\")"," .with_parent_snapshot_id(None)"," .with_row_range(base.next_row_id(), new_rows)"," let first_addition = base"," .add_snapshot(add_rows.clone())"," assert_eq!(first_addition.next_row_id(), new_rows);"," let add_more_rows = Snapshot::builder()"," .with_timestamp_ms(first_addition.last_updated_ms + 1)"," .with_parent_snapshot_id(Some(0))"," .with_row_range(first_addition.next_row_id(), new_rows)"," let second_addition = first_addition"," .add_snapshot(add_more_rows)"," assert_eq!(second_addition.next_row_id(), new_rows * 2);"," fn test_row_lineage_invalid_snapshot() {"," // add rows to check TableMetadata validation; Snapshot rejects negative next-row-id"," let added = base"," .add_snapshot(add_rows)"," let invalid_new_rows = Snapshot::builder()"," .with_timestamp_ms(added.last_updated_ms + 1)"," // first_row_id is behind table next_row_id"," .with_row_range(added.next_row_id() - 1, 10)"," let err = added"," .add_snapshot(invalid_new_rows)"," err.to_string().contains("," \"Cannot add a snapshot, first-row-id is behind table next-row-id: 29 < 30\""," fn test_row_lineage_append_branch() {"," // Appends to a branch should still change last-row-id even if not on main, these changes"," // should also affect commits to main"," let branch = \"some_branch\";"," // Start with V3 metadata to support row lineage"," // Initial next_row_id should be 0"," assert_eq!(base.next_row_id(), 0);"," // Write to Branch - append 30 rows"," let branch_snapshot_1 = Snapshot::builder()"," .with_row_range(base.next_row_id(), 30)"," let table_after_branch_1 = base"," .set_branch_snapshot(branch_snapshot_1.clone(), branch)"," // Current snapshot should be null (no main branch snapshot yet)"," assert!(table_after_branch_1.current_snapshot().is_none());"," // Branch snapshot should have first_row_id = 0"," let branch_ref = table_after_branch_1.refs.get(branch).unwrap();"," let branch_snap_1 = table_after_branch_1"," .get(&branch_ref.snapshot_id)"," assert_eq!(branch_snap_1.first_row_id(), Some(0));"," // Next row id should be 30"," assert_eq!(table_after_branch_1.next_row_id(), 30);"," // Write to Main - append 28 rows"," let main_snapshot = Snapshot::builder()"," .with_timestamp_ms(table_after_branch_1.last_updated_ms + 1)"," .with_manifest_list(\"bar\")"," .with_row_range(table_after_branch_1.next_row_id(), 28)"," let table_after_main = table_after_branch_1"," .add_snapshot(main_snapshot.clone())"," snapshot_id: main_snapshot.snapshot_id(),"," // Main snapshot should have first_row_id = 30"," let current_snapshot = table_after_main.current_snapshot().unwrap();"," assert_eq!(current_snapshot.first_row_id(), Some(30));"," // Next row id should be 58 (30 + 28)"," assert_eq!(table_after_main.next_row_id(), 58);"," // Write again to branch - append 21 rows"," let branch_snapshot_2 = Snapshot::builder()"," .with_snapshot_id(3)"," .with_timestamp_ms(table_after_main.last_updated_ms + 1)"," .with_sequence_number(2)"," .with_manifest_list(\"baz\")"," .with_parent_snapshot_id(Some(branch_snapshot_1.snapshot_id()))"," .with_row_range(table_after_main.next_row_id(), 21)"," let table_after_branch_2 = table_after_main"," .set_branch_snapshot(branch_snapshot_2.clone(), branch)"," // Branch snapshot should have first_row_id = 58 (30 + 28)"," let branch_ref_2 = table_after_branch_2.refs.get(branch).unwrap();"," let branch_snap_2 = table_after_branch_2"," .get(&branch_ref_2.snapshot_id)"," assert_eq!(branch_snap_2.first_row_id(), Some(58));"," // Next row id should be 79 (30 + 28 + 21)"," assert_eq!(table_after_branch_2.next_row_id(), 79);"," fn test_encryption_keys() {"," // Create test encryption keys"," let encryption_key_1 = EncryptedKey::builder()"," .key_id(\"key-1\")"," .encrypted_key_metadata(vec![1, 2, 3, 4])"," .encrypted_by_id(\"encryption-service-1\")"," .properties(HashMap::from_iter(vec![("," \"algorithm\".to_string(),"," \"AES-256\".to_string(),"," let encryption_key_2 = EncryptedKey::builder()"," .key_id(\"key-2\")"," .encrypted_key_metadata(vec![5, 6, 7, 8])"," .encrypted_by_id(\"encryption-service-2\")"," .properties(HashMap::new())"," // Add first encryption key"," .add_encryption_key(encryption_key_1.clone())"," assert_eq!(build_result.metadata.encryption_keys.len(), 1);"," build_result.metadata.encryption_key(\"key-1\"),"," Some(&encryption_key_1)"," assert_eq!(build_result.changes[0], TableUpdate::AddEncryptionKey {"," encryption_key: encryption_key_1.clone()"," // Add second encryption key"," .add_encryption_key(encryption_key_2.clone())"," assert_eq!(build_result.metadata.encryption_keys.len(), 2);"," build_result.metadata.encryption_key(\"key-2\"),"," Some(&encryption_key_2)"," encryption_key: encryption_key_2.clone()"," // Try to add duplicate key - should not create a change"," // Remove first encryption key"," \"s3://bucket/test/location/metadata/metadata3.json\".to_string(),"," .remove_encryption_key(\"key-1\")"," assert_eq!(build_result.metadata.encryption_key(\"key-1\"), None);"," assert_eq!(build_result.changes[0], TableUpdate::RemoveEncryptionKey {"," key_id: \"key-1\".to_string()"," // Try to remove non-existent key - should not create a change"," \"s3://bucket/test/location/metadata/metadata4.json\".to_string(),"," .remove_encryption_key(\"non-existent-key\")"," // Test encryption_keys_iter()"," let keys = build_result"," .encryption_keys_iter()"," assert_eq!(keys.len(), 1);"," assert_eq!(keys[0], &encryption_key_2);"," // Remove last encryption key"," \"s3://bucket/test/location/metadata/metadata5.json\".to_string(),"," .remove_encryption_key(\"key-2\")"," assert_eq!(build_result.metadata.encryption_keys.len(), 0);"," assert_eq!(build_result.metadata.encryption_key(\"key-2\"), None);"," key_id: \"key-2\".to_string()"," // Verify empty encryption_keys_iter()"," let keys = build_result.metadata.encryption_keys_iter();"," assert_eq!(keys.len(), 0);"," fn test_partition_field_id_reuse_across_specs() {"," NestedField::required(1, \"id\", Type::Primitive(PrimitiveType::Long)).into(),"," NestedField::required(2, \"data\", Type::Primitive(PrimitiveType::String)).into(),"," NestedField::required(3, \"timestamp\", Type::Primitive(PrimitiveType::Timestamp))"," // Create initial table with spec 0: identity(id) -> field_id = 1000"," let initial_spec = UnboundPartitionSpec::builder()"," .add_partition_field(1, \"id\", Transform::Identity)"," let mut metadata = TableMetadataBuilder::new("," initial_spec,"," \"s3://bucket/table\".to_string(),"," // Add spec 1: bucket(data) -> field_id = 1001"," let spec1 = UnboundPartitionSpec::builder()"," .add_partition_field(2, \"data_bucket\", Transform::Bucket(10))"," let builder = metadata.into_builder(Some(\"s3://bucket/table/metadata/v1.json\".to_string()));"," let result = builder.add_partition_spec(spec1).unwrap().build().unwrap();"," metadata = result.metadata;"," // Add spec 2: identity(id) + bucket(data) + year(timestamp)"," // Should reuse field_id 1000 for identity(id) and 1001 for bucket(data)"," let spec2 = UnboundPartitionSpec::builder()"," .add_partition_field(1, \"id\", Transform::Identity) // Should reuse 1000"," .add_partition_field(2, \"data_bucket\", Transform::Bucket(10)) // Should reuse 1001"," .add_partition_field(3, \"year\", Transform::Year) // Should get new 1002"," let builder = metadata.into_builder(Some(\"s3://bucket/table/metadata/v2.json\".to_string()));"," let result = builder.add_partition_spec(spec2).unwrap().build().unwrap();"," // Verify field ID reuse: spec 2 should reuse IDs from specs 0 and 1, assign new ID for new field"," let spec2 = result.metadata.partition_spec_by_id(2).unwrap();"," let field_ids: Vec = spec2.fields().iter().map(|f| f.field_id).collect();"," assert_eq!(field_ids, vec![1000, 1001, 1002]); // Reused 1000, 1001; new 1002","crates/iceberg/src/spec/table_metadata.rs",[2041],{"_419":420,"_421":2042,"_292":2043,"_424":62},4305,[425,426,427,428,429,430,431,432,433,432,434,435,436,437,438,439,166,2044,2045,166,2046,2047,2048,2049,441,166,2050,2051,2052,2053,442,166,2054,2055,443,2056,2057,2058,449,2059,2060,2061,2062,2063,2064,166,2065,2066,166,2067,2068,2069,2070,2071,166,2072,2073,2074,2075,2076,2077,166,2078,2079,2080,455,2081,2082,2083,2084,2085,2086,2087,2088,2089,2090,2091,2092,2093,2094,2095,2096,2097,2098,2099,2100,2101,2102,2103,2104,2105,2106,2107,2108,2109,2110,2111,2112,2113,2114,2115,2116,2117,2118,2119,2120,2121,2122,2123,2124,2125,2126,166,2127,2128,2129,2130,2131,2132,2133,166,2134,2135,2136,2137,2138,2139,2140,2141,2142,2143,2144,2145,2146,2147,2148,2149,2150,2151,2152,475,166,2153,2154,489,553,554,555,556,557,2155,2156,551,166,2157,2158,2159,2160,980,2161,551,166,2162,2158,2163,2164,980,2165,551,166,2166,2158,2167,2168,551,166,2169,2158,2170,2171,551,166,2172,2158,2173,2174,551,166,2175,2158,2176,2177,551,166,2178,489,2179,2180,2158,2181,2182,2183,2184,570,551,166,2185,2158,2186,2187,551,166,2188,2158,2189,2190,551,166,2191,2158,2192,2193,551,166,2194,2158,2195,2196,551,166,2197,2158,2198,2199,551,166,2200,2158,2201,2202,551,166,2203,2158,2204,2205,2206,551,166,2207,2158,2208,2209,551,166,2210,2158,2211,2212,551,166,2213,2158,2214,2215,551,166,2216,2158,2217,2218,551,166,2219,2158,2220,2221,551,166,2158,2222,2223,2224,551,166,2225,2158,2226,2227,551,166,2228,2158,2229,2230,551,166,2231,2158,2232,2233,551,166,2234,2158,2235,2236,551,166,2237,2158,2238,2239,2240,2241,999,551,166,2242,2158,2243,2244,551,166,2245,2246,2158,2247,2248,2249,2250,999,551,166,2251,2158,2252,2253,551,166,2254,2158,2255,2256,551,166,2257,2158,2258,2259,2260,2261,551,166,2257,2158,2262,2263,551,166,2264,2158,2265,2266,551,166,2267,489,2268,2269,489,602,489,2270,2271,2272,551,166,2273,2274,2275,2276,999,551,166,2277,2158,2278,2279,551,166,2280,2158,2281,975,2282,2283,551,166,2284,2158,2285,2286,551,166,2287,2158,2288,975,2289,2290,2291,551,166,2292,2293,2294,679,2295,2296,2297,1608,2298,1610,1611,1612,847,570,551,166,2299,2158,2300,2301,551,166,2302,2158,2303,2304,551,166,2305,2158,2306,2307,551,166,2308,2309,2310,2311,2312,2313,2314,2315,166,2316,2317,2318,2319,679,2320,2321,2322,727,712,2323,729,2324,2325,730,2326,748,2327,544,166,2328,551,166,2329,2330,975,2310,2331,2332,2333,166,2334,2335,166,2336,606,584,607,2337,2338,2339,610,611,570,166,2340,2341,2342,2343,2344,691,692,2345,698,624,544,166,2346,2347,2348,2349,551,166,2350,489,2351,2352,2353,2354,2355,2356,2357,2358,2359,2360,2361,2362,2363,2364,2365,2366,2367,2368,625,551,166,2369,2370,2371,2372,2373,2374,679,606,584,607,2375,610,611,570,166,904,551,166,2376,2377,675,2378,2379,679,2380,2381,2382,2383,570,166,904,551,166,2384,2385,2386,2387,2388,679,606,2389,607,2390,2391,610,611,570,166,2392,897,570,166,2393,606,584,607,2394,2395,610,611,570,166,2396,2259,2397,904,551,166,2398,2399,2400,606,584,607,2401,2402,610,611,570,904,551,166,2403,2404,2405,2406,2407,2408,691,692,693,2409,697,698,624,570,904,551,166,2410,2411,2412,2413,691,692,693,2414,697,698,624,570,166,2415,2416,2417,2418,2419,691,692,693,2420,2421,2422,697,698,624,2423,606,584,2424,611,570,166,904,551,166,2425,2426,2427,606,584,607,2428,2429,610,611,570,166,2430,2431,2432,2433,2434,679,606,584,607,2435,2436,685,2429,610,611,570,166,904,551,166,2437,2438,2439,2440,688,689,2441,691,692,2442,698,624,570,166,2443,688,689,2444,691,692,693,2445,2446,697,698,624,570,904,551,166,2447,2448,2440,688,689,2441,691,692,2449,698,624,570,166,2450,688,689,2444,691,692,693,2451,2446,697,698,624,570,166,904,551,475,166,2452,2453,2454,2455,2456,2457,2458,2454,2455,2456,2457,2459,166,2460,2461,166,2462,2463,2464,1293,2465,2466,1289,2467,2468,2469,1293,2470,166,2471,2472,2473,2474,2475,2476,551,166,2471,2477,2478,2479,2480,2481,2482,2483,2484,2485,2484,2486,551,166,2471,2477,2478,2487,2488,2489,2490,2491,2492,2493,2494,2495,2496,2497,2484,2498,2484,2499,2484,2500,2484,2501,2502,2503,2484,2504,2505,2506,2505,2507,551,166,2471,2477,2478,2508,2509,2481,2482,2484,2510,551,166,2471,2477,2511,2512,2513,2484,2514,2489,2491,2492,2515,2516,2484,2517,2484,2518,2519,2520,2484,2521,2484,2522,2484,2523,2484,2498,2484,2499,2484,2524,2484,2500,2484,2501,2525,2526,2505,2506,2505,2507,551,166,2527,2528,2529,166,2530,2531,2532,2533,2534,2535,166,2536,570,551,166,2537,2531,2532,2538,570,551,166,2539,2540,2541,2542,2543,2544,719,2545,624,570,551,166,2546,2547,2548,2549,2550,2551,2552,624,570,551,166,2553,2547,2554,2555,2556,2557,2558,995,570,551,166,2559,2547,2560,2561,2562,2563,2564,2565,2566,2567,2568,2569,719,2570,793,2571,2572,2573,2574,2575,2576,2383,166,2577,2578,727,712,713,2579,2580,716,729,730,2581,2572,2582,2574,2583,2383,2584,2585,2586,2587,2588,2589,2590,1613,726,727,712,2591,729,2592,2593,2594,166,2595,2596,2597,2598,2599,2600,2601,2602,2603,2604,2605,2606,2607,2608,2609,2610,2611,2612,2613,2614,2615,2616,1445,2617,2618,2619,2620,2621,2622,2623,2624,610,2625,2626,2627,2628,2629,2630,2631,2632,2633,2634,2635,1189,2636,1191,2637,2638,2639,2640,2641,2642,1445,2617,2564,793,166,2643,2644,570,551,166,2645,2547,2646,2647,2648,2568,2569,719,2570,793,2571,2572,2573,2574,2575,2576,2383,166,2577,2578,727,712,713,2579,2580,716,729,730,2581,2572,2582,2574,2583,2383,2584,2585,2586,2587,2588,2589,2590,1613,726,727,712,2591,729,2592,2593,2594,166,2595,2649,2597,2598,2599,2600,2601,2602,2603,2604,2605,2606,2607,2608,2609,2610,2611,2612,2613,2614,2615,2616,1445,2617,2618,2619,2620,2621,2622,2623,2624,610,2625,2626,2627,2628,2629,2630,2631,2632,2633,2634,2635,1189,2636,1191,2637,2638,2639,535,536,793,166,2643,2644,570,551,166,2650,2547,2651,2568,2569,719,2570,793,166,2652,2653,2654,992,2655,2656,2657,2658,2659,2660,2661,2662,2663,2664,2665,166,2666,2667,2668,2669,2670,2671,2672,2673,2674,2675,2676,2677,2678,2679,2680,2681,2682,2683,2684,711,712,2685,717,2686,166,2687,2688,2689,2690,2574,2691,2692,2693,2694,2695,2696,2697,2698,166,2699,719,2700,2695,2696,2698,166,2699,793,166,2701,2702,2703,2704,166,2705,2585,2706,2707,726,727,712,2591,729,2592,2593,2708,166,2595,2709,2710,2598,509,2600,2601,2711,2606,2605,2712,2713,2714,2604,2603,2608,2609,2715,2716,2611,2717,2613,2614,2718,2719,2720,1445,2721,2617,2618,2619,2722,2723,2724,697,2725,755,2726,2727,2728,2729,2730,2731,2732,2733,2734,2735,2736,2737,2683,2738,755,2638,2639,535,2739,793,166,2643,2644,570,551,166,2740,2547,166,2741,2742,2743,2744,2745,166,2746,2747,2748,2564,2749,2750,2683,2751,755,2752,2750,2683,2753,2754,2755,2756,2757,729,755,995,570,551,166,2758,2759,2744,2745,166,2760,2761,2748,2752,2750,2683,2753,2754,2755,2762,2763,729,755,624,570,551,166,2764,2765,2766,2767,2768,2769,2770,2771,2772,2573,2773,2774,2775,2776,2777,1445,2778,2779,2780,2582,2773,2781,2778,2782,2783,2784,2750,2683,2785,755,2786,2787,2750,2683,2788,755,2789,2750,2683,2790,755,2791,2792,2773,2781,2778,2793,2794,2795,2796,624,570,551,166,2797,2547,2798,2799,2800,2801,2768,2770,2771,2802,2803,2804,2805,2806,2807,2808,2809,2810,2811,610,2812,2803,2813,2814,2815,2816,2817,2818,2819,610,2820,2821,2822,2823,2813,2824,2819,610,2825,2826,2784,2750,2683,2785,755,2786,2827,2750,2683,2753,2828,2755,2829,2763,729,755,2787,2750,2683,2788,755,2789,2750,2683,2790,755,2830,2831,2813,2832,2819,610,2833,2795,2796,995,570,551,166,2834,2835,987,2836,2837,1192,551,166,2838,2839,2840,2835,987,2836,2837,1192,551,475,166,2841,2842,2843,2844,2845,2846,2847,2848,2849,2850,475,166,2851,2852,2853,551,475,166,2854,2855,2856,551,475,166,2857,2858,2859,2860,2861,2862,570,551,475,166,2863,2864,2865,2866,2867,2868,2869,2870,475,166,2863,2864,2871,2872,2873,2874,2875,2870,475,166,2876,2877,2878,2879,551,166,2880,2158,2881,2882,551,475,166,1281,1282,2458,2883,2459,166,2884,2885,2886,2887,2461,166,2888,2889,2890,1288,2891,1289,2892,2893,2894,2895,1293,2896,166,2897,2898,2899,166,2900,2901,166,2902,551,166,2903,2904,2905,166,2906,551,166,1333,2907,2908,2419,2909,2910,2911,2912,2913,2914,2915,1187,2916,2917,2918,2919,2920,2921,2922,2923,2634,2919,2924,2925,2922,2926,2927,2928,1191,2929,2930,2931,1187,2932,2933,2919,2934,2935,2936,2937,2927,2928,1191,2929,2938,2939,2940,2941,755,2942,1187,2943,2944,1191,2929,2945,2946,1187,2947,2948,1191,2929,2949,624,2950,166,1385,1549,1299,2951,2952,2953,2954,2955,2951,2956,2957,2958,2955,1303,1304,1398,166,2959,1318,1487,2960,2961,2962,1490,995,1305,1304,1398,166,2963,2964,2965,2966,2967,2968,2969,2970,2971,2972,2973,2974,2975,2976,2977,2978,2979,2980,2981,2982,1696,2983,2984,2985,2986,2987,1720,2988,2989,2990,2991,2992,544,166,2993,2994,166,2995,2996,551,166,1333,2997,2908,2419,2998,2910,2911,2912,2913,2914,2999,2915,1187,2916,2917,2918,2919,2924,2925,2922,2926,2927,2928,1191,2929,2930,2931,1187,2932,2933,2919,2934,2935,2936,2937,2927,2928,1191,2929,2938,2939,2940,2941,755,2942,1187,2943,2944,1191,2929,2945,3000,3001,3002,3003,3004,3005,3006,3007,3008,1612,3009,3010,1191,2929,3011,1187,3012,3013,3014,3015,3016,3017,1191,2929,2946,1187,2947,2948,1191,2929,2949,624,2950,166,1385,1549,3018,3019,3020,3021,3022,1304,1398,166,2959,1318,1487,2960,2961,2962,1490,995,1305,1304,1398,166,1587,1588,3023,1590,3024,3025,1593,1594,1658,995,3026,1591,1480,166,3027,3028,3029,3030,3031,3032,3033,586,1966,3034,3035,1575,1480,166,2963,2964,3036,2966,2967,2968,2969,2970,2971,2972,2973,2974,2975,2976,2977,3037,2979,2980,2981,2982,1696,2983,2984,2985,2986,2987,1720,2988,2989,2990,3038,3039,544,166,2993,2994,166,2995,2996,551,166,1333,3040,2908,679,3041,3042,3043,3044,3045,3046,3047,3048,3049,3050,3051,3052,3053,3054,3055,3056,3052,3053,3054,3057,3058,3052,3059,3054,3060,3061,3052,3062,3054,3063,3064,3052,3065,3066,537,3067,3068,3069,3070,3071,3072,3073,3074,3075,3076,3077,3072,3078,3079,537,3080,3081,3082,3083,3084,3085,537,3086,3087,3088,3089,3090,3091,3092,3093,3094,3095,3096,3097,3098,3072,3099,3088,3100,3072,3101,3102,3103,3104,3105,2950,166,1385,1299,3106,2952,3107,3108,2955,3106,3109,3110,3108,2955,3106,1413,3111,3112,2955,3106,2956,3113,3114,2955,3106,3115,3116,3117,2955,1303,1304,1398,166,3118,2959,1318,3119,1305,1304,1398,166,1056,3120,3121,1398,166,1587,3122,3023,1590,1591,3123,3124,1480,166,2963,2964,3125,3126,3127,3128,3129,3130,3131,2972,2973,3132,2975,2976,3133,3134,3135,3136,3137,3138,3139,3140,1720,3141,3142,2989,2990,2991,2992,544,166,2994,551,166,1333,3143,2908,679,3144,3145,3146,3147,3148,3149,3150,992,3151,3152,3153,3154,3155,3156,3157,3158,3017,3159,616,3160,3161,3162,992,3163,2948,616,3160,3164,3165,3166,3167,992,3168,3169,616,3160,3170,992,3171,3172,616,3160,3173,570,2950,166,1385,1549,3018,3174,3175,3176,3022,1304,1398,166,2959,1318,1304,1398,166,2963,2964,2965,2966,2967,2968,2969,2970,2971,2972,2973,2974,2975,2976,2977,2978,2979,2980,3177,2984,2985,2986,2987,1720,2988,2989,2990,2991,2992,544,166,2993,2994,166,2995,2996,551,166,1333,3178,2908,679,3144,3145,3146,3147,3148,3149,3150,992,3151,3152,3153,3154,3155,3156,3157,3158,2736,3154,3179,3180,3157,3181,3017,3159,616,3160,3161,3162,992,3163,3182,3154,3183,3184,3185,3186,3017,3159,616,3160,3165,3166,3187,3188,537,3167,992,3168,3169,616,3160,3170,992,3171,3172,616,3160,3189,3190,3081,3082,3191,3084,3085,537,3086,3192,3088,3089,3090,3091,3092,3093,3094,3095,3096,3097,3098,537,2419,3193,3194,3089,3090,3091,3092,3093,3094,3095,3096,3097,3098,3104,570,3195,166,3196,1341,1679,3197,826,551,166,1333,3198,2908,679,3144,3145,3146,3147,3148,3149,3150,992,3151,3152,3153,3154,3155,3156,3157,3158,2736,3154,3179,3180,3157,3181,3017,3159,616,3160,3161,3162,992,3163,3182,3154,3183,3184,3185,3186,3017,3159,616,3160,3165,3166,3187,3188,537,3167,992,3168,3169,616,3160,3170,992,3171,3172,616,3160,3189,3081,3082,3199,3084,3085,537,3086,3192,3088,3089,3090,3091,3092,3093,3094,3095,3096,3097,3098,3104,570,3195,166,3196,1341,1679,3200,826,551,166,1333,3201,2908,679,3144,3145,3146,3147,3148,3149,3150,992,3151,3152,3153,3154,3155,3156,3157,3158,2736,3154,3179,3180,3157,3181,3017,3159,616,3160,3161,3162,992,3163,3182,3154,3183,3184,3185,3186,3017,3159,616,3160,3165,3166,3187,3188,537,3167,992,3168,3169,616,3160,3170,992,3171,3172,616,3160,3189,3081,3082,3199,3084,3096,3202,3191,3084,3085,537,3086,3192,3088,3089,3090,3091,3092,3093,3094,3095,3096,3097,3098,3104,570,3195,166,3196,1341,1907,3203,586,826,551,166,1333,3204,2908,679,3205,3206,3207,3208,3209,3210,3211,3150,992,3212,3213,3182,3154,3155,3214,3157,3215,3017,3159,616,3160,3165,3162,992,3163,2948,616,3160,3166,3189,3170,992,2947,2948,616,3160,3216,3217,3218,992,3219,3220,3221,3222,3223,1612,3224,3225,616,3160,3226,3227,3228,570,3195,166,3196,1685,3229,1687,166,3230,3231,3232,3233,826,3234,3235,166,3236,3231,3233,3237,826,3234,3238,551,166,1333,3239,2908,679,3205,3206,3207,3240,3209,3210,3211,3150,992,3212,3213,3182,3154,3155,3214,3157,3215,3017,3159,616,3160,3165,3162,992,3163,2948,616,3160,3166,3189,3170,992,2947,2948,616,3160,3216,3217,3218,992,3219,3220,3241,3222,3223,1612,3224,3225,616,3160,3242,992,3219,3243,3244,3245,3246,3154,3247,3248,3249,3250,3251,3252,3017,3159,616,3160,3227,3228,570,3195,166,1385,1591,3018,3174,3253,3254,3022,1304,1398,2959,1318,1304,1398,1587,3255,3256,1700,3257,1591,1593,1594,1658,995,1480,166,2963,2964,2965,3258,3259,3260,3261,3262,3131,2972,2973,3132,2975,2976,2977,3263,3264,3265,3177,2984,3266,3267,1716,3268,3269,3270,3271,3272,3273,3274,3275,3276,3277,3278,3279,2990,3280,1716,751,752,753,754,755,3279,2991,2992,544,166,2994,551,166,1333,3281,2908,679,3205,3206,3207,3240,3209,3210,3211,3150,992,3212,3213,3182,3154,3155,3214,3157,3215,3017,3159,616,3160,3165,3162,992,3163,2948,616,3160,3166,3189,3170,992,2947,2948,616,3160,3216,3217,3218,992,3219,3220,3241,3222,3223,1612,3224,3225,616,3160,3282,992,3219,3283,3284,616,3160,3227,3228,570,2950,166,1385,1591,3018,3174,3253,3254,3022,1304,1398,2959,1318,1304,1398,1587,3255,3256,1700,3257,1591,1593,1594,1658,995,1480,166,2963,2964,2965,3258,3259,3260,3261,3262,3131,2972,3132,2973,2975,2976,2977,3263,3264,3265,3177,2984,3266,2989,3285,3286,3287,3273,3288,3289,755,2983,3280,1716,751,752,753,754,755,3279,2991,2992,544,166,2994,551,166,1333,3290,2908,2419,2909,3291,624,2950,3292,904,551,166,1333,3293,2908,2419,3294,624,2950,3292,904,551,166,1333,3295,3296,3297,166,3298,3299,166,1385,1591,1299,3300,3301,3302,3303,610,3300,3304,3305,610,2951,1413,3306,3108,2955,1303,1304,1398,166,2959,1318,1487,3307,1405,1418,1490,995,1305,1304,1398,166,1056,3308,1311,1489,1405,1406,1315,995,1311,1312,1313,1314,3309,995,3121,1398,166,2963,2964,3036,3258,3259,3260,3261,3262,3131,2972,3132,2973,2975,3310,3311,2978,2979,3265,3177,2984,3266,2988,2989,2990,2991,3312,544,166,3313,551,166,1333,3314,3315,3316,166,3317,1591,3018,3174,3253,3254,3022,1304,1398,166,3318,1549,1299,2951,2952,3319,3108,2955,3300,3304,3305,610,2951,1413,3306,3108,2955,1303,3320,1304,1398,166,3321,1318,1487,3307,1405,1418,1490,995,1305,1304,1398,166,1056,3308,1311,1489,1405,1406,1315,995,1311,1312,1313,1314,3309,995,3121,1398,166,3322,3323,3324,1590,3325,1593,1594,1658,995,1480,166,3326,3255,3327,3256,1700,1549,3257,1593,1594,1658,995,1480,166,3328,2964,2965,3258,3259,3260,3261,3329,2971,2972,3132,2973,2975,3310,3311,3330,3331,3332,3333,3264,3265,3177,3334,3335,3336,3337,755,3335,3273,3338,755,3160,3266,3280,1716,751,752,753,754,755,3279,2989,2990,2991,2992,544,166,3339,551,166,1333,3340,3315,3341,166,1385,1591,1299,2951,2952,3319,3108,2955,3300,3304,3305,610,2951,1413,3306,3108,2955,1303,1304,1398,166,2959,1318,1487,3307,1405,1418,1490,995,1305,1304,1398,166,1056,3308,1311,1489,1405,1406,1315,995,1311,1312,1313,1314,3309,995,3121,1398,166,2963,2964,2965,3258,3259,3260,3261,3262,3131,2972,2973,3132,2975,3310,3311,2978,2979,3265,3177,3342,3266,2988,2989,2990,2991,2992,544,166,3339,551,166,1333,3343,3315,3344,166,1385,1591,1299,2951,2952,3319,3108,2955,3300,3304,3305,610,2951,1413,3306,3108,2955,1303,1304,1398,166,2959,1318,1487,3307,1405,1418,1490,995,1305,1304,1398,166,2963,2964,3125,3345,3259,3346,3261,3262,3131,2972,3132,2973,3347,2976,3348,2977,3349,2979,3136,3177,3342,3266,2988,2989,2990,2991,2992,544,166,3339,551,166,1333,3350,3315,3344,3351,1494,3352,3353,3354,826,551,166,1333,3355,3315,3356,166,3357,3358,3359,166,3360,3361,1494,3362,3363,826,1494,3364,3365,826,3366,3367,551,166,1333,3368,3369,3370,594,1564,166,3371,3358,3372,166,3373,3361,1494,3362,3374,826,166,3375,3376,3377,3378,3379,3380,551,166,1333,3381,3315,3382,3383,166,3384,3385,166,3386,3387,1341,3388,3389,826,551,166,1333,3390,3369,3391,594,1564,166,3392,3358,3393,166,3394,3361,1494,3362,3374,826,166,3395,3396,3397,166,3398,3399,3400,3401,3402,3403,3404,551,166,1333,3405,3315,3406,3383,166,3385,166,1494,3407,3408,594,551,166,1333,3409,3315,3410,3383,166,3385,166,1494,3407,3411,594,551,166,1333,3412,3315,3413,3383,166,3385,166,1494,3407,3411,594,551,166,1333,3414,3369,3415,594,1564,166,3385,166,1494,3407,3411,594,551,166,1333,3416,3315,3417,3383,166,3385,166,1494,3407,3411,594,551,166,1333,3418,3315,3419,3383,166,3385,166,1494,3407,3411,594,551,166,1333,3420,3421,3422,3423,551,166,1333,3424,3425,3426,3427,3428,3429,964,3430,166,1494,3431,3432,3433,3434,3435,1818,826,551,1333,3436,3437,3426,3438,3429,1064,3439,166,1494,3440,3441,3442,3443,3434,594,551,166,1333,3444,3445,3446,3447,1973,3448,1480,3449,1305,1304,1305,1375,3450,3451,1494,3452,2372,3453,3434,3454,3455,3456,3457,826,3458,1494,3459,3460,3461,3300,3462,3463,3464,3465,871,3466,826,1494,3467,3460,3461,3468,3469,3470,1613,3466,826,551,166,3471,3472,3473,3474,3475,166,3476,3477,166,3478,3479,166,3480,3481,3482,166,3483,3484,3485,2349,1398,166,3486,3487,166,3488,3489,2349,1398,166,3490,3491,551,166,3471,3492,3474,3493,166,3479,3494,166,3495,3496,3497,3498,166,3488,3477,3499,3500,2349,1398,166,3490,3491,551,166,3471,3501,3476,3477,166,3502,3503,166,3504,1806,551,166,3471,3505,3474,3475,3477,166,3506,3479,166,3507,3508,3509,3510,3511,826,3512,3513,3514,3515,3516,3434,3517,3434,3518,166,3519,3520,3521,3482,166,3522,3523,166,3524,3525,3485,2349,1398,166,3526,3527,166,3528,3529,3530,3531,3532,166,3533,3489,2349,1398,166,3534,3535,551,166,1333,3536,1385,1299,1790,3537,1824,1303,1304,1398,166,3538,1486,3539,1305,1304,1398,166,3540,3541,3542,1305,1304,1398,166,3543,1351,576,3544,1338,3545,1339,1326,594,1327,3546,1327,1328,1327,1348,166,3547,3548,166,3549,3550,3551,551,166,1333,3552,3553,1385,1299,1790,1303,1304,1398,166,1351,576,1460,1338,3545,1339,1326,594,1327,1328,1327,1348,166,3554,3555,551,166,1333,3556,3557,3317,1549,1299,3558,3559,1303,1304,1398,166,3318,3560,1299,3558,3561,1303,1304,1398,166,1351,3562,1460,1338,3545,1339,1326,594,1327,3563,1327,1328,1327,1348,166,3564,3565,3566,166,3567,3568,3569,551,166,1333,3570,3571,166,1351,576,1460,1338,3545,1339,1326,594,1327,1328,1327,1348,166,3572,551,166,1333,3573,3574,1789,1299,2012,3575,1389,1413,3576,3117,871,1396,1303,1304,1398,166,1351,1793,1460,1338,3545,1339,1326,594,1564,166,1800,1299,2012,3575,1389,1413,3576,3117,871,1396,3577,1824,1303,1304,1398,166,3578,3579,1299,2012,3575,3577,1824,3580,1824,1303,1304,1398,166,3581,3582,1305,1304,1305,1375,166,3583,166,3584,3585,3586,3587,3588,551,166,1333,3589,3590,679,3205,3206,3207,3591,3592,3210,3593,3150,992,3212,3594,3182,3595,3596,3159,616,3160,3165,3597,3598,3189,3170,992,2947,3182,3154,3599,3600,3601,3602,3017,3159,616,3160,3216,3603,3604,570,2950,166,3605,166,3606,1341,3607,3608,826,551,166,1333,3609,3610,166,1385,1299,2012,1303,1304,1398,166,1351,576,1460,1338,3545,1339,1326,594,1327,1328,1327,1348,166,3611,166,1494,3612,3613,826,1494,3614,3615,826,551,166,1333,3616,3610,166,1385,1299,2012,1303,1304,1398,166,3617,3618,3619,3620,3621,3618,3622,3623,3621,1458,166,1351,576,1460,1338,3545,1339,579,594,1327,1328,1327,1348,166,3611,166,3624,3625,551,166,1333,3626,1385,1299,2012,1303,1304,1398,166,3627,3628,3629,3630,166,1351,576,1460,1338,3545,1339,579,594,1327,1328,1327,1348,166,3631,3632,3633,551,166,1333,3634,3635,1385,1299,2012,1303,1304,1398,166,3636,576,1460,1338,3637,1339,1326,594,1327,1328,1327,1348,166,3638,1587,1588,3639,1700,1591,3640,1593,1594,3641,3642,3643,1457,995,1480,166,3644,3645,3646,1305,3647,1618,751,752,753,754,755,995,1305,1304,1305,1375,166,3648,3649,3650,166,3651,3652,3653,3654,1305,1304,1305,1375,166,3655,3656,3657,166,3658,3659,1341,3660,3661,826,166,3662,3663,1341,3664,3665,826,166,3666,3667,3668,3669,166,3670,3671,1341,3672,3673,826,551,166,1333,3674,3675,1385,1299,2012,1303,1304,1398,166,1346,576,1460,1338,3637,1347,1326,594,1327,1328,1327,1348,166,3676,1587,1588,3677,1700,1591,3640,1593,1594,3641,3642,3643,1457,995,3678,1480,166,3679,3645,3646,1305,3647,1618,751,752,753,754,755,995,1305,1304,1305,1375,166,3680,3681,1341,3682,3683,826,3684,3685,3686,166,3687,3688,1341,3664,3689,826,166,3666,3667,3668,3669,166,3690,3671,1341,3691,3692,826,3693,3694,3695,3696,551,475],"//! Defines the [table metadata](https://iceberg.apache.org/spec/#table-metadata).","//! The main struct here is [TableMetadataV2] which defines the data for a table.","use std::cmp::Ordering;","use std::collections::HashMap;","use std::fmt::{Display, Formatter};","use std::hash::Hash;","use _serde::TableMetadataEnum;","use chrono::{DateTime, Utc};","use serde::{Deserialize, Serialize};","use serde_repr::{Deserialize_repr, Serialize_repr};","use super::snapshot::SnapshotReference;","pub use super::table_metadata_builder::{TableMetadataBuildResult, TableMetadataBuilder};"," DEFAULT_PARTITION_SPEC_ID, PartitionSpecRef, PartitionStatisticsFile, SchemaId, SchemaRef,"," SnapshotRef, SnapshotRetention, SortOrder, SortOrderRef, StatisticsFile, StructType,"," TableProperties, parse_metadata_file_compression,","use crate::catalog::MetadataLocation;","use crate::compression::CompressionCodec;","use crate::error::{Result, timestamp_ms_to_utc};","use crate::io::FileIO;","use crate::spec::EncryptedKey;","use crate::{Error, ErrorKind};","static MAIN_BRANCH: &str = \"main\";","pub(crate) static ONE_MINUTE_MS: i64 = 60_000;","/// Sentinel value used by the Java implementation and older metadata files","/// to represent a missing/empty current snapshot ID. During deserialization,","/// this value is normalized to `None`.","pub(crate) static EMPTY_SNAPSHOT_ID: i64 = -1;","pub(crate) static INITIAL_SEQUENCE_NUMBER: i64 = 0;","/// Initial row id for row lineage for new v3 tables and older tables upgrading to v3.","pub const INITIAL_ROW_ID: u64 = 0;","/// Minimum format version that supports row lineage (v3).","pub const MIN_FORMAT_VERSION_ROW_LINEAGE: FormatVersion = FormatVersion::V3;","/// Reference to [`TableMetadata`].","pub type TableMetadataRef = Arc;","#[derive(Debug, PartialEq, Deserialize, Eq, Clone)]","#[serde(try_from = \"TableMetadataEnum\")]","/// Fields for the version 2 of the table metadata.","/// We assume that this data structure is always valid, so we will panic when invalid error happens.","/// We check the validity of this data structure when constructing.","pub struct TableMetadata {"," /// Integer Version for the format."," pub(crate) format_version: FormatVersion,"," /// A UUID that identifies the table"," pub(crate) table_uuid: Uuid,"," /// Location tables base location"," pub(crate) location: String,"," /// The tables highest sequence number"," pub(crate) last_sequence_number: i64,"," /// Timestamp in milliseconds from the unix epoch when the table was last updated."," pub(crate) last_updated_ms: i64,"," /// An integer; the highest assigned column ID for the table."," pub(crate) last_column_id: i32,"," /// A list of schemas, stored as objects with schema-id."," pub(crate) schemas: HashMap,"," /// ID of the table’s current schema."," pub(crate) current_schema_id: i32,"," /// A list of partition specs, stored as full partition spec objects."," pub(crate) partition_specs: HashMap,"," /// ID of the “current” spec that writers should use by default."," pub(crate) default_spec: PartitionSpecRef,"," /// Partition type of the default partition spec."," pub(crate) default_partition_type: StructType,"," /// An integer; the highest assigned partition field ID across all partition specs for the table."," pub(crate) last_partition_id: i32,"," ///A string to string map of table properties. This is used to control settings that"," /// affect reading and writing and is not intended to be used for arbitrary metadata."," /// For example, commit.retry.num-retries is used to control the number of commit retries."," pub(crate) properties: HashMap,"," /// long ID of the current table snapshot; must be the same as the current"," /// ID of the main branch in refs."," pub(crate) current_snapshot_id: Option,"," ///A list of valid snapshots. Valid snapshots are snapshots for which all"," /// data files exist in the file system. A data file must not be deleted"," /// from the file system until the last snapshot in which it was listed is"," /// garbage collected."," pub(crate) snapshots: HashMap,"," /// A list (optional) of timestamp and snapshot ID pairs that encodes changes"," /// to the current snapshot for the table. Each time the current-snapshot-id"," /// is changed, a new entry should be added with the last-updated-ms"," /// and the new current-snapshot-id. When snapshots are expired from"," /// the list of valid snapshots, all entries before a snapshot that has"," /// expired should be removed."," pub(crate) snapshot_log: Vec,"," /// A list (optional) of timestamp and metadata file location pairs"," /// that encodes changes to the previous metadata files for the table."," /// Each time a new metadata file is created, a new entry of the"," /// previous metadata file location should be added to the list."," /// Tables can be configured to remove the oldest metadata log entries and"," /// keep a fixed-size log of the most recent entries after a commit."," pub(crate) metadata_log: Vec,"," /// A list of sort orders, stored as full sort order objects."," pub(crate) sort_orders: HashMap,"," /// Default sort order id of the table. Note that this could be used by"," /// writers, but is not used when reading because reads use the specs"," /// stored in manifest files."," pub(crate) default_sort_order_id: i64,"," /// A map of snapshot references. The map keys are the unique snapshot reference"," /// names in the table, and the map values are snapshot reference objects."," /// There is always a main branch reference pointing to the current-snapshot-id"," /// even if the refs map is null."," pub(crate) refs: HashMap,"," /// Mapping of snapshot ids to statistics files."," pub(crate) statistics: HashMap,"," /// Mapping of snapshot ids to partition statistics files."," pub(crate) partition_statistics: HashMap,"," /// Encryption Keys - map of key id to the actual key"," pub(crate) encryption_keys: HashMap,"," /// Next row id to be assigned for Row Lineage (v3)"," pub(crate) next_row_id: u64,","impl TableMetadata {"," /// Convert this Table Metadata into a builder for modification."," pub fn into_builder(self, current_file_location: Option) -> TableMetadataBuilder {"," TableMetadataBuilder::new_from_metadata(self, current_file_location)"," /// Check if a partition field name exists in any partition spec."," #[inline]"," pub(crate) fn partition_name_exists(&self, name: &str) -> bool {"," self.partition_specs"," .any(|spec| spec.fields().iter().any(|pf| pf.name == name))"," /// Check if a field name exists in any schema."," pub(crate) fn name_exists_in_any_schema(&self, name: &str) -> bool {"," self.schemas"," .any(|schema| schema.field_by_name(name).is_some())"," /// Returns format version of this metadata."," pub fn format_version(&self) -> FormatVersion {"," self.format_version"," /// Returns uuid of current table."," pub fn uuid(&self) -> Uuid {"," self.table_uuid"," /// Returns table location."," pub fn location(&self) -> &str {"," self.location.as_str()"," /// Returns last sequence number."," pub fn last_sequence_number(&self) -> i64 {"," self.last_sequence_number"," /// Returns the next sequence number for the table."," /// For format version 1, it always returns the initial sequence number."," /// For other versions, it returns the last sequence number incremented by 1."," pub fn next_sequence_number(&self) -> i64 {"," match self.format_version {"," FormatVersion::V1 => INITIAL_SEQUENCE_NUMBER,"," _ => self.last_sequence_number + 1,"," /// Returns the last column id."," pub fn last_column_id(&self) -> i32 {"," self.last_column_id"," /// Returns the last partition_id"," pub fn last_partition_id(&self) -> i32 {"," self.last_partition_id"," /// Returns last updated time."," pub fn last_updated_timestamp(&self) -> Result> {"," timestamp_ms_to_utc(self.last_updated_ms)"," /// Returns last updated time in milliseconds."," pub fn last_updated_ms(&self) -> i64 {"," self.last_updated_ms"," /// Returns schemas"," pub fn schemas_iter(&self) -> impl ExactSizeIterator {"," self.schemas.values()"," /// Lookup schema by id."," pub fn schema_by_id(&self, schema_id: SchemaId) -> Option<&SchemaRef> {"," self.schemas.get(&schema_id)"," /// Get current schema"," pub fn current_schema(&self) -> &SchemaRef {"," self.schema_by_id(self.current_schema_id)"," .expect(\"Current schema id set, but not found in table metadata\")"," /// Get the id of the current schema"," pub fn current_schema_id(&self) -> SchemaId {"," self.current_schema_id"," /// Returns all partition specs."," pub fn partition_specs_iter(&self) -> impl ExactSizeIterator {"," self.partition_specs.values()"," /// Lookup partition spec by id."," pub fn partition_spec_by_id(&self, spec_id: i32) -> Option<&PartitionSpecRef> {"," self.partition_specs.get(&spec_id)"," /// Get default partition spec"," pub fn default_partition_spec(&self) -> &PartitionSpecRef {"," &self.default_spec"," /// Return the partition type of the default partition spec."," pub fn default_partition_type(&self) -> &StructType {"," &self.default_partition_type"," /// Returns spec id of the \"current\" partition spec."," pub fn default_partition_spec_id(&self) -> i32 {"," self.default_spec.spec_id()"," /// Returns all snapshots"," pub fn snapshots(&self) -> impl ExactSizeIterator {"," self.snapshots.values()"," /// Lookup snapshot by id."," pub fn snapshot_by_id(&self, snapshot_id: i64) -> Option<&SnapshotRef> {"," self.snapshots.get(&snapshot_id)"," /// Returns snapshot history."," pub fn history(&self) -> &[SnapshotLog] {"," &self.snapshot_log"," /// Returns the metadata log."," pub fn metadata_log(&self) -> &[MetadataLog] {"," &self.metadata_log"," /// Get current snapshot"," pub fn current_snapshot(&self) -> Option<&SnapshotRef> {"," self.current_snapshot_id.map(|s| {"," self.snapshot_by_id(s)"," .expect(\"Current snapshot id has been set, but doesn't exist in metadata\")"," /// Get the current snapshot id"," pub fn current_snapshot_id(&self) -> Option {"," self.current_snapshot_id"," /// Get the snapshot for a reference"," /// Returns an option if the `ref_name` is not found"," pub fn snapshot_for_ref(&self, ref_name: &str) -> Option<&SnapshotRef> {"," self.refs.get(ref_name).map(|r| {"," self.snapshot_by_id(r.snapshot_id)"," .unwrap_or_else(|| panic!(\"Snapshot id of ref {ref_name} doesn't exist\"))"," /// Return all sort orders."," pub fn sort_orders_iter(&self) -> impl ExactSizeIterator {"," self.sort_orders.values()"," /// Lookup sort order by id."," pub fn sort_order_by_id(&self, sort_order_id: i64) -> Option<&SortOrderRef> {"," self.sort_orders.get(&sort_order_id)"," /// Returns default sort order id."," pub fn default_sort_order(&self) -> &SortOrderRef {"," self.sort_orders"," .get(&self.default_sort_order_id)"," .expect(\"Default order id has been set, but not found in table metadata!\")"," pub fn default_sort_order_id(&self) -> i64 {"," self.default_sort_order_id"," /// Returns properties of table."," pub fn properties(&self) -> &HashMap {"," &self.properties"," /// Returns the metadata compression codec from table properties."," /// Returns `CompressionCodec::None` if compression is disabled or not configured."," /// Returns `CompressionCodec::Gzip` if gzip compression is enabled."," /// Returns an error if the compression codec property has an invalid value."," pub fn metadata_compression_codec(&self) -> Result {"," parse_metadata_file_compression(&self.properties)"," /// Returns typed table properties parsed from the raw properties map with defaults."," pub fn table_properties(&self) -> Result {"," TableProperties::try_from(&self.properties).map_err(|e| {"," Error::new(ErrorKind::DataInvalid, \"Invalid table properties\").with_source(e)"," /// Return location of statistics files."," pub fn statistics_iter(&self) -> impl ExactSizeIterator {"," self.statistics.values()"," /// Return location of partition statistics files."," pub fn partition_statistics_iter("," ) -> impl ExactSizeIterator {"," self.partition_statistics.values()"," /// Get a statistics file for a snapshot id."," pub fn statistics_for_snapshot(&self, snapshot_id: i64) -> Option<&StatisticsFile> {"," self.statistics.get(&snapshot_id)"," /// Get a partition statistics file for a snapshot id."," pub fn partition_statistics_for_snapshot("," snapshot_id: i64,"," ) -> Option<&PartitionStatisticsFile> {"," self.partition_statistics.get(&snapshot_id)"," fn construct_refs(&mut self) {"," if let Some(current_snapshot_id) = self.current_snapshot_id"," && !self.refs.contains_key(MAIN_BRANCH)"," self.refs"," .insert(MAIN_BRANCH.to_string(), SnapshotReference {"," snapshot_id: current_snapshot_id,"," min_snapshots_to_keep: None,"," /// Iterate over all encryption keys"," pub fn encryption_keys_iter(&self) -> impl ExactSizeIterator {"," self.encryption_keys.values()"," /// Get the encryption key for a given key id"," pub fn encryption_key(&self, key_id: &str) -> Option<&EncryptedKey> {"," self.encryption_keys.get(key_id)"," /// Get the next row id to be assigned"," pub fn next_row_id(&self) -> u64 {"," self.next_row_id"," /// Read table metadata from the given location."," pub async fn read_from("," file_io: &FileIO,"," metadata_location: impl AsRef,"," ) -> Result {"," let metadata_location = metadata_location.as_ref();"," let input_file = file_io.new_input(metadata_location)?;"," let metadata_content = input_file.read().await?;"," // Check if the file is compressed by looking for the gzip \"magic number\"."," let metadata = if metadata_content.len() > 2"," && metadata_content[0] == 0x1F"," && metadata_content[1] == 0x8B"," let decompressed_data = CompressionCodec::gzip_default()"," .decompress(metadata_content.to_vec())"," .map_err(|e| {"," \"Trying to read compressed metadata file\","," .with_context(\"file_path\", metadata_location)"," .with_source(e)"," serde_json::from_slice(&decompressed_data)?"," serde_json::from_slice(&metadata_content)?"," Ok(metadata)"," /// Write table metadata to the given location."," pub async fn write_to("," metadata_location: &MetadataLocation,"," ) -> Result<()> {"," let json_data = serde_json::to_vec(self)?;"," // Check if compression codec from properties matches the one in metadata_location"," let codec = parse_metadata_file_compression(&self.properties)?;"," if codec != metadata_location.compression_codec() {"," \"Compression codec mismatch: metadata_location has {:?}, but table properties specify {:?}\","," metadata_location.compression_codec(),"," codec"," // Apply compression based on codec"," let data_to_write = match codec {"," CompressionCodec::Gzip(_) => codec.compress(json_data)?,"," CompressionCodec::None => json_data,"," _ => {"," format!(\"Unsupported metadata compression codec: {codec:?}\"),"," file_io"," .new_output(metadata_location.to_string())?"," .write(data_to_write.into())"," .await"," /// Normalize this partition spec."," /// This is an internal method"," /// meant to be called after constructing table metadata from untrusted sources."," /// We run this method after json deserialization."," /// All constructors for `TableMetadata` which are part of `iceberg-rust`"," /// should return normalized `TableMetadata`."," pub(super) fn try_normalize(&mut self) -> Result<&mut Self> {"," self.validate_current_schema()?;"," self.validate_schema_format_versions()?;"," self.normalize_current_snapshot()?;"," self.construct_refs();"," self.validate_refs()?;"," self.validate_chronological_snapshot_logs()?;"," self.validate_chronological_metadata_logs()?;"," // Normalize location (remove trailing slash)"," self.location = self.location.trim_end_matches('/').to_string();"," self.validate_snapshot_sequence_number()?;"," self.try_normalize_partition_spec()?;"," self.try_normalize_sort_order()?;"," fn validate_schema_format_versions(&self) -> Result<()> {"," if self.format_version < FormatVersion::V3"," && let Some(schema_id) = self"," .schemas"," .iter()"," .find_map(|(schema_id, schema)| schema.contains_unknown_type().then_some(schema_id))"," \"Schema {schema_id} contains unknown type, which is only supported in table format version v3\""," /// If the default partition spec is not present in specs, add it"," fn try_normalize_partition_spec(&mut self) -> Result<()> {"," .partition_spec_by_id(self.default_spec.spec_id())"," .is_none()"," self.partition_specs.insert("," self.default_spec.spec_id(),"," Arc::new(Arc::unwrap_or_clone(self.default_spec.clone())),"," );"," /// If the default sort order is unsorted but the sort order is not present, add it"," fn try_normalize_sort_order(&mut self) -> Result<()> {"," // Validate that sort order ID 0 (reserved for unsorted) has no fields"," if let Some(sort_order) = self.sort_order_by_id(SortOrder::UNSORTED_ORDER_ID)"," && !sort_order.fields.is_empty()"," ErrorKind::Unexpected,"," \"Sort order ID {} is reserved for unsorted order\","," SortOrder::UNSORTED_ORDER_ID"," if self.sort_order_by_id(self.default_sort_order_id).is_some() {"," if self.default_sort_order_id != SortOrder::UNSORTED_ORDER_ID {"," \"No sort order exists with the default sort order id {}.\","," self.default_sort_order_id"," let sort_order = SortOrder::unsorted_order();"," .insert(SortOrder::UNSORTED_ORDER_ID, Arc::new(sort_order));"," /// Validate the current schema is set and exists."," fn validate_current_schema(&self) -> Result<()> {"," if self.schema_by_id(self.current_schema_id).is_none() {"," \"No schema exists with the current schema id {}.\","," self.current_schema_id"," /// If current snapshot is Some(-1) then set it to None."," fn normalize_current_snapshot(&mut self) -> Result<()> {"," if let Some(current_snapshot_id) = self.current_snapshot_id {"," if current_snapshot_id == EMPTY_SNAPSHOT_ID {"," self.current_snapshot_id = None;"," } else if self.snapshot_by_id(current_snapshot_id).is_none() {"," \"Snapshot for current snapshot id {current_snapshot_id} does not exist in the existing snapshots list\""," /// Validate that all refs are valid (snapshot exists)"," fn validate_refs(&self) -> Result<()> {"," for (name, snapshot_ref) in self.refs.iter() {"," if self.snapshot_by_id(snapshot_ref.snapshot_id).is_none() {"," \"Snapshot for reference {name} does not exist in the existing snapshots list\""," let main_ref = self.refs.get(MAIN_BRANCH);"," if self.current_snapshot_id.is_some() {"," if let Some(main_ref) = main_ref"," && main_ref.snapshot_id != self.current_snapshot_id.unwrap_or_default()"," {"," \"Current snapshot id does not match main branch ({:?} != {:?})\","," self.current_snapshot_id.unwrap_or_default(),"," main_ref.snapshot_id"," } else if main_ref.is_some() {"," \"Current snapshot is not set, but main branch exists\","," /// Validate that for V1 Metadata the last_sequence_number is 0"," fn validate_snapshot_sequence_number(&self) -> Result<()> {"," if self.format_version < FormatVersion::V2 && self.last_sequence_number != 0 {"," \"Last sequence number must be 0 in v1. Found {}\","," self.last_sequence_number"," if self.format_version >= FormatVersion::V2"," && let Some(snapshot) = self"," .snapshots"," .values()"," .find(|snapshot| snapshot.sequence_number() > self.last_sequence_number)"," \"Invalid snapshot with id {} and sequence number {} greater than last sequence number {}\","," snapshot.snapshot_id(),"," /// Validate snapshots logs are chronological and last updated is after the last snapshot log."," fn validate_chronological_snapshot_logs(&self) -> Result<()> {"," for window in self.snapshot_log.windows(2) {"," let (prev, curr) = (&window[0], &window[1]);"," if curr.timestamp_ms - prev.timestamp_ms < -ONE_MINUTE_MS {"," \"Expected sorted snapshot log entries\","," if let Some(last) = self.snapshot_log.last() {"," if self.last_updated_ms - last.timestamp_ms < -ONE_MINUTE_MS {"," \"Invalid update timestamp {}: before last snapshot log entry at {}\","," self.last_updated_ms, last.timestamp_ms"," fn validate_chronological_metadata_logs(&self) -> Result<()> {"," for window in self.metadata_log.windows(2) {"," \"Expected sorted metadata log entries\","," if let Some(last) = self.metadata_log.last() {"," \"Invalid update timestamp {}: before last metadata log entry at {}\",","pub(super) mod _serde {"," use std::borrow::BorrowMut;"," /// This is a helper module that defines types to help with serialization/deserialization."," /// For deserialization the input first gets read into either the [TableMetadataV1] or [TableMetadataV2] struct"," /// and then converted into the [TableMetadata] struct. Serialization works the other way around."," /// [TableMetadataV1] and [TableMetadataV2] are internal struct that are only used for serialization and deserialization."," use std::collections::HashMap;"," use std::sync::Arc;"," use serde::{Deserialize, Serialize};"," use uuid::Uuid;"," use super::{"," DEFAULT_PARTITION_SPEC_ID, EMPTY_SNAPSHOT_ID, FormatVersion, MAIN_BRANCH, MetadataLog,"," SnapshotLog, TableMetadata,"," use crate::spec::schema::_serde::{SchemaV1, SchemaV2};"," use crate::spec::snapshot::_serde::{SnapshotV1, SnapshotV2, SnapshotV3};"," EncryptedKey, INITIAL_ROW_ID, PartitionField, PartitionSpec, PartitionSpecRef,"," PartitionStatisticsFile, Schema, SchemaRef, Snapshot, SnapshotReference, SnapshotRetention,"," SortOrder, StatisticsFile,"," use crate::{Error, ErrorKind};"," #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]"," #[serde(untagged)]"," pub(super) enum TableMetadataEnum {"," V3(TableMetadataV3),"," V2(TableMetadataV2),"," V1(TableMetadataV1),"," #[serde(rename_all = \"kebab-case\")]"," /// Defines the structure of a v2 table metadata for serialization/deserialization"," pub(super) struct TableMetadataV3 {"," pub format_version: VersionNumber<3>,"," #[serde(flatten)]"," pub shared: TableMetadataV2V3Shared,"," pub next_row_id: u64,"," #[serde(skip_serializing_if = \"Option::is_none\")]"," pub encryption_keys: Option>,"," pub snapshots: Option>,"," pub(super) struct TableMetadataV2V3Shared {"," pub table_uuid: Uuid,"," pub location: String,"," pub last_sequence_number: i64,"," pub last_updated_ms: i64,"," pub last_column_id: i32,"," pub schemas: Vec,"," pub current_schema_id: i32,"," pub partition_specs: Vec,"," pub default_spec_id: i32,"," pub last_partition_id: i32,"," pub properties: Option>,"," pub current_snapshot_id: Option,"," pub snapshot_log: Option>,"," pub metadata_log: Option>,"," pub sort_orders: Vec,"," pub default_sort_order_id: i64,"," pub refs: Option>,"," #[serde(default, skip_serializing_if = \"Vec::is_empty\")]"," pub statistics: Vec,"," pub partition_statistics: Vec,"," pub(super) struct TableMetadataV2 {"," pub format_version: VersionNumber<2>,"," pub snapshots: Option>,"," /// Defines the structure of a v1 table metadata for serialization/deserialization"," pub(super) struct TableMetadataV1 {"," pub format_version: VersionNumber<1>,"," pub table_uuid: Option,"," /// `schema` is optional to prioritize `schemas` and `current-schema-id`, allowing liberal reading of V1 metadata."," pub schema: Option,"," pub schemas: Option>,"," pub current_schema_id: Option,"," /// `partition_spec` is optional to prioritize `partition_specs`, aligning with liberal reading of potentially invalid V1 metadata."," pub partition_spec: Option>,"," pub partition_specs: Option>,"," pub default_spec_id: Option,"," pub last_partition_id: Option,"," pub snapshots: Option>,"," pub sort_orders: Option>,"," pub default_sort_order_id: Option,"," /// Helper to serialize and deserialize the format version."," #[derive(Debug, PartialEq, Eq)]"," pub(crate) struct VersionNumber;"," impl Serialize for TableMetadata {"," fn serialize(&self, serializer: S) -> Result"," where S: serde::Serializer {"," // we must do a clone here"," let table_metadata_enum: TableMetadataEnum ="," self.clone().try_into().map_err(serde::ser::Error::custom)?;"," table_metadata_enum.serialize(serializer)"," impl Serialize for VersionNumber {"," serializer.serialize_u8(V)"," impl<'de, const V: u8> Deserialize<'de> for VersionNumber {"," fn deserialize(deserializer: D) -> Result"," where D: serde::Deserializer<'de> {"," let value = u8::deserialize(deserializer)?;"," if value == V {"," Ok(VersionNumber::)"," Err(serde::de::Error::custom(\"Invalid Version\"))"," impl TryFrom for TableMetadata {"," type Error = Error;"," fn try_from(value: TableMetadataEnum) -> Result {"," match value {"," TableMetadataEnum::V3(value) => value.try_into(),"," TableMetadataEnum::V2(value) => value.try_into(),"," TableMetadataEnum::V1(value) => value.try_into(),"," impl TryFrom for TableMetadataEnum {"," fn try_from(value: TableMetadata) -> Result {"," Ok(match value.format_version {"," FormatVersion::V3 => TableMetadataEnum::V3(value.try_into()?),"," FormatVersion::V2 => TableMetadataEnum::V2(value.into()),"," FormatVersion::V1 => TableMetadataEnum::V1(value.try_into()?),"," impl TryFrom for TableMetadata {"," fn try_from(value: TableMetadataV3) -> Result {"," let TableMetadataV3 {"," format_version: _,"," shared: value,"," next_row_id,"," encryption_keys,"," snapshots,"," } = value;"," let current_snapshot_id = if value.current_snapshot_id == Some(EMPTY_SNAPSHOT_ID) {"," None"," value.current_snapshot_id"," let schemas = HashMap::from_iter("," value"," .schemas"," .into_iter()"," .map(|schema| Ok((schema.schema_id, Arc::new(schema.try_into()?))))"," .collect::, Error>>()?,"," let current_schema: &SchemaRef ="," schemas.get(&value.current_schema_id).ok_or_else(|| {"," \"No schema exists with the current schema id {}.\","," value.current_schema_id"," let partition_specs = HashMap::from_iter("," .partition_specs"," .map(|x| (x.spec_id(), Arc::new(x))),"," let default_spec_id = value.default_spec_id;"," let default_spec: PartitionSpecRef = partition_specs"," .get(&value.default_spec_id)"," .map(|spec| (**spec).clone())"," .or_else(|| {"," (DEFAULT_PARTITION_SPEC_ID == default_spec_id)"," .then(PartitionSpec::unpartition_spec)"," format!(\"Default partition spec {default_spec_id} not found\"),"," })?"," .into();"," let default_partition_type = default_spec.partition_type(current_schema)?;"," let mut metadata = TableMetadata {"," format_version: FormatVersion::V3,"," table_uuid: value.table_uuid,"," location: value.location,"," last_sequence_number: value.last_sequence_number,"," last_updated_ms: value.last_updated_ms,"," last_column_id: value.last_column_id,"," current_schema_id: value.current_schema_id,"," schemas,"," partition_specs,"," default_partition_type,"," default_spec,"," last_partition_id: value.last_partition_id,"," properties: value.properties.unwrap_or_default(),"," current_snapshot_id,"," snapshots: snapshots"," .map(|snapshots| {"," HashMap::from_iter("," snapshots"," .into_iter()"," .map(|x| (x.snapshot_id, Arc::new(x.into()))),"," )"," .unwrap_or_default(),"," snapshot_log: value.snapshot_log.unwrap_or_default(),"," metadata_log: value.metadata_log.unwrap_or_default(),"," sort_orders: HashMap::from_iter("," value"," .sort_orders"," .into_iter()"," .map(|x| (x.order_id, Arc::new(x))),"," default_sort_order_id: value.default_sort_order_id,"," refs: value.refs.unwrap_or_else(|| {"," if let Some(snapshot_id) = current_snapshot_id {"," HashMap::from_iter(vec![(MAIN_BRANCH.to_string(), SnapshotReference {"," snapshot_id,"," retention: SnapshotRetention::Branch {"," min_snapshots_to_keep: None,"," max_snapshot_age_ms: None,"," max_ref_age_ms: None,"," },"," })])"," HashMap::new()"," }),"," statistics: index_statistics(value.statistics),"," partition_statistics: index_partition_statistics(value.partition_statistics),"," encryption_keys: encryption_keys"," .map(|keys| {"," HashMap::from_iter(keys.into_iter().map(|key| (key.key_id.clone(), key)))"," metadata.borrow_mut().try_normalize()?;"," Ok(metadata)"," impl TryFrom for TableMetadata {"," fn try_from(value: TableMetadataV2) -> Result {"," let snapshots = value.snapshots;"," let value = value.shared;"," format_version: FormatVersion::V2,"," impl TryFrom for TableMetadata {"," fn try_from(value: TableMetadataV1) -> Result {"," let (schemas, current_schema_id, current_schema) ="," if let (Some(schemas_vec), Some(schema_id)) ="," (&value.schemas, value.current_schema_id)"," // Option 1: Use 'schemas' + 'current_schema_id'"," let schema_map = HashMap::from_iter("," schemas_vec"," .clone()"," .into_iter()"," .map(|schema| {"," let schema: Schema = schema.try_into()?;"," Ok((schema.schema_id(), Arc::new(schema)))"," })"," .collect::, Error>>()?,"," );"," let schema = schema_map"," .get(&schema_id)"," .ok_or_else(|| {"," Error::new("," ErrorKind::DataInvalid,"," format!(\"No schema exists with the current schema id {schema_id}.\"),"," )"," })?"," .clone();"," (schema_map, schema_id, schema)"," } else if let Some(schema) = value.schema {"," // Option 2: Fall back to `schema`"," let schema: Schema = schema.try_into()?;"," let schema_id = schema.schema_id();"," let schema_arc = Arc::new(schema);"," let schema_map = HashMap::from_iter(vec![(schema_id, schema_arc.clone())]);"," (schema_map, schema_id, schema_arc)"," } else {"," // Option 3: No valid schema configuration found"," \"No valid schema configuration found in table metadata\","," };"," // Prioritize 'partition_specs' over 'partition_spec'"," let partition_specs = if let Some(specs_vec) = value.partition_specs {"," // Option 1: Use 'partition_specs'"," specs_vec"," .map(|x| (x.spec_id(), Arc::new(x)))"," .collect::>()"," } else if let Some(partition_spec) = value.partition_spec {"," // Option 2: Fall back to 'partition_spec'"," let spec = PartitionSpec::builder(current_schema.clone())"," .with_spec_id(DEFAULT_PARTITION_SPEC_ID)"," .add_unbound_fields(partition_spec.into_iter().map(|f| f.into_unbound()))?"," .build()?;"," HashMap::from_iter(vec![(DEFAULT_PARTITION_SPEC_ID, Arc::new(spec))])"," // Option 3: Create empty partition spec"," // Get the default_spec_id, prioritizing the explicit value if provided"," let default_spec_id = value"," .default_spec_id"," .unwrap_or_else(|| partition_specs.keys().copied().max().unwrap_or_default());"," // Get the default spec"," .get(&default_spec_id)"," .map(|x| Arc::unwrap_or_clone(x.clone()))"," let default_partition_type = default_spec.partition_type(¤t_schema)?;"," format_version: FormatVersion::V1,"," table_uuid: value.table_uuid.unwrap_or_default(),"," current_schema_id,"," last_partition_id: value"," .last_partition_id"," .unwrap_or_else(|| partition_specs.keys().copied().max().unwrap_or_default()),"," snapshots: value"," .snapshots"," Ok::<_, Error>(HashMap::from_iter("," .map(|x| Ok((x.snapshot_id, Arc::new(x.try_into()?))))"," .collect::, Error>>()?,"," ))"," .transpose()?"," sort_orders: match value.sort_orders {"," Some(sort_orders) => HashMap::from_iter("," sort_orders.into_iter().map(|x| (x.order_id, Arc::new(x))),"," None => HashMap::new(),"," default_sort_order_id: value"," .default_sort_order_id"," .unwrap_or(SortOrder::UNSORTED_ORDER_ID),"," refs: if let Some(snapshot_id) = current_snapshot_id {"," HashMap::from_iter(vec![(MAIN_BRANCH.to_string(), SnapshotReference {"," snapshot_id,"," retention: SnapshotRetention::Branch {"," min_snapshots_to_keep: None,"," max_snapshot_age_ms: None,"," max_ref_age_ms: None,"," },"," })])"," HashMap::new()"," next_row_id: INITIAL_ROW_ID, // v1 has no row lineage"," impl TryFrom for TableMetadataV3 {"," fn try_from(mut v: TableMetadata) -> Result {"," let next_row_id = v.next_row_id;"," let encryption_keys = std::mem::take(&mut v.encryption_keys);"," let snapshots = std::mem::take(&mut v.snapshots);"," let shared = v.into();"," Ok(TableMetadataV3 {"," format_version: VersionNumber::<3>,"," shared,"," encryption_keys: if encryption_keys.is_empty() {"," None"," Some(encryption_keys.into_values().collect())"," snapshots: if snapshots.is_empty() {"," Some("," snapshots"," .into_values()"," .map(|s| SnapshotV3::try_from(Arc::unwrap_or_clone(s)))"," .collect::>()?,"," impl From for TableMetadataV2 {"," fn from(mut v: TableMetadata) -> Self {"," TableMetadataV2 {"," format_version: VersionNumber::<2>,"," .map(|s| SnapshotV2::from(Arc::unwrap_or_clone(s)))"," .collect(),"," impl From for TableMetadataV2V3Shared {"," fn from(v: TableMetadata) -> Self {"," TableMetadataV2V3Shared {"," table_uuid: v.table_uuid,"," location: v.location,"," last_sequence_number: v.last_sequence_number,"," last_updated_ms: v.last_updated_ms,"," last_column_id: v.last_column_id,"," schemas: v"," .into_values()"," .map(|x| {"," Arc::try_unwrap(x)"," .unwrap_or_else(|schema| schema.as_ref().clone())"," .into()"," .collect(),"," current_schema_id: v.current_schema_id,"," partition_specs: v"," .map(|x| Arc::try_unwrap(x).unwrap_or_else(|s| s.as_ref().clone()))"," default_spec_id: v.default_spec.spec_id(),"," last_partition_id: v.last_partition_id,"," properties: if v.properties.is_empty() {"," Some(v.properties)"," current_snapshot_id: v.current_snapshot_id,"," snapshot_log: if v.snapshot_log.is_empty() {"," Some(v.snapshot_log)"," metadata_log: if v.metadata_log.is_empty() {"," Some(v.metadata_log)"," sort_orders: v"," .sort_orders"," default_sort_order_id: v.default_sort_order_id,"," refs: Some(v.refs),"," statistics: v.statistics.into_values().collect(),"," partition_statistics: v.partition_statistics.into_values().collect(),"," impl TryFrom for TableMetadataV1 {"," fn try_from(v: TableMetadata) -> Result {"," Ok(TableMetadataV1 {"," format_version: VersionNumber::<1>,"," table_uuid: Some(v.table_uuid),"," schema: Some("," v.schemas"," .get(&v.current_schema_id)"," .ok_or(Error::new("," ErrorKind::Unexpected,"," \"current_schema_id not found in schemas\","," ))?"," .as_ref()"," .clone()"," .into(),"," schemas: Some("," .into_values()"," .map(|x| {"," Arc::try_unwrap(x)"," .unwrap_or_else(|schema| schema.as_ref().clone())"," .into()"," })"," .collect(),"," current_schema_id: Some(v.current_schema_id),"," partition_spec: Some(v.default_spec.fields().to_vec()),"," partition_specs: Some("," v.partition_specs"," .map(|x| Arc::try_unwrap(x).unwrap_or_else(|s| s.as_ref().clone()))"," default_spec_id: Some(v.default_spec.spec_id()),"," last_partition_id: Some(v.last_partition_id),"," snapshots: if v.snapshots.is_empty() {"," v.snapshots"," .map(|x| Snapshot::clone(&x).into())"," sort_orders: Some("," v.sort_orders"," .map(|s| Arc::try_unwrap(s).unwrap_or_else(|s| s.as_ref().clone()))"," default_sort_order_id: Some(v.default_sort_order_id),"," fn index_statistics(statistics: Vec) -> HashMap {"," statistics"," .rev()"," .map(|s| (s.snapshot_id, s))"," fn index_partition_statistics("," statistics: Vec,"," ) -> HashMap {","#[derive(Debug, Serialize_repr, Deserialize_repr, PartialEq, Eq, Clone, Copy, Hash)]","#[repr(u8)]","/// Iceberg format version","pub enum FormatVersion {"," /// Iceberg spec version 1"," V1 = 1u8,"," /// Iceberg spec version 2"," V2 = 2u8,"," /// Iceberg spec version 3"," V3 = 3u8,","impl PartialOrd for FormatVersion {"," fn partial_cmp(&self, other: &Self) -> Option {"," Some(self.cmp(other))","impl Ord for FormatVersion {"," fn cmp(&self, other: &Self) -> Ordering {"," (*self as u8).cmp(&(*other as u8))","impl Display for FormatVersion {"," fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {"," match self {"," FormatVersion::V1 => write!(f, \"v1\"),"," FormatVersion::V2 => write!(f, \"v2\"),"," FormatVersion::V3 => write!(f, \"v3\"),","#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]","#[serde(rename_all = \"kebab-case\")]","/// Encodes changes to the previous metadata files for the table","pub struct MetadataLog {"," /// The file for the log."," pub metadata_file: String,"," /// Time new metadata was created"," pub timestamp_ms: i64,","/// A log of when each snapshot was made.","pub struct SnapshotLog {"," /// Id of the snapshot."," pub snapshot_id: i64,"," /// Last updated timestamp","impl SnapshotLog {"," /// Returns the last updated timestamp as a DateTime with millisecond precision"," pub fn timestamp(self) -> Result> {"," timestamp_ms_to_utc(self.timestamp_ms)"," /// Returns the timestamp in milliseconds"," pub fn timestamp_ms(&self) -> i64 {"," self.timestamp_ms"," use std::fs;"," use anyhow::Result;"," use base64::Engine as _;"," use pretty_assertions::assert_eq;"," use tempfile::TempDir;"," use super::{FormatVersion, MetadataLog, SnapshotLog, TableMetadataBuilder};"," use crate::catalog::MetadataLocation;"," use crate::compression::CompressionCodec;"," use crate::spec::table_metadata::TableMetadata;"," BlobMetadata, EncryptedKey, INITIAL_ROW_ID, Literal, NestedField, NullOrder, Operation,"," PartitionSpec, PartitionStatisticsFile, PrimitiveLiteral, PrimitiveType, Schema, Snapshot,"," SnapshotReference, SnapshotRetention, SortDirection, SortField, SortOrder, StatisticsFile,"," Summary, TableProperties, Transform, Type, UnboundPartitionField,"," use crate::{ErrorKind, TableCreation};"," fn check_table_metadata_serde(json: &str, expected_type: TableMetadata) {"," let desered_type: TableMetadata = serde_json::from_str(json).unwrap();"," assert_eq!(desered_type, expected_type);"," let sered_json = serde_json::to_string(&expected_type).unwrap();"," let parsed_json_value = serde_json::from_str::(&sered_json).unwrap();"," assert_eq!(parsed_json_value, desered_type);"," fn get_test_table_metadata(file_name: &str) -> TableMetadata {"," let path = format!(\"testdata/table_metadata/{file_name}\");"," let metadata: String = fs::read_to_string(path).unwrap();"," serde_json::from_str(&metadata).unwrap()"," fn test_table_data_v2() {"," let data = r#\""," \"format-version\" : 2,"," \"table-uuid\": \"fb072c92-a02b-11e9-ae9c-1bb7bc9eca94\","," \"location\": \"s3://b/wh/data.db/table\","," \"last-sequence-number\" : 1,"," \"last-updated-ms\": 1515100955770,"," \"last-column-id\": 1,"," \"schemas\": ["," \"schema-id\" : 1,"," \"type\" : \"struct\","," \"fields\" :["," {"," \"id\": 1,"," \"name\": \"struct_name\","," \"required\": true,"," \"type\": \"fixed[1]\""," \"id\": 4,"," \"name\": \"ts\","," \"type\": \"timestamp\""," }"," ]"," ],"," \"current-schema-id\" : 1,"," \"partition-specs\": ["," \"spec-id\": 0,"," \"fields\": ["," \"source-id\": 4,"," \"field-id\": 1000,"," \"name\": \"ts_day\","," \"transform\": \"day\""," \"default-spec-id\": 0,"," \"last-partition-id\": 1000,"," \"properties\": {"," \"commit.retry.num-retries\": \"1\""," \"metadata-log\": ["," \"metadata-file\": \"s3://bucket/.../v1.json\","," \"timestamp-ms\": 1515100"," \"refs\": {},"," \"sort-orders\": ["," \"order-id\": 0,"," \"fields\": []"," \"default-sort-order-id\": 0"," \"#;"," Arc::new(NestedField::required("," 1,"," \"struct_name\","," Type::Primitive(PrimitiveType::Fixed(1)),"," )),"," 4,"," \"ts\","," Type::Primitive(PrimitiveType::Timestamp),"," let partition_spec = PartitionSpec::builder(schema.clone())"," name: \"ts_day\".to_string(),"," transform: Transform::Day,"," source_id: 4,"," let default_partition_type = partition_spec.partition_type(&schema).unwrap();"," let expected = TableMetadata {"," format_version: FormatVersion::V2,"," table_uuid: Uuid::parse_str(\"fb072c92-a02b-11e9-ae9c-1bb7bc9eca94\").unwrap(),"," location: \"s3://b/wh/data.db/table\".to_string(),"," last_updated_ms: 1515100955770,"," last_column_id: 1,"," schemas: HashMap::from_iter(vec![(1, Arc::new(schema))]),"," current_schema_id: 1,"," partition_specs: HashMap::from_iter(vec![(0, partition_spec.clone().into())]),"," default_partition_type,"," default_spec: partition_spec.into(),"," last_partition_id: 1000,"," default_sort_order_id: 0,"," sort_orders: HashMap::from_iter(vec![(0, SortOrder::unsorted_order().into())]),"," snapshots: HashMap::default(),"," current_snapshot_id: None,"," last_sequence_number: 1,"," properties: HashMap::from_iter(vec![("," \"commit.retry.num-retries\".to_string(),"," )]),"," snapshot_log: Vec::new(),"," metadata_log: vec![MetadataLog {"," metadata_file: \"s3://bucket/.../v1.json\".to_string(),"," timestamp_ms: 1515100,"," refs: HashMap::new(),"," statistics: HashMap::new(),"," partition_statistics: HashMap::new(),"," encryption_keys: HashMap::new(),"," next_row_id: INITIAL_ROW_ID,"," let expected_json_value = serde_json::to_value(&expected).unwrap();"," check_table_metadata_serde(data, expected);"," let json_value = serde_json::from_str::(data).unwrap();"," assert_eq!(json_value, expected_json_value);"," fn test_table_data_v3() {"," \"format-version\" : 3,"," \"next-row-id\": 5,"," \"snapshots\" : [ {"," \"snapshot-id\" : 1,"," \"timestamp-ms\" : 1662532818843,"," \"sequence-number\" : 0,"," \"first-row-id\" : 0,"," \"added-rows\" : 4,"," \"key-id\" : \"key1\","," \"summary\" : {"," \"operation\" : \"append\""," \"manifest-list\" : \"/home/iceberg/warehouse/nyc/taxis/metadata/snap-638933773299822130-1-7e6760f0-4f6c-4b23-b907-0a5a174e3863.avro\","," \"schema-id\" : 0"," \"encryption-keys\": ["," \"key-id\": \"key1\","," \"encrypted-by-id\": \"KMS\","," \"encrypted-key-metadata\": \"c29tZS1lbmNyeXB0aW9uLWtleQ==\","," \"properties\": {"," \"p1\": \"v1\""," }"," .with_fields(vec![Arc::new(NestedField::required("," 4,"," \"ts\","," Type::Primitive(PrimitiveType::Timestamp),"," ))])"," .with_timestamp_ms(1662532818843)"," .with_row_range(0, 4)"," .with_encryption_key_id(Some(\"key1\".to_string()))"," .with_manifest_list(\"/home/iceberg/warehouse/nyc/taxis/metadata/snap-638933773299822130-1-7e6760f0-4f6c-4b23-b907-0a5a174e3863.avro\".to_string())"," let encryption_key = EncryptedKey::builder()"," .key_id(\"key1\".to_string())"," .encrypted_by_id(\"KMS\".to_string())"," .encrypted_key_metadata("," base64::prelude::BASE64_STANDARD"," .decode(\"c29tZS1lbmNyeXB0aW9uLWtleQ==\")"," .unwrap(),"," \"p1\".to_string(),"," \"v1\".to_string(),"," format_version: FormatVersion::V3,"," snapshots: HashMap::from_iter(vec![(1, snapshot.into())]),"," encryption_keys: HashMap::from_iter(vec![(\"key1\".to_string(), encryption_key)]),"," next_row_id: 5,"," fn test_table_data_v1() {"," \"format-version\" : 1,"," \"table-uuid\" : \"df838b92-0b32-465d-a44e-d39936e538b7\","," \"location\" : \"/home/iceberg/warehouse/nyc/taxis\","," \"last-updated-ms\" : 1662532818843,"," \"last-column-id\" : 5,"," \"schema\" : {"," \"type\" : \"struct\","," \"schema-id\" : 0,"," \"fields\" : [ {"," \"id\" : 1,"," \"name\" : \"vendor_id\","," \"required\" : false,"," \"type\" : \"long\""," }, {"," \"id\" : 2,"," \"name\" : \"trip_id\","," \"id\" : 3,"," \"name\" : \"trip_distance\","," \"type\" : \"float\""," \"id\" : 4,"," \"name\" : \"fare_amount\","," \"type\" : \"double\""," \"id\" : 5,"," \"name\" : \"store_and_fwd_flag\","," \"type\" : \"string\""," } ]"," \"partition-spec\" : [ {"," \"name\" : \"vendor_id\","," \"transform\" : \"identity\","," \"source-id\" : 1,"," \"field-id\" : 1000"," } ],"," \"last-partition-id\" : 1000,"," \"default-sort-order-id\" : 0,"," \"sort-orders\" : [ {"," \"order-id\" : 0,"," \"fields\" : [ ]"," \"properties\" : {"," \"owner\" : \"root\""," \"current-snapshot-id\" : 638933773299822130,"," \"refs\" : {"," \"main\" : {"," \"snapshot-id\" : 638933773299822130,"," \"type\" : \"branch\""," }"," \"snapshots\" : [ {"," \"snapshot-id\" : 638933773299822130,"," \"timestamp-ms\" : 1662532818843,"," \"sequence-number\" : 0,"," \"summary\" : {"," \"operation\" : \"append\","," \"spark.app.id\" : \"local-1662532784305\","," \"added-data-files\" : \"4\","," \"added-records\" : \"4\","," \"added-files-size\" : \"6001\""," },"," \"manifest-list\" : \"/home/iceberg/warehouse/nyc/taxis/metadata/snap-638933773299822130-1-7e6760f0-4f6c-4b23-b907-0a5a174e3863.avro\","," \"schema-id\" : 0"," \"snapshot-log\" : [ {"," \"snapshot-id\" : 638933773299822130"," \"metadata-log\" : [ {"," \"timestamp-ms\" : 1662532805245,"," \"metadata-file\" : \"/home/iceberg/warehouse/nyc/taxis/metadata/00000-8a62c37d-4573-4021-952a-c0baef7d21d0.metadata.json\""," } ]"," }"," Arc::new(NestedField::optional("," \"vendor_id\","," Type::Primitive(PrimitiveType::Long),"," 2,"," \"trip_id\","," \"trip_distance\","," Type::Primitive(PrimitiveType::Float),"," \"fare_amount\","," Type::Primitive(PrimitiveType::Double),"," 5,"," \"store_and_fwd_flag\","," Type::Primitive(PrimitiveType::String),"," let schema = Arc::new(schema);"," .add_partition_field(\"vendor_id\", \"vendor_id\", Transform::Identity)"," .with_order_id(0)"," .build_unbound()"," .with_snapshot_id(638933773299822130)"," .with_manifest_list(\"/home/iceberg/warehouse/nyc/taxis/metadata/snap-638933773299822130-1-7e6760f0-4f6c-4b23-b907-0a5a174e3863.avro\")"," .with_summary(Summary { operation: Operation::Append, additional_properties: HashMap::from_iter(vec![(\"spark.app.id\".to_string(), \"local-1662532784305\".to_string()), (\"added-data-files\".to_string(), \"4\".to_string()), (\"added-records\".to_string(), \"4\".to_string()), (\"added-files-size\".to_string(), \"6001\".to_string())]) })"," format_version: FormatVersion::V1,"," table_uuid: Uuid::parse_str(\"df838b92-0b32-465d-a44e-d39936e538b7\").unwrap(),"," location: \"/home/iceberg/warehouse/nyc/taxis\".to_string(),"," last_updated_ms: 1662532818843,"," last_column_id: 5,"," schemas: HashMap::from_iter(vec![(0, schema)]),"," current_schema_id: 0,"," default_spec: Arc::new(partition_spec),"," sort_orders: HashMap::from_iter(vec![(0, sort_order.into())]),"," snapshots: HashMap::from_iter(vec![(638933773299822130, Arc::new(snapshot))]),"," current_snapshot_id: Some(638933773299822130),"," last_sequence_number: 0,"," properties: HashMap::from_iter(vec![(\"owner\".to_string(), \"root\".to_string())]),"," snapshot_log: vec![SnapshotLog {"," snapshot_id: 638933773299822130,"," timestamp_ms: 1662532818843,"," metadata_log: vec![MetadataLog { metadata_file: \"/home/iceberg/warehouse/nyc/taxis/metadata/00000-8a62c37d-4573-4021-952a-c0baef7d21d0.metadata.json\".to_string(), timestamp_ms: 1662532805245 }],"," refs: HashMap::from_iter(vec![(\"main\".to_string(), SnapshotReference { snapshot_id: 638933773299822130, retention: SnapshotRetention::Branch { min_snapshots_to_keep: None, max_snapshot_age_ms: None, max_ref_age_ms: None } })]),"," fn test_table_data_v2_no_snapshots() {"," \"format-version\" : 2,"," \"table-uuid\": \"fb072c92-a02b-11e9-ae9c-1bb7bc9eca94\","," \"location\": \"s3://b/wh/data.db/table\","," \"last-sequence-number\" : 1,"," \"last-updated-ms\": 1515100955770,"," \"last-column-id\": 1,"," \"schemas\": ["," \"schema-id\" : 1,"," \"type\" : \"struct\","," \"fields\" :["," {"," \"id\": 1,"," \"name\": \"struct_name\","," \"required\": true,"," \"type\": \"fixed[1]\""," ]"," ],"," \"current-schema-id\" : 1,"," \"partition-specs\": ["," \"spec-id\": 0,"," \"refs\": {},"," \"default-spec-id\": 0,"," \"last-partition-id\": 1000,"," \"metadata-log\": ["," \"metadata-file\": \"s3://bucket/.../v1.json\","," \"timestamp-ms\": 1515100"," \"sort-orders\": ["," \"order-id\": 0,"," \"fields\": []"," \"default-sort-order-id\": 0"," 1,"," \"struct_name\","," Type::Primitive(PrimitiveType::Fixed(1)),"," properties: HashMap::new(),"," fn test_current_snapshot_id_must_match_main_branch() {"," \"id\": 4,"," \"name\": \"ts\","," \"type\": \"timestamp\""," \"fields\": ["," \"source-id\": 4,"," \"field-id\": 1000,"," \"name\": \"ts_day\","," \"transform\": \"day\""," \"properties\": {"," \"commit.retry.num-retries\": \"1\""," \"default-sort-order-id\": 0,"," \"current-snapshot-id\" : 1,"," \"snapshot-id\" : 2,"," \"snapshot-id\" : 1,"," \"snapshot-id\" : 2,"," \"timestamp-ms\" : 1662532818844,"," \"#;"," let err = serde_json::from_str::(data).unwrap_err();"," .contains(\"Current snapshot id does not match main branch\")"," fn test_main_without_current() {"," \"snapshot-id\" : 1,"," .contains(\"Current snapshot is not set, but main branch exists\")"," fn test_branch_snapshot_missing() {"," \"foo\" : {"," \"Snapshot for reference foo does not exist in the existing snapshots list\""," fn test_v2_wrong_max_snapshot_sequence_number() {"," \"format-version\": 2,"," \"table-uuid\": \"9c12d441-03fe-4693-9a96-a0705ddf69c1\","," \"location\": \"s3://bucket/test/location\","," \"last-sequence-number\": 1,"," \"last-updated-ms\": 1602638573590,"," \"last-column-id\": 3,"," \"current-schema-id\": 0,"," \"type\": \"struct\","," \"schema-id\": 0,"," \"name\": \"x\","," \"type\": \"long\""," \"properties\": {},"," \"current-snapshot-id\": 3055729675574597004,"," \"snapshots\": ["," \"snapshot-id\": 3055729675574597004,"," \"timestamp-ms\": 1555100955770,"," \"sequence-number\": 4,"," \"summary\": {"," \"operation\": \"append\""," \"manifest-list\": \"s3://a/b/2.avro\","," \"schema-id\": 0"," \"statistics\": [],"," \"snapshot-log\": [],"," \"metadata-log\": []"," \"Invalid snapshot with id 3055729675574597004 and sequence number 4 greater than last sequence number 1\""," // Change max sequence number to 4 - should work"," let data = data.replace("," r#\"\"last-sequence-number\": 1,\"#,"," r#\"\"last-sequence-number\": 4,\"#,"," let metadata = serde_json::from_str::(data.as_str()).unwrap();"," assert_eq!(metadata.last_sequence_number, 4);"," // Change max sequence number to 5 - should work"," r#\"\"last-sequence-number\": 5,\"#,"," assert_eq!(metadata.last_sequence_number, 5);"," fn test_statistic_files() {"," \"last-sequence-number\": 34,"," \"sequence-number\": 1,"," \"statistics\": ["," \"statistics-path\": \"s3://a/b/stats.puffin\","," \"file-size-in-bytes\": 413,"," \"file-footer-size-in-bytes\": 42,"," \"blob-metadata\": ["," \"type\": \"ndv\","," \"snapshot-id\": 3055729675574597004,"," \"sequence-number\": 1,"," \"fields\": ["," 1"," ]"," \"x\","," Type::Primitive(PrimitiveType::Long),"," .with_snapshot_id(3055729675574597004)"," .with_timestamp_ms(1555100955770)"," .with_manifest_list(\"s3://a/b/2.avro\")"," table_uuid: Uuid::parse_str(\"9c12d441-03fe-4693-9a96-a0705ddf69c1\").unwrap(),"," location: \"s3://bucket/test/location\".to_string(),"," last_updated_ms: 1602638573590,"," last_column_id: 3,"," schemas: HashMap::from_iter(vec![(0, Arc::new(schema))]),"," snapshots: HashMap::from_iter(vec![(3055729675574597004, Arc::new(snapshot))]),"," current_snapshot_id: Some(3055729675574597004),"," last_sequence_number: 34,"," metadata_log: Vec::new(),"," statistics: HashMap::from_iter(vec![(3055729675574597004, StatisticsFile {"," statistics_path: \"s3://a/b/stats.puffin\".to_string(),"," file_size_in_bytes: 413,"," file_footer_size_in_bytes: 42,"," key_metadata: None,"," blob_metadata: vec![BlobMetadata {"," snapshot_id: 3055729675574597004,"," sequence_number: 1,"," fields: vec![1],"," r#type: \"ndv\".to_string(),"," properties: HashMap::new(),"," }],"," })]),"," refs: HashMap::from_iter(vec![(\"main\".to_string(), SnapshotReference {"," fn test_partition_statistics_file() {"," \"partition-statistics\": ["," \"statistics-path\": \"s3://a/b/partition-stats.parquet\","," \"file-size-in-bytes\": 43"," partition_statistics: HashMap::from_iter(vec![("," 3055729675574597004,"," PartitionStatisticsFile {"," statistics_path: \"s3://a/b/partition-stats.parquet\".to_string(),"," file_size_in_bytes: 43,"," fn test_invalid_table_uuid() -> Result<()> {"," \"table-uuid\": \"xxxx\""," assert!(serde_json::from_str::(data).is_err());"," fn test_deserialize_table_data_v2_invalid_format_version() -> Result<()> {"," \"format-version\" : 1"," fn test_table_metadata_v3_valid_minimal() {"," let metadata_str ="," fs::read_to_string(\"testdata/table_metadata/TableMetadataV3ValidMinimal.json\").unwrap();"," let table_metadata = serde_json::from_str::(&metadata_str).unwrap();"," assert_eq!(table_metadata.format_version, FormatVersion::V3);"," Arc::new("," NestedField::required(1, \"x\", Type::Primitive(PrimitiveType::Long))"," .with_initial_default(Literal::Primitive(PrimitiveLiteral::Long(1)))"," .with_write_default(Literal::Primitive(PrimitiveLiteral::Long(1))),"," NestedField::required(2, \"y\", Type::Primitive(PrimitiveType::Long))"," .with_doc(\"comment\"),"," \"z\","," name: \"x\".to_string(),"," .with_order_id(3)"," null_order: NullOrder::Last,"," default_sort_order_id: 3,"," sort_orders: HashMap::from_iter(vec![(3, sort_order.into())]),"," next_row_id: 0, // V3 specific field from the JSON"," check_table_metadata_serde(&metadata_str, expected);"," fn test_table_metadata_v2_file_valid() {"," let metadata ="," fs::read_to_string(\"testdata/table_metadata/TableMetadataV2Valid.json\").unwrap();"," let schema1 = Schema::builder()"," let schema2 = Schema::builder()"," \"x\","," .with_identifier_field_ids(vec![1, 2])"," let partition_spec = PartitionSpec::builder(schema2.clone())"," let snapshot1 = Snapshot::builder()"," .with_snapshot_id(3051729675574597004)"," .with_timestamp_ms(1515100955770)"," .with_manifest_list(\"s3://a/b/1.avro\")"," let snapshot2 = Snapshot::builder()"," .with_parent_snapshot_id(Some(3051729675574597004))"," let default_partition_type = partition_spec.partition_type(&schema2).unwrap();"," schemas: HashMap::from_iter(vec![(0, Arc::new(schema1)), (1, Arc::new(schema2))]),"," snapshots: HashMap::from_iter(vec!["," (3051729675574597004, Arc::new(snapshot1)),"," (3055729675574597004, Arc::new(snapshot2)),"," ]),"," snapshot_log: vec!["," SnapshotLog {"," snapshot_id: 3051729675574597004,"," timestamp_ms: 1515100955770,"," timestamp_ms: 1555100955770,"," check_table_metadata_serde(&metadata, expected);"," fn test_table_metadata_v2_file_valid_minimal() {"," fs::read_to_string(\"testdata/table_metadata/TableMetadataV2ValidMinimal.json\").unwrap();"," snapshot_log: vec![],"," fn test_table_metadata_v1_file_valid() {"," fs::read_to_string(\"testdata/table_metadata/TableMetadataV1Valid.json\").unwrap();"," table_uuid: Uuid::parse_str(\"d20125c8-7284-442c-9aea-15fee620737c\").unwrap(),"," last_updated_ms: 1602638573874,"," last_partition_id: 0,"," // Sort order is added during deserialization for V2 compatibility"," snapshots: HashMap::new(),"," fn test_empty_snapshot_id_is_normalized_to_none() {"," let deserialized: TableMetadata = serde_json::from_str(&metadata).unwrap();"," deserialized.current_snapshot_id(),"," None,"," \"current_snapshot_id of -1 should be deserialized as None\""," fn test_table_metadata_v1_compat() {"," fs::read_to_string(\"testdata/table_metadata/TableMetadataV1Compat.json\").unwrap();"," // Deserialize the JSON to verify it works"," let desered_type: TableMetadata = serde_json::from_str(&metadata)"," .expect(\"Failed to deserialize TableMetadataV1Compat.json\");"," // Verify some key fields match"," assert_eq!(desered_type.format_version(), FormatVersion::V1);"," desered_type.uuid(),"," Uuid::parse_str(\"3276010d-7b1d-488c-98d8-9025fc4fde6b\").unwrap()"," desered_type.location(),"," \"s3://bucket/warehouse/iceberg/glue.db/table_name\""," assert_eq!(desered_type.last_updated_ms(), 1727773114005);"," assert_eq!(desered_type.current_schema_id(), 0);"," fn test_table_metadata_v1_schemas_without_current_id() {"," let metadata = fs::read_to_string("," \"testdata/table_metadata/TableMetadataV1SchemasWithoutCurrentId.json\","," // Deserialize the JSON - this should succeed by using the 'schema' field instead of 'schemas'"," .expect(\"Failed to deserialize TableMetadataV1SchemasWithoutCurrentId.json\");"," // Verify it used the 'schema' field"," Uuid::parse_str(\"d20125c8-7284-442c-9aea-15fee620737c\").unwrap()"," // Get the schema and verify it has the expected fields"," let schema = desered_type.current_schema();"," assert_eq!(schema.as_struct().fields().len(), 3);"," assert_eq!(schema.as_struct().fields()[0].name, \"x\");"," assert_eq!(schema.as_struct().fields()[1].name, \"y\");"," assert_eq!(schema.as_struct().fields()[2].name, \"z\");"," fn test_table_metadata_v1_no_valid_schema() {"," fs::read_to_string(\"testdata/table_metadata/TableMetadataV1NoValidSchema.json\")"," .unwrap();"," // Deserialize the JSON - this should fail because neither schemas + current_schema_id nor schema is valid"," let desered: Result = serde_json::from_str(&metadata);"," assert!(desered.is_err());"," let error_message = desered.unwrap_err().to_string();"," error_message.contains(\"No valid schema configuration found\"),"," \"Expected error about no valid schema configuration, got: {error_message}\""," fn test_table_metadata_v1_partition_specs_without_default_id() {"," \"testdata/table_metadata/TableMetadataV1PartitionSpecsWithoutDefaultId.json\","," // Deserialize the JSON - this should succeed by inferring default_spec_id as the max spec ID"," .expect(\"Failed to deserialize TableMetadataV1PartitionSpecsWithoutDefaultId.json\");"," // Verify basic metadata"," // Verify partition specs"," assert_eq!(desered_type.default_partition_spec_id(), 2); // Should pick the largest spec ID (2)"," assert_eq!(desered_type.partition_specs.len(), 2);"," // Verify the default spec has the expected fields"," let default_spec = &desered_type.default_spec;"," assert_eq!(default_spec.spec_id(), 2);"," assert_eq!(default_spec.fields().len(), 1);"," assert_eq!(default_spec.fields()[0].name, \"y\");"," assert_eq!(default_spec.fields()[0].transform, Transform::Identity);"," assert_eq!(default_spec.fields()[0].source_id, 2);"," fn test_table_metadata_v2_schema_not_found() {"," fs::read_to_string(\"testdata/table_metadata/TableMetadataV2CurrentSchemaNotFound.json\")"," desered.unwrap_err().to_string(),"," \"DataInvalid => No schema exists with the current schema id 2.\""," fn test_table_metadata_v2_missing_sort_order() {"," fs::read_to_string(\"testdata/table_metadata/TableMetadataV2MissingSortOrder.json\")"," \"data did not match any variant of untagged enum TableMetadataEnum\""," fn test_table_metadata_v2_missing_partition_specs() {"," fs::read_to_string(\"testdata/table_metadata/TableMetadataV2MissingPartitionSpecs.json\")"," fn test_table_metadata_v2_missing_last_partition_id() {"," \"testdata/table_metadata/TableMetadataV2MissingLastPartitionId.json\","," fn test_table_metadata_v2_missing_schemas() {"," fs::read_to_string(\"testdata/table_metadata/TableMetadataV2MissingSchemas.json\")"," fn test_table_metadata_v2_unsupported_version() {"," fs::read_to_string(\"testdata/table_metadata/TableMetadataUnsupportedVersion.json\")"," fn test_order_of_format_version() {"," assert!(FormatVersion::V1 < FormatVersion::V2);"," assert_eq!(FormatVersion::V1, FormatVersion::V1);"," assert_eq!(FormatVersion::V2, FormatVersion::V2);"," fn test_default_partition_spec() {"," let default_spec_id = 1234;"," let mut table_meta_data = get_test_table_metadata(\"TableMetadataV2Valid.json\");"," let partition_spec = PartitionSpec::unpartition_spec();"," table_meta_data.default_spec = partition_spec.clone().into();"," table_meta_data"," .insert(default_spec_id, Arc::new(partition_spec));"," (*table_meta_data.default_partition_spec().clone()).clone(),"," (*table_meta_data"," .partition_spec_by_id(default_spec_id)"," .unwrap()"," .clone())"," fn test_default_sort_order() {"," let default_sort_order_id = 1234;"," table_meta_data.default_sort_order_id = default_sort_order_id;"," .insert(default_sort_order_id, Arc::new(SortOrder::default()));"," table_meta_data.default_sort_order(),"," table_meta_data"," .sort_orders"," .get(&default_sort_order_id)"," fn test_table_metadata_builder_from_table_creation() {"," let table_creation = TableCreation::builder()"," .location(\"s3://db/table\".to_string())"," .name(\"table\".to_string())"," .schema(Schema::builder().build().unwrap())"," let table_metadata = TableMetadataBuilder::from_table_creation(table_creation)"," assert_eq!(table_metadata.location, \"s3://db/table\");"," assert_eq!(table_metadata.schemas.len(), 1);"," table_metadata"," .get(&0)"," .as_struct()"," .fields()"," .len(),"," 0"," assert_eq!(table_metadata.properties.len(), 0);"," table_metadata.partition_specs,"," HashMap::from([("," 0,"," PartitionSpec::builder(table_metadata.schemas.get(&0).unwrap().clone())"," .with_spec_id(0)"," .build()"," .unwrap()"," )])"," table_metadata.sort_orders,"," Arc::new(SortOrder {"," order_id: 0,"," fields: vec![]"," #[tokio::test]"," async fn test_table_metadata_read_write() {"," // Create a temporary directory for our test"," let temp_dir = TempDir::new().unwrap();"," let temp_path = temp_dir.path().to_str().unwrap();"," // Create a FileIO instance"," let file_io = FileIO::new_with_fs();"," // Use an existing test metadata from the test files"," let original_metadata: TableMetadata = get_test_table_metadata(\"TableMetadataV2Valid.json\");"," // Define the metadata location"," let metadata_location = MetadataLocation::new_with_metadata(temp_path, &original_metadata);"," let metadata_location_str = metadata_location.to_string();"," // Write the metadata"," original_metadata"," .write_to(&file_io, &metadata_location)"," // Verify the file exists"," assert!(fs::metadata(&metadata_location_str).is_ok());"," // Read the metadata back"," let read_metadata = TableMetadata::read_from(&file_io, &metadata_location_str)"," // Verify the metadata matches"," assert_eq!(read_metadata, original_metadata);"," async fn test_table_metadata_read_compressed() {"," let metadata_location = temp_dir.path().join(\"v1.gz.metadata.json\");"," let json = serde_json::to_string(&original_metadata).unwrap();"," let compressed = CompressionCodec::gzip_default()"," .compress(json.into_bytes())"," .expect(\"failed to compress metadata\");"," std::fs::write(&metadata_location, &compressed).expect(\"failed to write metadata\");"," let metadata_location = metadata_location.to_str().unwrap();"," let read_metadata = TableMetadata::read_from(&file_io, metadata_location)"," async fn test_table_metadata_read_nonexistent_file() {"," // Try to read a non-existent file"," let result = TableMetadata::read_from(&file_io, \"/nonexistent/path/metadata.json\").await;"," // Verify it returns an error"," async fn test_table_metadata_write_with_gzip_compression() {"," // Get a test metadata and add gzip compression property"," // Modify properties to enable gzip compression (using mixed case to test case-insensitive matching)"," let mut props = original_metadata.properties.clone();"," props.insert("," TableProperties::PROPERTY_METADATA_COMPRESSION_CODEC.to_string(),"," \"GziP\".to_string(),"," // Use builder to create new metadata with updated properties"," let compressed_metadata ="," TableMetadataBuilder::new_from_metadata(original_metadata.clone(), None)"," .assign_uuid(original_metadata.table_uuid)"," .set_properties(props.clone())"," .build()"," .metadata;"," // Create MetadataLocation with compression codec from metadata"," let metadata_location ="," MetadataLocation::new_with_metadata(temp_path, &compressed_metadata);"," // Verify the location has the .gz extension"," assert!(metadata_location_str.contains(\".gz.metadata.json\"));"," // Write the metadata with compression"," compressed_metadata"," // Verify the compressed file exists"," assert!(std::path::Path::new(&metadata_location_str).exists());"," // Read the raw file and check it's gzip compressed"," let raw_content = std::fs::read(&metadata_location_str).unwrap();"," assert!(raw_content.len() > 2);"," assert_eq!(raw_content[0], 0x1F); // gzip magic number"," assert_eq!(raw_content[1], 0x8B); // gzip magic number"," // Read the metadata back using the compressed location"," // Verify the complete round-trip: read metadata should match what we wrote"," assert_eq!(read_metadata, compressed_metadata);"," fn test_partition_name_exists() {"," NestedField::required(2, \"partition_col\", Type::Primitive(PrimitiveType::Int))"," let spec1 = PartitionSpec::builder(schema.clone())"," .add_partition_field(\"data\", \"data_partition\", Transform::Identity)"," let spec2 = PartitionSpec::builder(schema.clone())"," .with_spec_id(2)"," .add_partition_field(\"partition_col\", \"partition_bucket\", Transform::Bucket(16))"," // Build metadata with these specs"," spec1.clone().into_unbound(),"," \"s3://test/location\".to_string(),"," .add_partition_spec(spec2.into_unbound())"," assert!(metadata.partition_name_exists(\"data_partition\"));"," assert!(metadata.partition_name_exists(\"partition_bucket\"));"," assert!(!metadata.partition_name_exists(\"nonexistent_field\"));"," assert!(!metadata.partition_name_exists(\"data\")); // schema field name, not partition field name"," assert!(!metadata.partition_name_exists(\"\"));"," fn test_partition_name_exists_empty_specs() {"," // Create metadata with no partition specs (unpartitioned table)"," assert!(!metadata.partition_name_exists(\"any_field\"));"," assert!(!metadata.partition_name_exists(\"data\"));"," fn test_name_exists_in_any_schema() {"," // Create multiple schemas with different fields"," NestedField::required(1, \"field1\", Type::Primitive(PrimitiveType::String)).into(),"," NestedField::required(2, \"field2\", Type::Primitive(PrimitiveType::Int)).into(),"," .with_schema_id(2)"," NestedField::required(3, \"field3\", Type::Primitive(PrimitiveType::Long)).into(),"," schema1,"," .add_current_schema(schema2)"," assert!(metadata.name_exists_in_any_schema(\"field1\")); // exists in both schemas"," assert!(metadata.name_exists_in_any_schema(\"field2\")); // exists only in schema1 (historical)"," assert!(metadata.name_exists_in_any_schema(\"field3\")); // exists only in schema2 (current)"," assert!(!metadata.name_exists_in_any_schema(\"nonexistent_field\"));"," assert!(!metadata.name_exists_in_any_schema(\"field4\"));"," assert!(!metadata.name_exists_in_any_schema(\"\"));"," fn test_name_exists_in_any_schema_empty_schemas() {"," let schema = Schema::builder().with_fields(vec![]).build().unwrap();"," assert!(!metadata.name_exists_in_any_schema(\"any_field\"));"," fn test_helper_methods_multi_version_scenario() {"," // Test a realistic multi-version scenario"," NestedField::required(2, \"name\", Type::Primitive(PrimitiveType::String)).into(),"," \"deprecated_field\","," NestedField::required(4, \"new_field\", Type::Primitive(PrimitiveType::Double))"," // Then add a third schema that removes the deprecated field"," let _final_schema = Schema::builder()"," NestedField::required(5, \"latest_field\", Type::Primitive(PrimitiveType::Boolean))"," let final_metadata = metadata"," .add_current_schema(evolved_schema)"," assert!(!final_metadata.partition_name_exists(\"nonexistent_partition\")); // unpartitioned table"," assert!(final_metadata.name_exists_in_any_schema(\"id\")); // exists in both schemas"," assert!(final_metadata.name_exists_in_any_schema(\"name\")); // exists in both schemas"," assert!(final_metadata.name_exists_in_any_schema(\"deprecated_field\")); // exists in both schemas"," assert!(final_metadata.name_exists_in_any_schema(\"new_field\")); // only in current schema"," assert!(!final_metadata.name_exists_in_any_schema(\"never_existed\"));"," fn test_invalid_sort_order_id_zero_with_fields() {"," let metadata = r#\""," \"last-sequence-number\": 111,"," \"last-updated-ms\": 1600000000000,"," \"current-schema-id\": 1,"," \"schema-id\": 1,"," {\"id\": 1, \"name\": \"x\", \"required\": true, \"type\": \"long\"},"," {\"id\": 2, \"name\": \"y\", \"required\": true, \"type\": \"long\"}"," \"partition-specs\": [{\"spec-id\": 0, \"fields\": []}],"," \"last-partition-id\": 999,"," \"transform\": \"identity\","," \"source-id\": 1,"," \"direction\": \"asc\","," \"null-order\": \"nulls-first\""," \"current-snapshot-id\": -1,"," \"snapshots\": []"," let result: Result = serde_json::from_str(metadata);"," // Should fail because sort order ID 0 is reserved for unsorted order and cannot have fields"," result.is_err(),"," \"Parsing should fail for sort order ID 0 with fields\""," fn test_table_properties_with_defaults() {"," use crate::spec::TableProperties;"," let props = metadata.table_properties().unwrap();"," props.commit_num_retries,"," TableProperties::PROPERTY_COMMIT_NUM_RETRIES_DEFAULT"," props.write_target_file_size_bytes,"," TableProperties::PROPERTY_WRITE_TARGET_FILE_SIZE_BYTES_DEFAULT"," fn test_table_properties_with_custom_values() {"," let properties = HashMap::from(["," ("," TableProperties::PROPERTY_COMMIT_NUM_RETRIES.to_string(),"," \"10\".to_string(),"," ),"," TableProperties::PROPERTY_WRITE_TARGET_FILE_SIZE_BYTES.to_string(),"," \"1024\".to_string(),"," assert_eq!(props.commit_num_retries, 10);"," assert_eq!(props.write_target_file_size_bytes, 1024);"," fn test_table_properties_with_invalid_value() {"," let properties = HashMap::from([("," \"commit.retry.num-retries\".to_string(),"," \"not_a_number\".to_string(),"," )]);"," let err = metadata.table_properties().unwrap_err();"," assert_eq!(err.kind(), ErrorKind::DataInvalid);"," assert!(err.message().contains(\"Invalid table properties\"));"," fn test_v2_to_v3_upgrade_preserves_existing_snapshots_without_row_lineage() {"," // Create a v2 table metadata"," let v2_metadata = TableMetadataBuilder::new("," \"s3://bucket/test/location\".to_string(),"," // Add a v2 snapshot"," .with_timestamp_ms(v2_metadata.last_updated_ms + 1)"," .with_manifest_list(\"s3://bucket/test/metadata/snap-1.avro\")"," additional_properties: HashMap::from([("," \"added-data-files\".to_string(),"," \"1\".to_string(),"," let v2_with_snapshot = v2_metadata"," .into_builder(Some(\"s3://bucket/test/metadata/v00001.json\".to_string()))"," .add_snapshot(snapshot)"," .set_ref(\"main\", SnapshotReference {"," // Verify v2 serialization works fine"," let v2_json = serde_json::to_string(&v2_with_snapshot);"," assert!(v2_json.is_ok(), \"v2 serialization should work\");"," // Upgrade to v3"," let v3_metadata = v2_with_snapshot"," .into_builder(Some(\"s3://bucket/test/metadata/v00002.json\".to_string()))"," .upgrade_format_version(FormatVersion::V3)"," assert_eq!(v3_metadata.format_version, FormatVersion::V3);"," assert_eq!(v3_metadata.next_row_id, INITIAL_ROW_ID);"," assert_eq!(v3_metadata.snapshots.len(), 1);"," // Verify the snapshot has no row_range"," let snapshot = v3_metadata.snapshots.values().next().unwrap();"," snapshot.row_range().is_none(),"," \"Snapshot should have no row_range after upgrade\""," // Try to serialize v3 metadata - this should now work"," let v3_json = serde_json::to_string(&v3_metadata);"," v3_json.is_ok(),"," \"v3 serialization should work for upgraded tables\""," // Verify we can deserialize it back"," let deserialized: TableMetadata = serde_json::from_str(&v3_json.unwrap()).unwrap();"," assert_eq!(deserialized.format_version, FormatVersion::V3);"," assert_eq!(deserialized.snapshots.len(), 1);"," // Verify the deserialized snapshot still has no row_range"," let deserialized_snapshot = deserialized.snapshots.values().next().unwrap();"," deserialized_snapshot.row_range().is_none(),"," \"Deserialized snapshot should have no row_range\""," fn test_v3_snapshot_with_row_lineage_serialization() {"," // Create a v3 table metadata"," // Add a v3 snapshot with row lineage"," .with_timestamp_ms(v3_metadata.last_updated_ms + 1)"," .with_row_range(100, 50) // first_row_id=100, added_rows=50"," let v3_with_snapshot = v3_metadata"," // Verify the snapshot has row_range"," let snapshot = v3_with_snapshot.snapshots.values().next().unwrap();"," snapshot.row_range().is_some(),"," \"Snapshot should have row_range\""," let (first_row_id, added_rows) = snapshot.row_range().unwrap();"," assert_eq!(first_row_id, 100);"," assert_eq!(added_rows, 50);"," // Serialize v3 metadata - this should work"," let v3_json = serde_json::to_string(&v3_with_snapshot);"," \"v3 serialization should work for snapshots with row lineage\""," // Verify the deserialized snapshot has the correct row_range"," deserialized_snapshot.row_range().is_some(),"," \"Deserialized snapshot should have row_range\""," let (deserialized_first_row_id, deserialized_added_rows) ="," deserialized_snapshot.row_range().unwrap();"," assert_eq!(deserialized_first_row_id, 100);"," assert_eq!(deserialized_added_rows, 50);","crates/iceberg/src/spec/schema/mod.rs",[3699],{"_419":420,"_421":3700,"_292":3701,"_424":62},1392,[425,426,427,428,429,430,431,432,433,432,434,435,436,437,438,439,166,3702,166,440,2048,441,166,3703,3704,3705,3706,3707,3708,3709,3710,3711,2052,166,3712,3713,3714,3715,3716,3717,3718,3719,3720,3721,449,3722,166,3723,3724,3725,3726,3727,3728,166,3729,3730,3731,3732,3733,3734,3735,3736,166,3737,3738,166,3739,3740,3741,166,3742,475,166,3743,3744,3745,3746,3747,551,475,166,3748,166,3749,3750,3751,3752,3753,3737,3736,3754,475,166,3755,3756,3757,3758,600,551,166,3759,3760,489,3761,3762,3763,600,551,166,3764,3765,3766,600,551,166,3767,3768,3769,600,551,166,3770,3771,3772,600,551,166,3773,3774,3775,3776,570,166,3777,166,3778,3779,166,3780,3781,3782,3783,3784,166,3785,3786,3787,3788,544,166,3789,653,3790,983,166,3791,166,3792,3793,3794,3795,3796,3797,3798,166,3799,3800,3801,166,3802,544,166,3803,3804,3805,3806,3807,3808,166,3809,3810,3811,3812,3813,3814,570,166,3815,551,166,3816,3817,3818,3819,3820,3821,3822,3823,3819,3824,3825,3822,3823,624,3826,3827,3828,616,624,3829,3830,624,3831,3832,3833,624,3834,570,166,904,551,166,3835,3836,166,3837,3838,3839,3840,3841,3842,616,166,3843,3844,3845,3846,3847,1191,616,3848,3849,616,624,570,166,3850,551,166,3851,3852,3853,3838,3839,3854,3855,616,3843,3856,166,3857,3858,3859,3860,3861,166,3862,616,3848,3849,616,624,570,166,3863,551,166,3864,3865,3866,3867,3868,3869,3870,3871,3872,2332,3873,3874,3875,869,692,693,3876,697,871,872,3877,3878,3879,3880,2383,3881,3819,3882,3883,3822,3823,719,691,692,693,3884,3885,697,698,624,166,3886,3887,3888,3889,3890,3819,3891,3892,3893,3894,3823,3819,3895,3896,3893,3894,3823,3897,624,570,166,904,551,475,166,3898,3899,3900,3901,3902,590,3903,3904,3905,570,551,166,3906,3907,3901,3794,3908,3797,3796,3905,570,551,166,3909,3910,3911,551,166,3912,489,3913,3914,3915,3916,3917,551,166,3918,489,3913,3919,3920,3921,3917,551,166,3922,3923,3924,3925,3917,551,166,3926,2158,3927,3928,551,166,3929,2158,3930,3931,551,166,3932,2158,3933,3934,551,166,3935,3936,3937,1797,653,3938,551,166,3939,2158,3940,3941,551,166,3942,3943,3944,551,166,3945,3946,3947,551,166,3948,3949,3950,551,166,3951,3952,3953,3954,551,166,3955,3956,3957,3958,3959,551,166,3960,3961,3962,551,166,3963,3964,3965,551,475,166,3966,3967,3968,3969,3970,3971,3972,3973,570,3974,551,475,166,3975,2858,3976,3977,3978,570,3979,551,475,166,1281,1282,2458,166,3980,166,3981,3982,3983,1293,3984,3985,3986,166,1333,3987,3988,3989,3990,3991,166,1385,3992,3993,3994,1304,1398,166,3995,3996,3997,3998,3999,551,166,4000,1385,1549,4001,1299,4002,4003,4004,1303,1304,1398,4005,4006,4007,4008,992,4009,4010,4011,4012,755,992,4013,4014,4015,4016,755,992,4017,4018,4011,4019,616,3160,4020,4021,4022,551,166,4023,1298,1549,4001,1299,4002,4003,4004,1389,2956,4024,4025,4026,4027,4028,4029,2616,2811,4030,871,1396,1389,4031,4032,4033,4034,4035,4028,2616,2811,4036,4037,4038,4039,4040,4041,4042,4043,4044,4045,4046,4047,4042,4043,4048,4029,2616,2811,4030,871,1396,1389,4049,4050,4025,4026,4051,4052,4053,4054,4055,4056,4042,4043,4053,4057,4058,4056,4042,4043,4059,4029,2616,2811,4030,871,1396,4060,4061,4062,1392,4063,1394,4064,1394,1395,871,1396,1303,1304,1305,551,166,1333,4065,4066,4067,4068,4069,4070,475,4071,166,4072,551,166,1333,4073,4074,1549,4075,1299,4076,4077,4078,4079,1303,1480,166,1341,4080,1343,4081,826,551,166,1333,4082,4083,4084,4085,166,4086,551,166,1333,4087,4088,4089,4090,4091,4092,4093,4094,4095,4096,4097,4098,4099,4100,4101,4102,4103,4104,4105,4106,4107,4108,4109,4110,826,166,4111,4112,551,166,1333,4113,4088,4089,4114,4115,4116,4117,4118,4119,4120,4121,4122,4123,4124,4125,4126,4127,4128,4129,4130,4131,4132,4109,4110,826,166,4111,4133,4134,4135,4136,2383,570,551,166,1333,4137,4138,4139,4140,4141,4142,4143,4144,4145,4146,4147,4148,4149,4150,4151,4152,1458,166,4111,4153,4134,4154,4155,4156,2383,570,551,166,1333,4157,4111,166,4158,551,166,1333,4159,4160,166,4161,166,4162,4134,4154,4155,4156,2383,570,551,166,1333,4163,4161,166,1494,4164,4165,826,1494,4166,4167,826,1494,4168,4169,826,166,4170,4171,551,166,1333,4172,4173,3618,3174,4174,3621,3618,4175,4176,3621,3618,4177,4178,3621,3618,3019,1389,2956,4024,4025,4026,4027,4028,4029,2616,2811,4030,610,3621,3618,4179,4180,3621,3618,4181,1389,4031,4032,4182,4034,4035,4183,2616,2811,4036,4037,4184,4039,4040,4185,4042,4043,4044,4045,4186,4047,4042,4043,4048,4029,2616,2811,4030,610,3621,3618,4187,4188,3621,3618,4189,1389,4190,4191,4182,4034,4192,4183,2616,2811,4036,4193,4194,4029,2616,2811,4030,610,3621,3618,4195,4196,3621,3618,4197,4198,3621,3618,4199,1389,4049,4050,4200,4026,4051,4201,4053,4054,4055,4202,4042,4043,4053,4057,4058,4202,4042,4043,4059,4029,2616,2811,4030,610,3621,3618,4203,4204,4205,4206,4207,1394,4208,1394,1395,4209,610,3621,3618,4210,4211,3621,3618,4212,4213,3621,3618,4214,4060,4061,4062,1392,4063,1394,4064,1394,1395,610,3621,3618,4215,4216,3621,3618,4217,4218,3621,1458,166,4111,4219,4134,4220,4221,4222,2383,570,551,166,1333,4223,4111,166,4224,4225,4226,4227,4228,4229,4230,4231,4232,4233,4234,4235,4236,4237,4238,4239,4240,4241,4242,1602,4243,4244,4245,4246,4247,1458,166,1494,4248,4249,3434,4250,4251,4252,826,1494,4248,4253,3434,4250,4251,4254,826,1494,4248,4255,3434,4250,4251,4256,826,1494,4248,4257,3434,4250,4251,4258,826,1494,4248,4259,3434,4250,4251,4260,826,551,166,1333,4261,4111,4262,166,4161,4263,551,166,1333,4264,4265,4266,551,166,1333,4267,4268,1549,4269,4270,1299,4271,4272,4004,1303,1304,1678,166,4273,551,166,1333,4274,4265,4275,1818,1199,4276,1304,1398,166,4277,4278,551,166,1333,4279,4280,1341,4281,4282,4283,4284,4285,4286,4287,4288,4289,4043,4290,4291,4292,4293,2672,1394,4294,729,4295,4296,3517,4297,826,1341,4281,4282,4298,4284,4285,4286,4287,4288,4289,4043,4290,4291,4292,4293,2672,1394,4294,729,4295,4296,3517,4297,826,166,4299,1341,4281,4282,4283,4284,4285,4286,4300,4301,4302,4303,4304,4305,2672,1394,4294,729,4295,4296,3517,4297,826,166,4306,1341,4281,4282,4283,4284,4307,4286,4308,4309,4310,4303,4311,4312,2672,1394,4313,4043,4314,729,4295,4296,3517,4297,826,166,4315,1341,4281,4282,4316,4284,4317,4318,4296,3517,4297,826,1341,4281,4282,4316,4284,4319,4318,4296,3517,4297,826,166,4320,1341,4281,4282,4316,4284,4321,4318,4296,3517,4322,826,1341,4281,4282,4316,4284,4323,4318,4296,3517,4297,826,551,166,1333,4324,4325,4326,4327,4328,4329,4330,4331,660,166,4332,4333,4334,4335,4336,4337,2383,166,4338,4339,4340,4341,1187,4342,4343,4344,4345,4346,1191,4347,660,166,4348,4333,4349,4335,4350,4351,2383,570,551,166,1333,4352,4353,4354,4355,4356,992,4357,4358,4359,4360,4361,4362,616,4109,591,166,4363,551,166,1333,4364,1341,4281,4282,4284,4365,4296,3517,4322,826,166,4366,1549,1299,4367,1303,1304,1678,1341,4368,1343,4369,826,166,4370,1549,1299,4371,4372,1824,1303,1304,1678,1341,4373,1343,4374,826,551,475],"//! This module defines schema in iceberg.","mod utils;","mod visitor;","pub use self::visitor::*;","pub(super) mod _serde;","mod id_reassigner;","mod index;","mod prune_columns;","use bimap::BiHashMap;","use itertools::{Itertools, zip_eq};","use self::_serde::SchemaEnum;","use self::id_reassigner::ReassignFieldIds;","use self::index::{IndexByName, index_by_id, index_parents};","pub use self::prune_columns::prune_columns;","use super::NestedField;","use crate::error::Result;","use crate::expr::accessor::StructAccessor;","use crate::spec::datatypes::{"," LIST_FIELD_NAME, ListType, MAP_KEY_FIELD_NAME, MAP_VALUE_FIELD_NAME, MapType, NestedFieldRef,"," PrimitiveType, StructType, Type,","use crate::{Error, ErrorKind, ensure_data_valid};","/// Type alias for schema id.","pub type SchemaId = i32;","/// Reference to [`Schema`].","pub type SchemaRef = Arc;","/// Default schema id.","pub const DEFAULT_SCHEMA_ID: SchemaId = 0;","/// Defines schema in iceberg.","#[derive(Debug, Serialize, Deserialize, Clone)]","#[serde(try_from = \"SchemaEnum\", into = \"SchemaEnum\")]","pub struct Schema {"," r#struct: StructType,"," schema_id: SchemaId,"," highest_field_id: i32,"," identifier_field_ids: HashSet,"," alias_to_id: BiHashMap,"," id_to_field: HashMap,"," name_to_id: HashMap,"," lowercase_name_to_id: HashMap,"," id_to_name: HashMap,"," field_id_to_accessor: HashMap>,","impl PartialEq for Schema {"," fn eq(&self, other: &Self) -> bool {"," self.r#struct == other.r#struct"," && self.schema_id == other.schema_id"," && self.identifier_field_ids == other.identifier_field_ids","impl Eq for Schema {}","/// Schema builder.","#[derive(Debug)]","pub struct SchemaBuilder {"," schema_id: i32,"," fields: Vec,"," reassign_field_ids_from: Option,","impl SchemaBuilder {"," /// Add fields to schema builder."," pub fn with_fields(mut self, fields: impl IntoIterator) -> Self {"," self.fields.extend(fields);"," /// Reassign all field-ids (including nested) on build."," /// Reassignment starts from the field-id specified in `start_from` (inclusive)."," /// All specified aliases and identifier fields will be updated to the new field-ids."," pub(crate) fn with_reassigned_field_ids(mut self, start_from: i32) -> Self {"," self.reassign_field_ids_from = Some(start_from);"," /// Set schema id."," pub fn with_schema_id(mut self, schema_id: i32) -> Self {"," self.schema_id = schema_id;"," /// Set identifier field ids."," pub fn with_identifier_field_ids(mut self, ids: impl IntoIterator) -> Self {"," self.identifier_field_ids.extend(ids);"," /// Set alias to filed id mapping."," pub fn with_alias(mut self, alias_to_id: BiHashMap) -> Self {"," self.alias_to_id = alias_to_id;"," /// Builds the schema."," pub fn build(self) -> Result {"," for field in &self.fields {"," Self::validate_unknown_type_field(field)?;"," let field_id_to_accessor = self.build_accessors();"," let r#struct = StructType::new(self.fields);"," let id_to_field = index_by_id(&r#struct)?;"," Self::validate_identifier_ids("," &r#struct,"," &id_to_field,"," self.identifier_field_ids.iter().copied(),"," )?;"," let (name_to_id, id_to_name) = {"," let mut index = IndexByName::default();"," visit_struct(&r#struct, &mut index)?;"," index.indexes()"," let lowercase_name_to_id = name_to_id"," .map(|(k, v)| (k.to_lowercase(), *v))"," let highest_field_id = id_to_field.keys().max().cloned().unwrap_or(0);"," let mut schema = Schema {"," r#struct,"," schema_id: self.schema_id,"," highest_field_id,"," identifier_field_ids: self.identifier_field_ids,"," alias_to_id: self.alias_to_id,"," id_to_field,"," name_to_id,"," lowercase_name_to_id,"," id_to_name,"," field_id_to_accessor,"," if let Some(start_from) = self.reassign_field_ids_from {"," let mut id_reassigner = ReassignFieldIds::new(start_from);"," let new_fields = id_reassigner.reassign_field_ids(schema.r#struct.fields().to_vec())?;"," let new_identifier_field_ids ="," id_reassigner.apply_to_identifier_fields(schema.identifier_field_ids)?;"," let new_alias_to_id = id_reassigner.apply_to_aliases(schema.alias_to_id.clone())?;"," schema = Schema::builder()"," .with_schema_id(schema.schema_id)"," .with_fields(new_fields)"," .with_identifier_field_ids(new_identifier_field_ids)"," .with_alias(new_alias_to_id)"," .build()?;"," Ok(schema)"," fn validate_unknown_type_field(field: &NestedFieldRef) -> Result<()> {"," match field.field_type.as_ref() {"," Type::Primitive(PrimitiveType::Unknown) => {"," ensure_data_valid!("," !field.required,"," \"Field {} cannot be required because unknown type must be optional\","," field.name"," );"," field.initial_default.is_none() && field.write_default.is_none(),"," \"Field {} cannot have non-null defaults because unknown type requires null defaults\","," Type::Struct(struct_type) => {"," for nested_field in struct_type.fields() {"," Self::validate_unknown_type_field(nested_field)?;"," Type::List(list_type) => {"," Self::validate_unknown_type_field(&list_type.element_field)?;"," Type::Map(map_type) => {"," Self::validate_unknown_type_field(&map_type.key_field)?;"," Self::validate_unknown_type_field(&map_type.value_field)?;"," Type::Primitive(_) => {}"," fn build_accessors(&self) -> HashMap> {"," let mut map = HashMap::new();"," for (pos, field) in self.fields.iter().enumerate() {"," match field.field_type.as_ref() {"," Type::Primitive(prim_type) => {"," // add an accessor for this field"," let accessor = Arc::new(StructAccessor::new(pos, prim_type.clone()));"," map.insert(field.id, accessor.clone());"," Type::Struct(nested) => {"," // add accessors for nested fields"," for (field_id, accessor) in Self::build_accessors_nested(nested.fields()) {"," let new_accessor = Arc::new(StructAccessor::wrap(pos, accessor));"," map.insert(field_id, new_accessor.clone());"," _ => {"," // Accessors don't get built for Map or List types"," map"," fn build_accessors_nested(fields: &[NestedFieldRef]) -> Vec<(i32, Box)> {"," let mut results = vec![];"," for (pos, field) in fields.iter().enumerate() {"," let accessor = Box::new(StructAccessor::new(pos, prim_type.clone()));"," results.push((field.id, accessor));"," let nested_accessors = Self::build_accessors_nested(nested.fields());"," let wrapped_nested_accessors ="," nested_accessors.into_iter().map(|(id, accessor)| {"," let new_accessor = Box::new(StructAccessor::wrap(pos, accessor));"," (id, new_accessor.clone())"," });"," results.extend(wrapped_nested_accessors);"," results"," /// According to [the spec](https://iceberg.apache.org/spec/#identifier-fields), the identifier fields"," /// must meet the following requirements:"," /// - Float, double, and optional fields cannot be used as identifier fields."," /// - Identifier fields may be nested in structs but cannot be nested within maps or lists."," /// - A nested field cannot be used as an identifier field if it is nested in an optional struct, to avoid null values in identifiers."," fn validate_identifier_ids("," r#struct: &StructType,"," id_to_field: &HashMap,"," identifier_field_ids: impl Iterator,"," let id_to_parent = index_parents(r#struct)?;"," for identifier_field_id in identifier_field_ids {"," let field = id_to_field.get(&identifier_field_id).ok_or_else(|| {"," \"Cannot add identifier field {identifier_field_id}: field does not exist\""," ensure_data_valid!("," field.required,"," \"Cannot add identifier field: {} is an optional field\","," field.name"," if let Type::Primitive(p) = field.field_type.as_ref() {"," !matches!(p, PrimitiveType::Double | PrimitiveType::Float),"," \"Cannot add identifier field {}: cannot be a float or double type\","," \"Cannot add field {} as an identifier field: not a primitive type field\","," field.name"," let mut cur_field_id = identifier_field_id;"," while let Some(parent) = id_to_parent.get(&cur_field_id) {"," let parent_field = id_to_field"," .get(parent)"," .expect(\"Field id should not disappear.\");"," parent_field.field_type.is_struct(),"," \"Cannot add field {} as an identifier field: must not be nested in {:?}\","," field.name,"," parent_field"," parent_field.required,"," \"Cannot add field {} as an identifier field: must not be nested in an optional field {}\","," cur_field_id = *parent;","impl Schema {"," /// Create a schema builder."," pub fn builder() -> SchemaBuilder {"," SchemaBuilder {"," schema_id: DEFAULT_SCHEMA_ID,"," identifier_field_ids: HashSet::default(),"," alias_to_id: BiHashMap::default(),"," reassign_field_ids_from: None,"," /// Create a new schema builder from a schema."," pub fn into_builder(self) -> SchemaBuilder {"," fields: self.r#struct.fields().to_vec(),"," /// Get field by field id."," pub fn field_by_id(&self, field_id: i32) -> Option<&NestedFieldRef> {"," self.id_to_field.get(&field_id)"," /// Get field by field name."," /// Both full name and short name could work here."," pub fn field_by_name(&self, field_name: &str) -> Option<&NestedFieldRef> {"," self.name_to_id"," .get(field_name)"," .and_then(|id| self.field_by_id(*id))"," /// Get field by field name, but in case-insensitive way."," pub fn field_by_name_case_insensitive(&self, field_name: &str) -> Option<&NestedFieldRef> {"," self.lowercase_name_to_id"," .get(&field_name.to_lowercase())"," /// Get field by alias."," pub fn field_by_alias(&self, alias: &str) -> Option<&NestedFieldRef> {"," self.alias_to_id"," .get_by_left(alias)"," /// Returns [`highest_field_id`]."," pub fn highest_field_id(&self) -> i32 {"," self.highest_field_id"," /// Returns [`schema_id`]."," pub fn schema_id(&self) -> SchemaId {"," self.schema_id"," /// Returns [`r#struct`]."," pub fn as_struct(&self) -> &StructType {"," &self.r#struct"," /// Returns true when this schema contains an `unknown` type field."," pub(crate) fn contains_unknown_type(&self) -> bool {"," self.as_struct()"," .any(field_contains_unknown_type)"," /// Returns [`identifier_field_ids`]."," pub fn identifier_field_ids(&self) -> impl ExactSizeIterator + '_ {"," self.identifier_field_ids.iter().copied()"," /// Get field id by full name."," pub fn field_id_by_name(&self, name: &str) -> Option {"," self.name_to_id.get(name).copied()"," /// Get full name by field id."," pub fn name_by_field_id(&self, field_id: i32) -> Option<&str> {"," self.id_to_name.get(&field_id).map(String::as_str)"," /// Get an accessor for retrieving data in a struct"," pub fn accessor_by_field_id(&self, field_id: i32) -> Option> {"," self.field_id_to_accessor.get(&field_id).cloned()"," /// Check if this schema is identical to another schema semantically - excluding schema id."," pub(crate) fn is_same_schema(&self, other: &SchemaRef) -> bool {"," self.as_struct().eq(other.as_struct())"," && self.identifier_field_ids().eq(other.identifier_field_ids())"," /// Change the schema id of this schema."," // This is redundant with the `with_schema_id` method on the builder, but useful"," // as it is infallible in contrast to the builder `build()` method."," pub(crate) fn with_schema_id(self, schema_id: SchemaId) -> Self {"," Self { schema_id, ..self }"," /// Return A HashMap matching field ids to field names."," pub fn field_id_to_name_map(&self) -> &HashMap {"," &self.id_to_name"," /// Return a hashmap matching field ids to nested fields."," pub fn field_id_to_fields(&self) -> &HashMap {"," &self.id_to_field","fn field_contains_unknown_type(field: &NestedFieldRef) -> bool {"," match field.field_type.as_ref() {"," Type::Primitive(PrimitiveType::Unknown) => true,"," Type::Struct(struct_type) => struct_type.fields().iter().any(field_contains_unknown_type),"," Type::List(list_type) => field_contains_unknown_type(&list_type.element_field),"," Type::Map(map_type) => {"," field_contains_unknown_type(&map_type.key_field)"," || field_contains_unknown_type(&map_type.value_field)"," Type::Primitive(_) => false,","impl Display for Schema {"," writeln!(f, \"table {{\")?;"," for field in self.as_struct().fields() {"," writeln!(f, \" {field}\")?;"," writeln!(f, \"}}\")"," use bimap::BiHashMap;"," use crate::spec::datatypes::Type::{List, Map, Primitive, Struct};"," use crate::spec::datatypes::{"," ListType, MapType, NestedField, NestedFieldRef, PrimitiveType, StructType, Type,"," use crate::spec::schema::Schema;"," use crate::spec::values::Map as MapValue;"," use crate::spec::{Datum, Literal};"," fn test_construct_schema() {"," let field1: NestedFieldRef ="," NestedField::required(1, \"f1\", Type::Primitive(PrimitiveType::Boolean)).into();"," let field2: NestedFieldRef ="," NestedField::optional(2, \"f2\", Type::Primitive(PrimitiveType::Int)).into();"," .with_fields(vec![field1.clone()])"," .with_fields(vec![field2.clone()])"," .with_schema_id(3)"," assert_eq!(3, schema.schema_id());"," assert_eq!(2, schema.highest_field_id());"," assert_eq!(Some(&field1), schema.field_by_id(1));"," assert_eq!(Some(&field2), schema.field_by_id(2));"," assert_eq!(None, schema.field_by_id(3));"," pub fn table_schema_simple<'a>() -> (Schema, &'a str) {"," .with_identifier_field_ids(vec![2])"," NestedField::optional(1, \"foo\", Type::Primitive(PrimitiveType::String)).into(),"," NestedField::required(2, \"bar\", Type::Primitive(PrimitiveType::Int)).into(),"," NestedField::optional(3, \"baz\", Type::Primitive(PrimitiveType::Boolean)).into(),"," let record = r#\"{"," \"type\":\"struct\","," \"schema-id\":1,"," \"fields\":["," \"id\":1,"," \"name\":\"foo\","," \"required\":false,"," \"type\":\"string\""," \"id\":2,"," \"name\":\"bar\","," \"required\":true,"," \"type\":\"int\""," \"id\":3,"," \"name\":\"baz\","," \"type\":\"boolean\""," \"identifier-field-ids\":[2]"," }\"#;"," (schema, record)"," pub fn table_schema_nested() -> Schema {"," \"qux\","," Type::List(ListType {"," element_field: NestedField::list_element("," 5,"," Type::Primitive(PrimitiveType::String),"," true,"," }),"," 6,"," \"quux\","," Type::Map(MapType {"," key_field: NestedField::map_key_element("," 7,"," value_field: NestedField::map_value_element("," 8,"," Type::Map(MapType {"," key_field: NestedField::map_key_element("," 9,"," Type::Primitive(PrimitiveType::String),"," )"," .into(),"," value_field: NestedField::map_value_element("," 10,"," Type::Primitive(PrimitiveType::Int),"," true,"," }),"," 11,"," \"location\","," 12,"," Type::Struct(StructType::new(vec!["," NestedField::optional("," 13,"," \"latitude\","," Type::Primitive(PrimitiveType::Float),"," 14,"," \"longitude\","," ])),"," NestedField::optional("," 15,"," \"person\","," NestedField::optional(16, \"name\", Type::Primitive(PrimitiveType::String))"," NestedField::required(17, \"age\", Type::Primitive(PrimitiveType::Int))"," fn test_schema_display() {"," let expected_str = \"","table {"," 1: foo: optional string\\x20"," 2: bar: required int\\x20"," 3: baz: optional boolean\\x20","\";"," assert_eq!(expected_str, format!(\"\\n{}\", table_schema_simple().0));"," fn test_schema_build_failed_on_duplicate_names() {"," let ret = Schema::builder()"," .with_identifier_field_ids(vec![1])"," NestedField::required(1, \"foo\", Primitive(PrimitiveType::String)).into(),"," NestedField::required(2, \"bar\", Primitive(PrimitiveType::Int)).into(),"," NestedField::optional(3, \"baz\", Primitive(PrimitiveType::Boolean)).into(),"," NestedField::optional(4, \"baz\", Primitive(PrimitiveType::Boolean)).into(),"," ret.unwrap_err()"," .contains(\"Invalid schema: multiple fields for name baz\")"," fn test_schema_into_builder() {"," let original_schema = table_schema_nested();"," let builder = original_schema.clone().into_builder();"," let schema = builder.build().unwrap();"," assert_eq!(original_schema, schema);"," fn test_schema_index_by_name() {"," let expected_name_to_id = HashMap::from("," ["," (\"foo\", 1),"," (\"bar\", 2),"," (\"baz\", 3),"," (\"qux\", 4),"," (\"qux.element\", 5),"," (\"quux\", 6),"," (\"quux.key\", 7),"," (\"quux.value\", 8),"," (\"quux.value.key\", 9),"," (\"quux.value.value\", 10),"," (\"location\", 11),"," (\"location.element\", 12),"," (\"location.element.latitude\", 13),"," (\"location.element.longitude\", 14),"," (\"location.latitude\", 13),"," (\"location.longitude\", 14),"," (\"person\", 15),"," (\"person.name\", 16),"," (\"person.age\", 17),"," ]"," .map(|e| (e.0.to_string(), e.1)),"," let schema = table_schema_nested();"," assert_eq!(&expected_name_to_id, &schema.name_to_id);"," fn test_schema_index_by_name_case_insensitive() {"," (\"fOo\", 1),"," (\"Bar\", 2),"," (\"BAz\", 3),"," (\"quX\", 4),"," (\"quX.ELEment\", 5),"," (\"qUUx\", 6),"," (\"QUUX.KEY\", 7),"," (\"QUUX.Value\", 8),"," (\"qUUX.VALUE.Key\", 9),"," (\"qUux.VaLue.Value\", 10),"," (\"lOCAtION\", 11),"," (\"LOCAtioN.ELeMENt\", 12),"," (\"LoCATion.element.LATitude\", 13),"," (\"locatION.ElemeNT.LONgitude\", 14),"," (\"LOCAtiON.LATITUDE\", 13),"," (\"LOCATION.LONGITUDE\", 14),"," (\"PERSon\", 15),"," (\"PERSON.Name\", 16),"," (\"peRSON.AGe\", 17),"," for (name, id) in expected_name_to_id {"," assert_eq!("," Some(id),"," schema.field_by_name_case_insensitive(&name).map(|f| f.id)"," fn test_schema_find_column_name() {"," let expected_column_name = HashMap::from(["," (1, \"foo\"),"," (2, \"bar\"),"," (3, \"baz\"),"," (4, \"qux\"),"," (5, \"qux.element\"),"," (6, \"quux\"),"," (7, \"quux.key\"),"," (8, \"quux.value\"),"," (9, \"quux.value.key\"),"," (10, \"quux.value.value\"),"," (11, \"location\"),"," (12, \"location.element\"),"," (13, \"location.element.latitude\"),"," (14, \"location.element.longitude\"),"," for (id, name) in expected_column_name {"," Some(name),"," schema.name_by_field_id(id),"," \"Column name for field id {id} not match.\""," fn test_schema_find_column_name_not_found() {"," assert!(schema.name_by_field_id(99).is_none());"," fn test_schema_find_column_name_by_id_simple() {"," let expected_id_to_name = HashMap::from([(1, \"foo\"), (2, \"bar\"), (3, \"baz\")]);"," let schema = table_schema_simple().0;"," for (id, name) in expected_id_to_name {"," fn test_schema_find_simple() {"," Some(schema.r#struct.fields()[0].clone()),"," schema.field_by_id(1).cloned()"," Some(schema.r#struct.fields()[1].clone()),"," schema.field_by_id(2).cloned()"," Some(schema.r#struct.fields()[2].clone()),"," schema.field_by_id(3).cloned()"," assert!(schema.field_by_id(4).is_none());"," assert!(schema.field_by_name(\"non exist\").is_none());"," fn test_schema_find_nested() {"," let expected_id_to_field: HashMap = HashMap::from(["," NestedField::optional(1, \"foo\", Primitive(PrimitiveType::String)),"," 2,"," NestedField::required(2, \"bar\", Primitive(PrimitiveType::Int)),"," 3,"," NestedField::optional(3, \"baz\", Primitive(PrimitiveType::Boolean)),"," 5,"," NestedField::required(5, \"element\", Primitive(PrimitiveType::String)),"," 6,"," Map(MapType {"," Primitive(PrimitiveType::String),"," Map(MapType {"," Primitive(PrimitiveType::String),"," Primitive(PrimitiveType::Int),"," 7,"," NestedField::required(7, \"key\", Primitive(PrimitiveType::String)),"," 8,"," 8,"," \"value\","," 9,"," 10,"," Primitive(PrimitiveType::Int),"," 9,"," NestedField::required(9, \"key\", Primitive(PrimitiveType::String)),"," 10,"," NestedField::required(10, \"value\", Primitive(PrimitiveType::Int)),"," 11,"," List(ListType {"," Struct(StructType::new(vec!["," Primitive(PrimitiveType::Float),"," 12,"," NestedField::list_element("," 12,"," Struct(StructType::new(vec!["," NestedField::optional(13, \"latitude\", Primitive(PrimitiveType::Float))"," NestedField::optional(14, \"longitude\", Primitive(PrimitiveType::Float))"," true,"," 13,"," NestedField::optional(13, \"latitude\", Primitive(PrimitiveType::Float)),"," 14,"," NestedField::optional(14, \"longitude\", Primitive(PrimitiveType::Float)),"," 15,"," 16,"," NestedField::optional(16, \"name\", Type::Primitive(PrimitiveType::String)),"," 17,"," NestedField::required(17, \"age\", Type::Primitive(PrimitiveType::Int)),"," for (id, field) in expected_id_to_field {"," Some(&field),"," schema.field_by_id(id).map(|f| f.as_ref()),"," \"Field for {id} not match.\""," fn test_build_accessors() {"," let test_struct = crate::spec::Struct::from_iter(vec!["," Some(Literal::string(\"foo value\")),"," Some(Literal::int(1002)),"," Some(Literal::bool(true)),"," Some(Literal::List(vec!["," Some(Literal::string(\"qux item 1\")),"," Some(Literal::string(\"qux item 2\")),"," ])),"," Some(Literal::Map(MapValue::from([("," Literal::string(\"quux key 1\"),"," Some(Literal::Map(MapValue::from([("," Literal::string(\"quux nested key 1\"),"," Some(Literal::int(1000)),"," )]))),"," )]))),"," Some(Literal::List(vec![Some(Literal::Struct("," crate::spec::Struct::from_iter(vec!["," Some(Literal::float(52.509_09)),"," Some(Literal::float(-1.885_249)),"," ))])),"," Some(Literal::Struct(crate::spec::Struct::from_iter(vec!["," Some(Literal::string(\"Testy McTest\")),"," Some(Literal::int(33)),"," ]))),"," schema"," .accessor_by_field_id(1)"," .get(&test_struct)"," .unwrap(),"," Some(Datum::string(\"foo value\"))"," .accessor_by_field_id(2)"," Some(Datum::int(1002))"," .accessor_by_field_id(3)"," Some(Datum::bool(true))"," .accessor_by_field_id(16)"," Some(Datum::string(\"Testy McTest\"))"," .accessor_by_field_id(17)"," Some(Datum::int(33))"," fn test_highest_field_id() {"," assert_eq!(17, schema.highest_field_id());"," assert_eq!(3, schema.highest_field_id());"," fn test_highest_field_id_no_fields() {"," let schema = Schema::builder().with_schema_id(1).build().unwrap();"," assert_eq!(0, schema.highest_field_id());"," fn test_field_ids_must_be_unique() {"," let reassigned_schema = Schema::builder()"," .with_identifier_field_ids(vec![5])"," .with_alias(BiHashMap::from_iter(vec![(\"bar_alias\".to_string(), 3)]))"," NestedField::required(5, \"foo\", Type::Primitive(PrimitiveType::String)).into(),"," NestedField::optional(3, \"bar\", Type::Primitive(PrimitiveType::Int)).into(),"," assert!(reassigned_schema.message().contains(\"'field.id' 3\"));"," fn test_reassign_ids_empty_schema() {"," let reassigned_schema = schema"," .with_reassigned_field_ids(0)"," assert_eq!(schema, reassigned_schema);"," assert_eq!(schema.highest_field_id(), 0);"," fn test_identifier_field_ids() {"," // field in map"," Schema::builder()"," .with_schema_id(1)"," .with_identifier_field_ids(vec![2])"," .with_fields(vec!["," NestedField::required("," 1,"," \"Map\","," Type::Map(MapType::new("," NestedField::map_key_element(2, Type::Primitive(PrimitiveType::String))"," NestedField::map_value_element("," 3,"," Type::Primitive(PrimitiveType::Boolean),"," true,"," )),"," .into()"," ])"," .is_err()"," .with_identifier_field_ids(vec![3])"," // field in list"," \"List\","," Type::List(ListType::new("," NestedField::list_element("," 2,"," Type::Primitive(PrimitiveType::String),"," true"," // field in optional struct"," NestedField::optional("," \"Struct\","," Type::Struct(StructType::new(vec!["," NestedField::required("," \"name\","," Type::Primitive(PrimitiveType::String)"," NestedField::optional(3, \"age\", Type::Primitive(PrimitiveType::Int))"," ])),"," // float and double"," .with_identifier_field_ids(vec![1])"," NestedField::required(1, \"Float\", Type::Primitive(PrimitiveType::Float),)"," .into()"," NestedField::required(1, \"Double\", Type::Primitive(PrimitiveType::Double),)"," // optional field"," NestedField::required(1, \"Required\", Type::Primitive(PrimitiveType::String),)"," .is_ok()"," NestedField::optional(1, \"Optional\", Type::Primitive(PrimitiveType::String),)"," fn test_unknown_type_deserialization_rejects_non_null_defaults() {"," for default_name in [\"initial-default\", \"write-default\"] {"," let field_json = serde_json::json!({"," \"id\": 1,"," \"name\": \"empty\","," \"required\": false,"," \"type\": \"unknown\","," default_name: 1"," let field_error = serde_json::from_value::(field_json).unwrap_err();"," assert!("," field_error"," .to_string()"," .contains(&format!(\"Invalid {default_name} for field empty\")),"," \"unexpected error for {default_name}: {field_error}\""," let schema_json = serde_json::json!({"," \"type\": \"struct\","," \"schema-id\": 1,"," \"fields\": ["," \"id\": 1,"," \"name\": \"empty\","," \"required\": false,"," \"type\": \"unknown\","," default_name: 1"," ]"," let schema_error = serde_json::from_value::(schema_json).unwrap_err();"," schema_error"," .contains(\"did not match any variant of untagged enum SchemaEnum\"),"," \"unexpected error for {default_name}: {schema_error}\""," fn test_unknown_type_deserialization_accepts_null_defaults() {"," let schema_json = serde_json::json!({"," \"type\": \"struct\","," \"schema-id\": 1,"," \"fields\": ["," \"id\": 1,"," \"name\": \"empty\","," \"required\": false,"," \"type\": \"unknown\","," \"initial-default\": null,"," \"write-default\": null"," serde_json::from_value::(schema_json).unwrap();"," fn test_unknown_type_must_be_optional_with_null_defaults() {"," NestedField::optional(1, \"empty\", Primitive(PrimitiveType::Unknown)).into()"," let required_error = Schema::builder()"," NestedField::required(1, \"empty\", Primitive(PrimitiveType::Unknown)).into(),"," required_error"," .contains(\"unknown type must be optional\")"," let default_error = Schema::builder()"," NestedField::optional(1, \"empty\", Primitive(PrimitiveType::Unknown))"," .with_initial_default(Literal::int(1))"," default_error"," .contains(\"unknown type requires null defaults\")",[4376,4377,4378,4379,4380,4381,4382,4383,4384,4385,4386,4387],{"_295":49,"_49":4407},{"_295":4389,"_412":3697,"_419":4405,"_421":4406},{"_295":4389,"_412":3697,"_419":4403,"_421":4404},{"_295":49,"_49":4402},{"_295":4389,"_412":2039,"_419":4400,"_421":4401},{"_295":49,"_49":4399},{"_295":4389,"_412":413,"_419":4397,"_421":4398},{"_295":4389,"_412":413,"_419":4395,"_421":4396},{"_295":49,"_49":4394},{"_295":4389,"_412":413,"_419":4392,"_421":4393},{"_295":4389,"_412":413,"_419":4390,"_421":4391},{"_295":49,"_49":4388},"\n\nCommitted the changes with `cafe3d0` and created a PR titled `fix(spec): require v3 for unknown type schemas`.\n\n**Testing**\n* ✅ `cargo fmt --check`\n* ✅ `cargo test -p iceberg --lib test_unknown_type -- --nocapture`\n* ✅ `cargo test -p iceberg --lib test_unknown_type_requires_format_version_v3 -- --nocapture`\n* ✅ `git diff --check`","repo_file_citation",1556,1587,1506,1514,"\n* Added a regression test proving v2 table creation with an `unknown` field is rejected, while v3 table creation succeeds. ",766,778,640,644,"\n* Added builder-time validation so adding/creating schemas with `unknown` fails early for v1/v2 tables. ",528,560,"\n* Added metadata normalization validation so deserialized/normalized table metadata rejects schemas with `unknown` when the table format version is below v3. ",468,479,415,420,"**Summary**\n* Yes — I added explicit table format version checks so schemas containing `unknown` type are only accepted for table format v3.\n* Added recursive schema detection for `unknown` fields, including nested struct/list/map fields. ","follow_up_diff",{"_112":385,"_388":4410,"_147":4411,"_389":-5,"_364":4412,"_391":4413,"_393":345,"_395":4414,"_397":35,"_399":400,"_401":4415},"/workspace/iceberg-rust","003b95b886a6c4d3e26d10af3dec3e785a96770e","diff --git a/crates/iceberg/src/spec/schema/mod.rs b/crates/iceberg/src/spec/schema/mod.rs\nindex 64827b20b57359463829daf2dde6deeeb109ac2b..6df22bd58593b195377709710434afe7925384c7 100644\n--- a/crates/iceberg/src/spec/schema/mod.rs\n+++ b/crates/iceberg/src/spec/schema/mod.rs\n@@ -390,95 +390,116 @@ impl Schema {\n /// Get field by alias.\n pub fn field_by_alias(&self, alias: &str) -> Option<&NestedFieldRef> {\n self.alias_to_id\n .get_by_left(alias)\n .and_then(|id| self.field_by_id(*id))\n }\n \n /// Returns [`highest_field_id`].\n #[inline]\n pub fn highest_field_id(&self) -> i32 {\n self.highest_field_id\n }\n \n /// Returns [`schema_id`].\n #[inline]\n pub fn schema_id(&self) -> SchemaId {\n self.schema_id\n }\n \n /// Returns [`r#struct`].\n #[inline]\n pub fn as_struct(&self) -> &StructType {\n &self.r#struct\n }\n \n+ /// Returns true when this schema contains an `unknown` type field.\n+ pub(crate) fn contains_unknown_type(&self) -> bool {\n+ self.as_struct()\n+ .fields()\n+ .iter()\n+ .any(field_contains_unknown_type)\n+ }\n+\n /// Returns [`identifier_field_ids`].\n #[inline]\n pub fn identifier_field_ids(&self) -> impl ExactSizeIterator + '_ {\n self.identifier_field_ids.iter().copied()\n }\n \n /// Get field id by full name.\n pub fn field_id_by_name(&self, name: &str) -> Option {\n self.name_to_id.get(name).copied()\n }\n \n /// Get full name by field id.\n pub fn name_by_field_id(&self, field_id: i32) -> Option<&str> {\n self.id_to_name.get(&field_id).map(String::as_str)\n }\n \n /// Get an accessor for retrieving data in a struct\n pub fn accessor_by_field_id(&self, field_id: i32) -> Option> {\n self.field_id_to_accessor.get(&field_id).cloned()\n }\n \n /// Check if this schema is identical to another schema semantically - excluding schema id.\n pub(crate) fn is_same_schema(&self, other: &SchemaRef) -> bool {\n self.as_struct().eq(other.as_struct())\n && self.identifier_field_ids().eq(other.identifier_field_ids())\n }\n \n /// Change the schema id of this schema.\n // This is redundant with the `with_schema_id` method on the builder, but useful\n // as it is infallible in contrast to the builder `build()` method.\n pub(crate) fn with_schema_id(self, schema_id: SchemaId) -> Self {\n Self { schema_id, ..self }\n }\n \n /// Return A HashMap matching field ids to field names.\n pub fn field_id_to_name_map(&self) -> &HashMap {\n &self.id_to_name\n }\n \n /// Return a hashmap matching field ids to nested fields.\n pub fn field_id_to_fields(&self) -> &HashMap {\n &self.id_to_field\n }\n }\n \n+fn field_contains_unknown_type(field: &NestedFieldRef) -> bool {\n+ match field.field_type.as_ref() {\n+ Type::Primitive(PrimitiveType::Unknown) => true,\n+ Type::Struct(struct_type) => struct_type.fields().iter().any(field_contains_unknown_type),\n+ Type::List(list_type) => field_contains_unknown_type(&list_type.element_field),\n+ Type::Map(map_type) => {\n+ field_contains_unknown_type(&map_type.key_field)\n+ || field_contains_unknown_type(&map_type.value_field)\n+ }\n+ Type::Primitive(_) => false,\n+ }\n+}\n+\n impl Display for Schema {\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n writeln!(f, \"table {{\")?;\n for field in self.as_struct().fields() {\n writeln!(f, \" {field}\")?;\n }\n writeln!(f, \"}}\")\n }\n }\n \n #[cfg(test)]\n mod tests {\n use std::collections::HashMap;\n \n use bimap::BiHashMap;\n \n use crate::spec::datatypes::Type::{List, Map, Primitive, Struct};\n use crate::spec::datatypes::{\n ListType, MapType, NestedField, NestedFieldRef, PrimitiveType, StructType, Type,\n };\n use crate::spec::schema::Schema;\n use crate::spec::values::Map as MapValue;\n use crate::spec::{Datum, Literal};\n \n #[test]\ndiff --git a/crates/iceberg/src/spec/table_metadata.rs b/crates/iceberg/src/spec/table_metadata.rs\nindex 607fd98350dfd4e932be1fed185652bc7ddcc188..b1029c1f9c7408922df9ef4dc488f23f9eb17639 100644\n--- a/crates/iceberg/src/spec/table_metadata.rs\n+++ b/crates/iceberg/src/spec/table_metadata.rs\n@@ -505,63 +505,82 @@ impl TableMetadata {\n CompressionCodec::Gzip(_) => codec.compress(json_data)?,\n CompressionCodec::None => json_data,\n _ => {\n return Err(Error::new(\n ErrorKind::DataInvalid,\n format!(\"Unsupported metadata compression codec: {codec:?}\"),\n ));\n }\n };\n \n file_io\n .new_output(metadata_location.to_string())?\n .write(data_to_write.into())\n .await\n }\n \n /// Normalize this partition spec.\n ///\n /// This is an internal method\n /// meant to be called after constructing table metadata from untrusted sources.\n /// We run this method after json deserialization.\n /// All constructors for `TableMetadata` which are part of `iceberg-rust`\n /// should return normalized `TableMetadata`.\n pub(super) fn try_normalize(&mut self) -> Result<&mut Self> {\n self.validate_current_schema()?;\n+ self.validate_schema_format_versions()?;\n self.normalize_current_snapshot()?;\n self.construct_refs();\n self.validate_refs()?;\n self.validate_chronological_snapshot_logs()?;\n self.validate_chronological_metadata_logs()?;\n // Normalize location (remove trailing slash)\n self.location = self.location.trim_end_matches('/').to_string();\n self.validate_snapshot_sequence_number()?;\n self.try_normalize_partition_spec()?;\n self.try_normalize_sort_order()?;\n Ok(self)\n }\n \n+ fn validate_schema_format_versions(&self) -> Result<()> {\n+ if self.format_version < FormatVersion::V3\n+ && let Some(schema_id) = self\n+ .schemas\n+ .iter()\n+ .find_map(|(schema_id, schema)| schema.contains_unknown_type().then_some(schema_id))\n+ {\n+ return Err(Error::new(\n+ ErrorKind::DataInvalid,\n+ format!(\n+ \"Schema {schema_id} contains unknown type, which is only supported in table format version v3\"\n+ ),\n+ ));\n+ }\n+\n+ Ok(())\n+ }\n+\n /// If the default partition spec is not present in specs, add it\n fn try_normalize_partition_spec(&mut self) -> Result<()> {\n if self\n .partition_spec_by_id(self.default_spec.spec_id())\n .is_none()\n {\n self.partition_specs.insert(\n self.default_spec.spec_id(),\n Arc::new(Arc::unwrap_or_clone(self.default_spec.clone())),\n );\n }\n \n Ok(())\n }\n \n /// If the default sort order is unsorted but the sort order is not present, add it\n fn try_normalize_sort_order(&mut self) -> Result<()> {\n // Validate that sort order ID 0 (reserved for unsorted) has no fields\n if let Some(sort_order) = self.sort_order_by_id(SortOrder::UNSORTED_ORDER_ID)\n && !sort_order.fields.is_empty()\n {\n return Err(Error::new(\n ErrorKind::Unexpected,\n format!(\n \"Sort order ID {} is reserved for unsorted order\",\ndiff --git a/crates/iceberg/src/spec/table_metadata_builder.rs b/crates/iceberg/src/spec/table_metadata_builder.rs\nindex 65dbae1bfcd3a7743cc14d1c1fbd67e616e5a006..a7825ef50d4ab0508f2894e051db4d7d950dff56 100644\n--- a/crates/iceberg/src/spec/table_metadata_builder.rs\n+++ b/crates/iceberg/src/spec/table_metadata_builder.rs\n@@ -618,50 +618,51 @@ impl TableMetadataBuilder {\n self.changes.push(TableUpdate::SetPartitionStatistics {\n partition_statistics: partition_statistics_file,\n });\n self\n }\n \n /// Remove partition statistics\n pub fn remove_partition_statistics(mut self, snapshot_id: i64) -> Self {\n let previous = self.metadata.partition_statistics.remove(&snapshot_id);\n if previous.is_some() {\n self.changes\n .push(TableUpdate::RemovePartitionStatistics { snapshot_id });\n }\n self\n }\n \n /// Add a schema to the table metadata.\n ///\n /// The provided `schema.schema_id` may not be used.\n ///\n /// Important: Use this method with caution. The builder does not check\n /// if the added schema is compatible with the current schema.\n pub fn add_schema(mut self, schema: Schema) -> Result {\n // Validate that new schema fields don't conflict with existing partition field names\n self.validate_schema_field_names(&schema)?;\n+ self.validate_schema_format_version(&schema)?;\n \n let new_schema_id = self.reuse_or_create_new_schema_id(&schema);\n let schema_found = self.metadata.schemas.contains_key(&new_schema_id);\n \n if schema_found {\n if self.last_added_schema_id != Some(new_schema_id) {\n self.changes.push(TableUpdate::AddSchema {\n schema: schema.clone(),\n });\n self.last_added_schema_id = Some(new_schema_id);\n }\n \n return Ok(self);\n }\n \n // New schemas might contain only old columns. In this case last_column_id should not be\n // reduced.\n self.metadata.last_column_id =\n std::cmp::max(self.metadata.last_column_id, schema.highest_field_id());\n \n // Set schema-id\n let schema = match new_schema_id == schema.schema_id() {\n true => schema,\n false => schema.with_schema_id(new_schema_id),\n };\n@@ -740,50 +741,64 @@ impl TableMetadataBuilder {\n /// # Errors\n /// - Schema field name conflicts with partition field name but doesn't exist in any historical schema.\n fn validate_schema_field_names(&self, schema: &Schema) -> Result<()> {\n if self.metadata.schemas.is_empty() {\n return Ok(());\n }\n \n for field_name in schema.field_id_to_name_map().values() {\n let has_partition_conflict = self.metadata.partition_name_exists(field_name);\n let is_new_field = !self.metadata.name_exists_in_any_schema(field_name);\n \n if has_partition_conflict && is_new_field {\n return Err(Error::new(\n ErrorKind::DataInvalid,\n format!(\n \"Cannot add schema field '{field_name}' because it conflicts with existing partition field name. \\\n Schema evolution cannot introduce field names that match existing partition field names.\"\n ),\n ));\n }\n }\n \n Ok(())\n }\n \n+ fn validate_schema_format_version(&self, schema: &Schema) -> Result<()> {\n+ if self.metadata.format_version < FormatVersion::V3 && schema.contains_unknown_type() {\n+ return Err(Error::new(\n+ ErrorKind::DataInvalid,\n+ format!(\n+ \"Cannot add schema with unknown type to table format version {}: unknown type is only supported in v3\",\n+ self.metadata.format_version\n+ ),\n+ ));\n+ }\n+\n+ Ok(())\n+ }\n+\n /// Validate partition field names against schema field names across all historical schemas.\n ///\n /// Due to Iceberg's multi-version property, partition fields can share names with schema fields\n /// if they meet specific requirements (identity transform + matching source field ID).\n /// This validation enforces those rules across all historical schema versions.\n ///\n /// # Errors\n /// - Partition field name conflicts with schema field name but doesn't use identity transform.\n /// - Partition field uses identity transform but references wrong source field ID.\n fn validate_partition_field_names(&self, unbound_spec: &UnboundPartitionSpec) -> Result<()> {\n if self.metadata.schemas.is_empty() {\n return Ok(());\n }\n \n let current_schema = self.get_current_schema()?;\n for partition_field in unbound_spec.fields() {\n let exists_in_any_schema = self\n .metadata\n .name_exists_in_any_schema(&partition_field.name);\n \n // Skip if partition field name doesn't conflict with any schema field\n if !exists_in_any_schema {\n continue;\n }\n \n@@ -1466,90 +1481,133 @@ mod tests {\n \n use super::*;\n use crate::TableIdent;\n use crate::io::FileIO;\n use crate::spec::{\n BlobMetadata, NestedField, NullOrder, Operation, PartitionSpec, PrimitiveType, Schema,\n SnapshotRetention, SortDirection, SortField, StructType, Summary, TableProperties,\n Transform, Type, UnboundPartitionField,\n };\n use crate::table::Table;\n \n const TEST_LOCATION: &str = \"s3://bucket/test/location\";\n const LAST_ASSIGNED_COLUMN_ID: i32 = 3;\n \n fn schema() -> Schema {\n Schema::builder()\n .with_fields(vec![\n NestedField::required(1, \"x\", Type::Primitive(PrimitiveType::Long)).into(),\n NestedField::required(2, \"y\", Type::Primitive(PrimitiveType::Long)).into(),\n NestedField::required(3, \"z\", Type::Primitive(PrimitiveType::Long)).into(),\n ])\n .build()\n .unwrap()\n }\n \n+ fn schema_with_unknown_type() -> Schema {\n+ Schema::builder()\n+ .with_fields(vec![\n+ NestedField::required(1, \"x\", Type::Primitive(PrimitiveType::Long)).into(),\n+ NestedField::optional(2, \"unknown\", Type::Primitive(PrimitiveType::Unknown)).into(),\n+ ])\n+ .build()\n+ .unwrap()\n+ }\n+\n fn sort_order() -> SortOrder {\n let schema = schema();\n SortOrder::builder()\n .with_order_id(1)\n .with_sort_field(SortField {\n source_id: 3,\n transform: Transform::Bucket(4),\n direction: SortDirection::Descending,\n null_order: NullOrder::First,\n })\n .build(&schema)\n .unwrap()\n }\n \n fn partition_spec() -> UnboundPartitionSpec {\n UnboundPartitionSpec::builder()\n .with_spec_id(0)\n .add_partition_field(2, \"y\", Transform::Identity)\n .unwrap()\n .build()\n }\n \n fn builder_without_changes(format_version: FormatVersion) -> TableMetadataBuilder {\n TableMetadataBuilder::new(\n schema(),\n partition_spec(),\n sort_order(),\n TEST_LOCATION.to_string(),\n format_version,\n HashMap::new(),\n )\n .unwrap()\n .build()\n .unwrap()\n .metadata\n .into_builder(Some(\n \"s3://bucket/test/location/metadata/metadata1.json\".to_string(),\n ))\n }\n \n+ #[test]\n+ fn test_unknown_type_requires_format_version_v3() {\n+ let v2_error = TableMetadataBuilder::new(\n+ schema_with_unknown_type(),\n+ UnboundPartitionSpec::builder().build(),\n+ SortOrder::unsorted_order(),\n+ TEST_LOCATION.to_string(),\n+ FormatVersion::V2,\n+ HashMap::new(),\n+ )\n+ .unwrap_err();\n+ assert!(\n+ v2_error\n+ .message()\n+ .contains(\"unknown type is only supported in v3\"),\n+ \"unexpected error: {v2_error}\"\n+ );\n+\n+ let v3_metadata = TableMetadataBuilder::new(\n+ schema_with_unknown_type(),\n+ UnboundPartitionSpec::builder().build(),\n+ SortOrder::unsorted_order(),\n+ TEST_LOCATION.to_string(),\n+ FormatVersion::V3,\n+ HashMap::new(),\n+ )\n+ .unwrap()\n+ .build()\n+ .unwrap()\n+ .metadata;\n+ assert_eq!(v3_metadata.format_version(), FormatVersion::V3);\n+ }\n+\n #[test]\n fn test_minimal_build() {\n let metadata = TableMetadataBuilder::new(\n schema(),\n partition_spec(),\n sort_order(),\n TEST_LOCATION.to_string(),\n FormatVersion::V1,\n HashMap::new(),\n )\n .unwrap()\n .build()\n .unwrap()\n .metadata;\n \n assert_eq!(metadata.format_version, FormatVersion::V1);\n assert_eq!(metadata.location, TEST_LOCATION);\n assert_eq!(metadata.current_schema_id, 0);\n assert_eq!(metadata.default_spec.spec_id(), 0);\n assert_eq!(metadata.default_sort_order_id, 1);\n assert_eq!(metadata.last_partition_id, 1000);\n assert_eq!(metadata.last_column_id, 3);\n assert_eq!(metadata.snapshots.len(), 0);\n assert_eq!(metadata.current_snapshot_id, None);\n assert_eq!(metadata.refs.len(), 0);\n",{"_403":4416,"_405":-5},98,[],"file_0000000014a471f7bc1a782d5601c731",{"_112":284,"_45":100,"_116":284,"_285":4419,"_287":-5,"_288":289,"_150":98,"_138":4420},[102],[4421],1778209129.858279,{"_112":280,"_116":284,"_292":4422},[4423],{"_295":49,"_49":4424},"do you check table format version is v3?",{"_112":113,"_45":98,"_114":-5,"_115":-5,"_116":113,"_117":4427,"_119":4428,"_121":122,"_123":-5,"_125":-5,"_126":4429,"_128":4430,"_130":4431,"_132":304,"_134":-5,"_135":136,"_137":-5,"_138":4432,"_140":-5,"_141":142,"_143":4433,"_145":146,"_147":309,"_148":-5,"_149":-5,"_150":96,"_151":4434,"_153":-5,"_154":-5,"_155":18,"_156":157,"_158":-5},[100],[4465,4466,4467,4468],[],{"_276":4464},{"_273":4463},{"_273":4462},1778207591.504333,{"_45":142,"_160":161,"_162":163,"_164":18,"_165":166,"_167":168,"_169":4449,"_171":-5,"_172":173,"_174":18,"_175":4450,"_177":166,"_178":166,"_179":4451,"_181":4452,"_183":4453,"_185":-5,"_186":4454,"_188":189,"_190":191,"_192":4455,"_58":-5,"_138":194,"_195":4456,"_197":4457,"_199":4458,"_201":18,"_202":18},{"_151":4435},[4436,4437,4438],{"_316":4446,"_318":4447},{"_316":4442,"_318":4443},{"_316":4439,"_318":4440},{"_227":320,"_112":321,"_138":4441},"file_0000000085f8722fa7add50499e29f7a","2026-05-08T01:55:00.720658",{"_227":4444,"_112":321,"_138":4445},"file_0000000036a8722f9a0670aa0b83bfc0","warm_up_git_repo_1778207597","2026-05-08T02:33:17.163626",{"_227":329,"_112":321,"_138":4448},"file_00000000cdb4722fbf8a0fbc45781f44","2026-05-08T01:54:49.207952",{"_266":267,"_268":-5,"_269":-5,"_270":-5,"_271":-5,"_272":-5},[224],{"_224":4459},{"_206":207,"_208":209,"_210":211,"_212":213,"_214":215,"_216":217,"_218":219,"_220":221,"_222":223},{},8,[],{"_205":62},{"_203":62,"_204":166},"\"710081e7-0000-0200-0000-69fd46d50000\"",{"_45":226,"_227":228,"_229":4460,"_231":163,"_232":233,"_234":235,"_236":237,"_238":239,"_240":241,"_242":67,"_243":18,"_244":18,"_245":62,"_246":62,"_247":62,"_248":18,"_249":-5,"_250":251,"_252":-5,"_58":4461},{"_258":259,"_45":260,"_112":261,"_262":263,"_264":265},{"_254":62,"_255":18,"_256":62,"_257":62},[],[],[],{"_112":4408,"_385":5278},{"_112":280,"_116":113,"_292":5255},{"_112":406,"_407":4479},{"_112":381,"_382":4469,"_383":4470,"_385":4471,"_387":-5},"Add helper to parse field defaults and improve validation/error messages; update tests","### Motivation\n\n- Factor duplicated logic for parsing JSON defaults into a single helper and provide clearer error context when a default cannot be converted to the field `Type`.\n- Ensure both `initial-default` and `write-default` are validated and produce consistent error messages for invalid defaults on unknown/unsupported types.\n\n### Description\n\n- Add `parse_field_default` helper that converts an optional `JsonValue` into an optional `Literal` and wraps conversion errors with a message containing the field name and default kind.\n- Replace inline parsing logic in `TryFrom` with calls to `parse_field_default` for `initial-default` and `write-default`.\n- Update the test `test_unknown_type_deserialization_rejects_non_null_default` to iterate both `initial-default` and `write-default` cases and assert the new error message and schema-level deserialization behavior.\n\n### Testing\n\n- Ran unit tests with `cargo test` and the test suite completed successfully, including the updated `test_unknown_type_deserialization_rejects_non_null_defaults` which verifies both default kinds error as expected.\n- The tests for accepting null defaults (`test_unknown_type_deserialization_accepts_null_defaults`) still pass.",{"_112":385,"_388":4410,"_147":309,"_389":-5,"_364":4472,"_391":4473,"_393":4474,"_395":4475,"_397":398,"_399":4476,"_401":4477},"diff --git a/crates/iceberg/src/spec/datatypes.rs b/crates/iceberg/src/spec/datatypes.rs\nindex 14595ee6d0c7d5ee7f03d03760b459dcb89fa5b5..963093f5955b1e97ee51579ceb8ed9c0460f25c2 100644\n--- a/crates/iceberg/src/spec/datatypes.rs\n+++ b/crates/iceberg/src/spec/datatypes.rs\n@@ -544,64 +544,89 @@ pub struct NestedField {\n pub field_type: Box,\n /// Fields may have an optional comment or doc string.\n pub doc: Option,\n /// Used to populate the field’s value for all records that were written before the field was added to the schema\n pub initial_default: Option,\n /// Used to populate the field’s value for any records written after the field was added to the schema, if the writer does not supply the field’s value\n pub write_default: Option,\n }\n \n #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]\n #[serde(rename_all = \"kebab-case\")]\n struct SerdeNestedField {\n pub id: i32,\n pub name: String,\n pub required: bool,\n #[serde(rename = \"type\")]\n pub field_type: Box,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub doc: Option,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub initial_default: Option,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub write_default: Option,\n }\n \n+fn parse_field_default(\n+ default: Option,\n+ field_type: &Type,\n+ field_name: &str,\n+ default_name: &'static str,\n+) -> Result> {\n+ default\n+ .map(|value| {\n+ Literal::try_from_json(value, field_type).map_err(|err| {\n+ crate::Error::new(\n+ err.kind(),\n+ format!(\n+ \"Invalid {default_name} for field {field_name}: {}\",\n+ err.message()\n+ ),\n+ )\n+ .with_source(err)\n+ })\n+ })\n+ .transpose()\n+ .map(Option::flatten)\n+}\n+\n impl TryFrom for NestedField {\n type Error = crate::Error;\n \n fn try_from(value: SerdeNestedField) -> Result {\n- let initial_default = value\n- .initial_default\n- .map(|x| Literal::try_from_json(x, &value.field_type))\n- .transpose()?\n- .flatten();\n- let write_default = value\n- .write_default\n- .map(|x| Literal::try_from_json(x, &value.field_type))\n- .transpose()?\n- .flatten();\n+ let initial_default = parse_field_default(\n+ value.initial_default,\n+ &value.field_type,\n+ &value.name,\n+ \"initial-default\",\n+ )?;\n+ let write_default = parse_field_default(\n+ value.write_default,\n+ &value.field_type,\n+ &value.name,\n+ \"write-default\",\n+ )?;\n \n Ok(NestedField {\n id: value.id,\n name: value.name,\n required: value.required,\n initial_default,\n write_default,\n field_type: value.field_type,\n doc: value.doc,\n })\n }\n }\n \n impl From for SerdeNestedField {\n fn from(value: NestedField) -> Self {\n let initial_default = value.initial_default.map(|x| x.try_into_json(&value.field_type).expect(\"We should have checked this in NestedField::with_initial_default, it can't be converted to json value\"));\n let write_default = value.write_default.map(|x| x.try_into_json(&value.field_type).expect(\"We should have checked this in NestedField::with_write_default, it can't be converted to json value\"));\n SerdeNestedField {\n id: value.id,\n name: value.name,\n required: value.required,\n field_type: value.field_type,\n doc: value.doc,\n initial_default,\n write_default,\ndiff --git a/crates/iceberg/src/spec/schema/mod.rs b/crates/iceberg/src/spec/schema/mod.rs\nindex 4d43e411552e83d011a379fa2e58a83245cb8399..64827b20b57359463829daf2dde6deeeb109ac2b 100644\n--- a/crates/iceberg/src/spec/schema/mod.rs\n+++ b/crates/iceberg/src/spec/schema/mod.rs\n@@ -1244,72 +1244,90 @@ table {\n assert!(\n Schema::builder()\n .with_schema_id(1)\n .with_identifier_field_ids(vec![1])\n .with_fields(vec![\n NestedField::required(1, \"Required\", Type::Primitive(PrimitiveType::String),)\n .into()\n ])\n .build()\n .is_ok()\n );\n assert!(\n Schema::builder()\n .with_schema_id(1)\n .with_identifier_field_ids(vec![1])\n .with_fields(vec![\n NestedField::optional(1, \"Optional\", Type::Primitive(PrimitiveType::String),)\n .into()\n ])\n .build()\n .is_err()\n );\n }\n \n #[test]\n- fn test_unknown_type_deserialization_rejects_non_null_default() {\n- let schema_json = serde_json::json!({\n- \"type\": \"struct\",\n- \"schema-id\": 1,\n- \"fields\": [\n- {\n- \"id\": 1,\n- \"name\": \"empty\",\n- \"required\": false,\n- \"type\": \"unknown\",\n- \"initial-default\": 1\n- }\n- ]\n- });\n+ fn test_unknown_type_deserialization_rejects_non_null_defaults() {\n+ for default_name in [\"initial-default\", \"write-default\"] {\n+ let field_json = serde_json::json!({\n+ \"id\": 1,\n+ \"name\": \"empty\",\n+ \"required\": false,\n+ \"type\": \"unknown\",\n+ default_name: 1\n+ });\n+\n+ let field_error = serde_json::from_value::(field_json).unwrap_err();\n+ assert!(\n+ field_error\n+ .to_string()\n+ .contains(&format!(\"Invalid {default_name} for field empty\")),\n+ \"unexpected error for {default_name}: {field_error}\"\n+ );\n \n- let error = serde_json::from_value::(schema_json).unwrap_err();\n- assert!(\n- error\n- .to_string()\n- .contains(\"did not match any variant of untagged enum SchemaEnum\"),\n- \"unexpected error: {error}\"\n- );\n+ let schema_json = serde_json::json!({\n+ \"type\": \"struct\",\n+ \"schema-id\": 1,\n+ \"fields\": [\n+ {\n+ \"id\": 1,\n+ \"name\": \"empty\",\n+ \"required\": false,\n+ \"type\": \"unknown\",\n+ default_name: 1\n+ }\n+ ]\n+ });\n+\n+ let schema_error = serde_json::from_value::(schema_json).unwrap_err();\n+ assert!(\n+ schema_error\n+ .to_string()\n+ .contains(\"did not match any variant of untagged enum SchemaEnum\"),\n+ \"unexpected error for {default_name}: {schema_error}\"\n+ );\n+ }\n }\n \n #[test]\n fn test_unknown_type_deserialization_accepts_null_defaults() {\n let schema_json = serde_json::json!({\n \"type\": \"struct\",\n \"schema-id\": 1,\n \"fields\": [\n {\n \"id\": 1,\n \"name\": \"empty\",\n \"required\": false,\n \"type\": \"unknown\",\n \"initial-default\": null,\n \"write-default\": null\n }\n ]\n });\n \n serde_json::from_value::(schema_json).unwrap();\n }\n \n #[test]\n fn test_unknown_type_must_be_optional_with_null_defaults() {\n assert!(\n",{"_403":4478,"_405":-5},2,74,"fix(spec): preserve unknown default deserialization errors",[],"file_00000000ee44722f9e06f01f3592cda8",[4480,4481],{"_412":4486,"_414":-5,"_415":4487,"_417":-5},{"_412":3697,"_414":-5,"_415":4482,"_417":-5},[4483],{"_419":420,"_421":4484,"_292":4485,"_424":62},1371,[425,426,427,428,429,430,431,432,433,432,434,435,436,437,438,439,166,3702,166,440,2048,441,166,3703,3704,3705,3706,3707,3708,3709,3710,3711,2052,166,3712,3713,3714,3715,3716,3717,3718,3719,3720,3721,449,3722,166,3723,3724,3725,3726,3727,3728,166,3729,3730,3731,3732,3733,3734,3735,3736,166,3737,3738,166,3739,3740,3741,166,3742,475,166,3743,3744,3745,3746,3747,551,475,166,3748,166,3749,3750,3751,3752,3753,3737,3736,3754,475,166,3755,3756,3757,3758,600,551,166,3759,3760,489,3761,3762,3763,600,551,166,3764,3765,3766,600,551,166,3767,3768,3769,600,551,166,3770,3771,3772,600,551,166,3773,3774,3775,3776,570,166,3777,166,3778,3779,166,3780,3781,3782,3783,3784,166,3785,3786,3787,3788,544,166,3789,653,3790,983,166,3791,166,3792,3793,3794,3795,3796,3797,3798,166,3799,3800,3801,166,3802,544,166,3803,3804,3805,3806,3807,3808,166,3809,3810,3811,3812,3813,3814,570,166,3815,551,166,3816,3817,3818,3819,3820,3821,3822,3823,3819,3824,3825,3822,3823,624,3826,3827,3828,616,624,3829,3830,624,3831,3832,3833,624,3834,570,166,904,551,166,3835,3836,166,3837,3838,3839,3840,3841,3842,616,166,3843,3844,3845,3846,3847,1191,616,3848,3849,616,624,570,166,3850,551,166,3851,3852,3853,3838,3839,3854,3855,616,3843,3856,166,3857,3858,3859,3860,3861,166,3862,616,3848,3849,616,624,570,166,3863,551,166,3864,3865,3866,3867,3868,3869,3870,3871,3872,2332,3873,3874,3875,869,692,693,3876,697,871,872,3877,3878,3879,3880,2383,3881,3819,3882,3883,3822,3823,719,691,692,693,3884,3885,697,698,624,166,3886,3887,3888,3889,3890,3819,3891,3892,3893,3894,3823,3819,3895,3896,3893,3894,3823,3897,624,570,166,904,551,475,166,3898,3899,3900,3901,3902,590,3903,3904,3905,570,551,166,3906,3907,3901,3794,3908,3797,3796,3905,570,551,166,3909,3910,3911,551,166,3912,489,3913,3914,3915,3916,3917,551,166,3918,489,3913,3919,3920,3921,3917,551,166,3922,3923,3924,3925,3917,551,166,3926,2158,3927,3928,551,166,3929,2158,3930,3931,551,166,3932,2158,3933,3934,551,166,3939,2158,3940,3941,551,166,3942,3943,3944,551,166,3945,3946,3947,551,166,3948,3949,3950,551,166,3951,3952,3953,3954,551,166,3955,3956,3957,3958,3959,551,166,3960,3961,3962,551,166,3963,3964,3965,551,475,166,3975,2858,3976,3977,3978,570,3979,551,475,166,1281,1282,2458,166,3980,166,3981,3982,3983,1293,3984,3985,3986,166,1333,3987,3988,3989,3990,3991,166,1385,3992,3993,3994,1304,1398,166,3995,3996,3997,3998,3999,551,166,4000,1385,1549,4001,1299,4002,4003,4004,1303,1304,1398,4005,4006,4007,4008,992,4009,4010,4011,4012,755,992,4013,4014,4015,4016,755,992,4017,4018,4011,4019,616,3160,4020,4021,4022,551,166,4023,1298,1549,4001,1299,4002,4003,4004,1389,2956,4024,4025,4026,4027,4028,4029,2616,2811,4030,871,1396,1389,4031,4032,4033,4034,4035,4028,2616,2811,4036,4037,4038,4039,4040,4041,4042,4043,4044,4045,4046,4047,4042,4043,4048,4029,2616,2811,4030,871,1396,1389,4049,4050,4025,4026,4051,4052,4053,4054,4055,4056,4042,4043,4053,4057,4058,4056,4042,4043,4059,4029,2616,2811,4030,871,1396,4060,4061,4062,1392,4063,1394,4064,1394,1395,871,1396,1303,1304,1305,551,166,1333,4065,4066,4067,4068,4069,4070,475,4071,166,4072,551,166,1333,4073,4074,1549,4075,1299,4076,4077,4078,4079,1303,1480,166,1341,4080,1343,4081,826,551,166,1333,4082,4083,4084,4085,166,4086,551,166,1333,4087,4088,4089,4090,4091,4092,4093,4094,4095,4096,4097,4098,4099,4100,4101,4102,4103,4104,4105,4106,4107,4108,4109,4110,826,166,4111,4112,551,166,1333,4113,4088,4089,4114,4115,4116,4117,4118,4119,4120,4121,4122,4123,4124,4125,4126,4127,4128,4129,4130,4131,4132,4109,4110,826,166,4111,4133,4134,4135,4136,2383,570,551,166,1333,4137,4138,4139,4140,4141,4142,4143,4144,4145,4146,4147,4148,4149,4150,4151,4152,1458,166,4111,4153,4134,4154,4155,4156,2383,570,551,166,1333,4157,4111,166,4158,551,166,1333,4159,4160,166,4161,166,4162,4134,4154,4155,4156,2383,570,551,166,1333,4163,4161,166,1494,4164,4165,826,1494,4166,4167,826,1494,4168,4169,826,166,4170,4171,551,166,1333,4172,4173,3618,3174,4174,3621,3618,4175,4176,3621,3618,4177,4178,3621,3618,3019,1389,2956,4024,4025,4026,4027,4028,4029,2616,2811,4030,610,3621,3618,4179,4180,3621,3618,4181,1389,4031,4032,4182,4034,4035,4183,2616,2811,4036,4037,4184,4039,4040,4185,4042,4043,4044,4045,4186,4047,4042,4043,4048,4029,2616,2811,4030,610,3621,3618,4187,4188,3621,3618,4189,1389,4190,4191,4182,4034,4192,4183,2616,2811,4036,4193,4194,4029,2616,2811,4030,610,3621,3618,4195,4196,3621,3618,4197,4198,3621,3618,4199,1389,4049,4050,4200,4026,4051,4201,4053,4054,4055,4202,4042,4043,4053,4057,4058,4202,4042,4043,4059,4029,2616,2811,4030,610,3621,3618,4203,4204,4205,4206,4207,1394,4208,1394,1395,4209,610,3621,3618,4210,4211,3621,3618,4212,4213,3621,3618,4214,4060,4061,4062,1392,4063,1394,4064,1394,1395,610,3621,3618,4215,4216,3621,3618,4217,4218,3621,1458,166,4111,4219,4134,4220,4221,4222,2383,570,551,166,1333,4223,4111,166,4224,4225,4226,4227,4228,4229,4230,4231,4232,4233,4234,4235,4236,4237,4238,4239,4240,4241,4242,1602,4243,4244,4245,4246,4247,1458,166,1494,4248,4249,3434,4250,4251,4252,826,1494,4248,4253,3434,4250,4251,4254,826,1494,4248,4255,3434,4250,4251,4256,826,1494,4248,4257,3434,4250,4251,4258,826,1494,4248,4259,3434,4250,4251,4260,826,551,166,1333,4261,4111,4262,166,4161,4263,551,166,1333,4264,4265,4266,551,166,1333,4267,4268,1549,4269,4270,1299,4271,4272,4004,1303,1304,1678,166,4273,551,166,1333,4274,4265,4275,1818,1199,4276,1304,1398,166,4277,4278,551,166,1333,4279,4280,1341,4281,4282,4283,4284,4285,4286,4287,4288,4289,4043,4290,4291,4292,4293,2672,1394,4294,729,4295,4296,3517,4297,826,1341,4281,4282,4298,4284,4285,4286,4287,4288,4289,4043,4290,4291,4292,4293,2672,1394,4294,729,4295,4296,3517,4297,826,166,4299,1341,4281,4282,4283,4284,4285,4286,4300,4301,4302,4303,4304,4305,2672,1394,4294,729,4295,4296,3517,4297,826,166,4306,1341,4281,4282,4283,4284,4307,4286,4308,4309,4310,4303,4311,4312,2672,1394,4313,4043,4314,729,4295,4296,3517,4297,826,166,4315,1341,4281,4282,4316,4284,4317,4318,4296,3517,4297,826,1341,4281,4282,4316,4284,4319,4318,4296,3517,4297,826,166,4320,1341,4281,4282,4316,4284,4321,4318,4296,3517,4322,826,1341,4281,4282,4316,4284,4323,4318,4296,3517,4297,826,551,166,1333,4324,4325,4326,4327,4328,4329,4330,4331,660,166,4332,4333,4334,4335,4336,4337,2383,166,4338,4339,4340,4341,1187,4342,4343,4344,4345,4346,1191,4347,660,166,4348,4333,4349,4335,4350,4351,2383,570,551,166,1333,4352,4353,4354,4355,4356,992,4357,4358,4359,4360,4361,4362,616,4109,591,166,4363,551,166,1333,4364,1341,4281,4282,4284,4365,4296,3517,4322,826,166,4366,1549,1299,4367,1303,1304,1678,1341,4368,1343,4369,826,166,4370,1549,1299,4371,4372,1824,1303,1304,1678,1341,4373,1343,4374,826,551,475],"crates/iceberg/src/spec/datatypes.rs",[4488],{"_419":420,"_421":4489,"_292":4490,"_424":62},1364,[425,426,427,428,429,430,431,432,433,432,434,435,436,437,438,439,166,4491,4492,4493,2047,4494,4495,4496,166,4497,4498,4499,4500,166,4501,4502,3717,4503,4504,166,4505,4506,4507,4508,4509,4510,166,4511,4512,166,4513,4514,166,4515,166,4516,4517,4518,4519,4520,570,166,4521,4522,166,4523,4524,4525,4526,4527,166,4528,4529,4530,4531,4532,1191,616,624,166,4533,591,475,166,4534,4535,4536,4537,4538,4539,4540,4541,4542,4543,4544,475,166,4545,4546,2859,4547,4548,4549,4550,570,551,475,166,4551,4552,4553,4554,4555,551,166,4556,4553,4557,4558,551,166,4559,4553,4560,4561,551,166,4562,4563,4564,4565,748,4566,570,551,166,4567,4568,4569,4570,748,4566,570,551,166,4571,4553,4572,4573,4574,4575,826,4576,551,166,4577,4553,4578,4573,4579,4580,826,4581,551,166,4582,4553,4583,4573,4579,4580,826,4584,551,166,4585,4553,4586,4587,4588,4589,594,551,475,166,4590,4591,4592,551,475,166,4593,4594,4595,551,475,166,4596,4597,4598,551,475,166,4599,4600,4601,551,475,166,4602,4603,4604,4605,4606,4607,4608,4609,4610,4611,4612,4613,4614,4615,4616,4617,4618,4619,4620,4621,4622,4623,4624,4625,4626,4627,4628,4629,4630,4631,4632,4633,4634,4635,4636,4637,4638,4639,4640,4641,4642,4643,4644,4645,4646,475,166,4647,4648,4649,4587,4650,4651,4652,4653,4654,4655,4656,4657,4658,4659,4660,4661,4662,4663,4664,4665,4666,594,551,475,166,4667,4668,4669,4670,4671,551,475,166,4672,4673,4674,4675,4676,551,475,166,4677,4673,4674,4678,4679,4680,4681,4682,748,4683,570,551,475,166,4684,4668,4669,2859,4685,4686,624,4687,4688,570,551,475,166,4689,4690,4691,4692,4693,4694,4695,4696,166,4697,4698,4699,4700,475,166,4701,4702,4703,4704,4705,4706,4707,4708,4709,475,166,4710,4690,4711,4712,4713,4714,166,4715,4716,4717,4718,475,166,4719,4720,4721,475,166,4722,4546,2859,4723,4724,4725,4726,4727,4728,4685,4729,624,4730,4731,4732,4733,4734,4735,4736,4737,4738,4739,570,551,475,166,4740,4741,4742,4743,4744,3753,4745,4746,4747,4746,4748,475,166,4749,4673,4674,4750,4751,4752,4753,4754,570,166,4755,166,4756,4757,166,4758,4759,624,166,4760,4761,4762,4763,4764,4765,4766,4767,4768,4769,4770,2927,3017,4771,4772,4773,2927,4774,3017,1191,616,4775,4776,166,4777,624,570,166,4778,4779,551,475,166,4780,4781,4782,562,998,4783,4784,570,551,166,4785,4786,4787,551,166,4788,4789,4790,4791,995,4792,4793,551,166,4794,4795,4796,551,166,4797,4798,4790,4799,4800,4801,4802,4803,871,995,4804,4793,551,166,4805,4806,4807,551,475,166,4808,3744,4809,551,475,166,4810,166,4811,4812,166,4813,4814,551,475,166,4815,4546,4816,3775,4817,570,4818,551,475,166,4819,4820,4821,4822,4823,4824,4825,4826,4827,4828,4829,4830,4831,4832,4833,4834,4835,4836,4837,4838,475,166,2863,2864,4839,4826,4828,4830,4840,4832,4841,4834,4841,4842,4841,4843,475,166,4844,4845,4846,4847,4848,4849,4850,4851,4852,4853,4854,693,4855,4856,697,871,4857,995,999,4858,4859,475,166,4860,4861,166,4862,4863,4864,4865,4866,4867,3784,4868,4869,4865,4866,4870,3784,166,4871,4872,4873,4874,4875,4876,4877,4878,999,551,475,166,4879,4880,4881,4882,4883,4872,4873,4874,4877,4878,4875,4876,570,551,475,166,4884,4885,166,4886,4887,4888,562,4889,4890,4891,4892,4893,4894,4895,570,551,166,4896,4897,4898,551,166,4899,4900,4901,551,166,4902,4903,4904,551,166,4905,4906,4907,551,166,4908,4909,4910,551,166,4911,4912,4913,600,551,166,4914,4915,4916,600,551,166,4914,4917,4918,600,551,166,4919,4920,4921,600,551,475,166,4922,4546,4923,4924,4925,4926,748,4927,570,4928,4929,4930,570,904,551,475,166,4534,4931,4932,4933,4934,4935,475,166,4936,4937,4938,4939,551,475,166,4940,2452,4941,166,4942,166,4943,3982,3983,1293,166,4944,4945,2472,4946,4947,4948,4949,4950,4951,4952,4953,4954,4949,4955,4953,4947,4956,4949,4957,4958,4959,4960,4961,4953,4962,551,166,4963,4964,2549,4965,4966,4967,4968,4969,4970,4971,4972,4973,4974,729,1824,2637,4975,4966,4976,4977,4978,4979,4980,4981,4982,4983,4984,4985,4986,729,1824,2637,4987,4988,616,4989,624,570,551,166,4990,4991,2549,4992,4993,4994,4995,4996,755,4997,4998,4999,5000,5001,5002,5003,755,5004,5005,5006,755,5007,624,570,551,475,166,4534,5008,5009,5010,5011,5012,5013,5014,5015,5016,475,166,5017,5018,5019,562,5020,5021,570,551,166,5022,5023,562,5024,5025,570,551,166,5026,5027,562,5024,5028,570,551,475,166,1281,1282,2886,2461,166,1286,5029,166,5030,5031,2899,166,2900,5032,5033,166,5034,551,166,1333,5035,5036,5037,5038,5039,5040,5041,5042,5043,5044,5045,5046,5047,5048,5049,5050,5051,5052,5053,5054,5055,5056,5057,551,3195,166,5058,5059,5060,5061,4307,5062,5063,5064,729,1824,5065,2811,5066,2811,5067,2811,5068,2811,4285,5069,5070,5071,729,1824,4285,5072,5073,5074,5075,5076,5077,729,1824,5078,2811,5079,2811,4285,5080,5081,5082,729,1824,4285,5083,5084,5085,729,1824,4285,5086,5087,5088,729,1824,4285,5089,5090,5091,729,1824,5092,2811,4285,5093,5094,5095,729,1824,4285,5096,5097,5098,729,1824,4285,5099,5100,5101,729,1824,2929,5102,5103,566,594,551,166,1333,5104,5036,679,4354,4356,992,4357,5105,5106,5107,5108,5109,5110,5111,5112,4359,5113,616,4109,570,2950,166,5058,5059,5060,5061,5114,5115,5116,5117,5118,5119,5120,5121,5117,5118,5119,2811,5122,2929,5123,5124,566,594,551,166,1333,5125,5036,4708,5126,5127,5037,5128,5129,5130,5131,5132,5133,4624,5037,5134,5135,5136,5137,4624,5037,5138,5139,5130,5140,5038,5039,5141,5142,5143,5144,5145,5146,5141,5147,5148,5149,5145,5146,5141,5150,5151,5144,5152,3105,5057,5153,551,5154,475,5155,166,5156,5157,5158,5159,3465,5160,5161,5162,5163,3465,5160,5161,1396,5164,5165,4177,5166,5167,5168,2811,5169,2811,5170,5171,586,5172,5173,166,5174,551,166,1333,5175,5036,679,5176,5177,5178,5179,570,2950,166,5058,5059,5180,5181,1413,3117,4209,871,1396,566,826,551,166,1333,5182,5036,679,5183,5184,5185,5186,5187,5188,570,2950,166,5058,5059,5189,5190,1824,5191,3115,3114,5192,871,1396,566,826,166,5058,5059,5193,3019,5194,4179,5195,5196,826,551,166,1333,5197,5036,679,5183,5184,5198,5186,5187,5199,570,2950,166,5058,5059,5189,5200,1824,5191,3115,3117,5192,871,1396,566,826,166,5058,5059,5193,3019,5201,4179,5194,5196,826,551,166,1333,5202,5036,679,5183,5184,5198,5186,5203,5199,570,2950,166,5058,5059,5204,3019,5201,4179,5194,5196,826,551,166,1333,5205,5206,5207,5208,5209,5210,4134,5211,5212,5213,2383,570,166,5214,5215,551,166,1333,5216,5217,5218,5219,5220,5221,5222,3618,5223,5224,5225,755,5226,3621,5227,5228,5229,5230,5231,5232,3618,5233,5234,3621,5235,5236,5209,5237,5238,570,166,5239,551,166,1333,5240,5241,5242,5243,679,4354,4356,5244,4109,570,2950,166,5245,5246,166,5247,5248,551,166,1333,5249,5250,5243,679,5176,4356,5244,4109,570,2950,166,5251,1341,3607,5252,826,1341,5253,1614,1615,5254,826,551,475],"/*!"," * Data Types"," */","use std::fmt;","use std::ops::Index;","use std::sync::{Arc, OnceLock};","use ::serde::de::{MapAccess, Visitor};","use serde::de::{Error, IntoDeserializer};","use serde::{Deserialize, Deserializer, Serialize, Serializer, de};","use serde_json::Value as JsonValue;","use super::values::Literal;","use crate::ensure_data_valid;","use crate::spec::PrimitiveLiteral;","use crate::spec::datatypes::_decimal::{MAX_PRECISION, REQUIRED_LENGTH};","/// Field name for list type.","pub const LIST_FIELD_NAME: &str = \"element\";","/// Field name for map type's key.","pub const MAP_KEY_FIELD_NAME: &str = \"key\";","/// Field name for map type's value.","pub const MAP_VALUE_FIELD_NAME: &str = \"value\";","pub(crate) const MAX_DECIMAL_BYTES: u32 = 24;","pub(crate) const MAX_DECIMAL_PRECISION: u32 = 38;","mod _decimal {"," use once_cell::sync::Lazy;"," use crate::spec::{MAX_DECIMAL_BYTES, MAX_DECIMAL_PRECISION};"," // Max precision of bytes, starts from 1"," pub(super) static MAX_PRECISION: Lazy<[u32; MAX_DECIMAL_BYTES as usize]> = Lazy::new(|| {"," let mut ret: [u32; 24] = [0; 24];"," for (i, prec) in ret.iter_mut().enumerate() {"," *prec = 2f64.powi((8 * (i + 1) - 1) as i32).log10().floor() as u32;"," ret"," });"," // Required bytes of precision, starts from 1"," pub(super) static REQUIRED_LENGTH: Lazy<[u32; MAX_DECIMAL_PRECISION as usize]> ="," Lazy::new(|| {"," let mut ret: [u32; MAX_DECIMAL_PRECISION as usize] ="," [0; MAX_DECIMAL_PRECISION as usize];"," for (i, required_len) in ret.iter_mut().enumerate() {"," for j in 0..MAX_PRECISION.len() {"," if MAX_PRECISION[j] >= ((i + 1) as u32) {"," *required_len = (j + 1) as u32;"," break;"," ret","#[derive(Debug, PartialEq, Eq, Clone)]","/// All data types are either primitives or nested types, which are maps, lists, or structs.","pub enum Type {"," /// Primitive types"," Primitive(PrimitiveType),"," /// Struct type"," Struct(StructType),"," /// List type."," List(ListType),"," /// Map type"," Map(MapType),","impl fmt::Display for Type {"," fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {"," Type::Primitive(primitive) => write!(f, \"{primitive}\"),"," Type::Struct(s) => write!(f, \"{s}\"),"," Type::List(_) => write!(f, \"list\"),"," Type::Map(_) => write!(f, \"map\"),","impl Type {"," /// Whether the type is primitive type."," #[inline(always)]"," pub fn is_primitive(&self) -> bool {"," matches!(self, Type::Primitive(_))"," /// Whether the type is struct type."," pub fn is_struct(&self) -> bool {"," matches!(self, Type::Struct(_))"," /// Whether the type is nested type."," pub fn is_nested(&self) -> bool {"," matches!(self, Type::Struct(_) | Type::List(_) | Type::Map(_))"," /// Convert Type to reference of PrimitiveType"," pub fn as_primitive_type(&self) -> Option<&PrimitiveType> {"," if let Type::Primitive(primitive_type) = self {"," Some(primitive_type)"," None"," /// Convert Type to StructType"," pub fn to_struct_type(self) -> Option {"," if let Type::Struct(struct_type) = self {"," Some(struct_type)"," /// Return max precision for decimal given [`num_bytes`] bytes."," pub fn decimal_max_precision(num_bytes: u32) -> Result {"," ensure_data_valid!("," num_bytes > 0 && num_bytes <= MAX_DECIMAL_BYTES,"," \"Decimal length larger than {MAX_DECIMAL_BYTES} is not supported: {num_bytes}\","," Ok(MAX_PRECISION[num_bytes as usize - 1])"," /// Returns minimum bytes required for decimal with [`precision`]."," pub fn decimal_required_bytes(precision: u32) -> Result {"," precision > 0 && precision <= MAX_DECIMAL_PRECISION,"," \"Decimals with precision larger than {MAX_DECIMAL_PRECISION} are not supported: {precision}\","," Ok(REQUIRED_LENGTH[precision as usize - 1])"," /// Creates decimal type."," pub fn decimal(precision: u32, scale: u32) -> Result {"," Ok(Type::Primitive(PrimitiveType::Decimal { precision, scale }))"," /// Check if it's float or double type."," pub fn is_floating_type(&self) -> bool {"," matches!("," self,"," Type::Primitive(PrimitiveType::Float) | Type::Primitive(PrimitiveType::Double)","impl From for Type {"," fn from(value: PrimitiveType) -> Self {"," Self::Primitive(value)","impl From for Type {"," fn from(value: StructType) -> Self {"," Type::Struct(value)","impl From for Type {"," fn from(value: ListType) -> Self {"," Type::List(value)","impl From for Type {"," fn from(value: MapType) -> Self {"," Type::Map(value)","/// Primitive data types","#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Hash)]","#[serde(rename_all = \"lowercase\", remote = \"Self\")]","pub enum PrimitiveType {"," /// Default / null column type used when a more specific type is not known."," Unknown,"," /// True or False"," Boolean,"," /// 32-bit signed integer"," Int,"," /// 64-bit signed integer"," Long,"," /// 32-bit IEEE 754 floating point."," Float,"," /// 64-bit IEEE 754 floating point."," Double,"," /// Fixed point decimal"," Decimal {"," /// Precision, must be 38 or less"," precision: u32,"," /// Scale"," scale: u32,"," },"," /// Calendar date without timezone or time."," Date,"," /// Time of day in microsecond precision, without date or timezone."," Time,"," /// Timestamp in microsecond precision, without timezone"," Timestamp,"," /// Timestamp in microsecond precision, with timezone"," Timestamptz,"," /// Timestamp in nanosecond precision, without timezone"," #[serde(rename = \"timestamp_ns\")]"," TimestampNs,"," /// Timestamp in nanosecond precision with timezone"," #[serde(rename = \"timestamptz_ns\")]"," TimestamptzNs,"," /// Arbitrary-length character sequences encoded in utf-8"," String,"," /// Universally Unique Identifiers, should use 16-byte fixed"," Uuid,"," /// Fixed length byte array"," Fixed(u64),"," /// Arbitrary-length byte array."," Binary,","impl PrimitiveType {"," /// Check whether literal is compatible with the type."," pub fn compatible(&self, literal: &PrimitiveLiteral) -> bool {"," (self, literal),"," (PrimitiveType::Boolean, PrimitiveLiteral::Boolean(_))"," | (PrimitiveType::Int, PrimitiveLiteral::Int(_))"," | (PrimitiveType::Long, PrimitiveLiteral::Long(_))"," | (PrimitiveType::Float, PrimitiveLiteral::Float(_))"," | (PrimitiveType::Double, PrimitiveLiteral::Double(_))"," | (PrimitiveType::Decimal { .. }, PrimitiveLiteral::Int128(_))"," | (PrimitiveType::Date, PrimitiveLiteral::Int(_))"," | (PrimitiveType::Time, PrimitiveLiteral::Long(_))"," | (PrimitiveType::Timestamp, PrimitiveLiteral::Long(_))"," | (PrimitiveType::Timestamptz, PrimitiveLiteral::Long(_))"," | (PrimitiveType::TimestampNs, PrimitiveLiteral::Long(_))"," | (PrimitiveType::TimestamptzNs, PrimitiveLiteral::Long(_))"," | (PrimitiveType::String, PrimitiveLiteral::String(_))"," | (PrimitiveType::Uuid, PrimitiveLiteral::UInt128(_))"," | (PrimitiveType::Fixed(_), PrimitiveLiteral::Binary(_))"," | (PrimitiveType::Binary, PrimitiveLiteral::Binary(_))","impl Serialize for Type {"," fn serialize(&self, serializer: S) -> std::result::Result"," where S: Serializer {"," let type_serde = _serde::SerdeType::from(self);"," type_serde.serialize(serializer)","impl<'de> Deserialize<'de> for Type {"," fn deserialize(deserializer: D) -> std::result::Result"," where D: Deserializer<'de> {"," let type_serde = _serde::SerdeType::deserialize(deserializer)?;"," Ok(Type::from(type_serde))","impl<'de> Deserialize<'de> for PrimitiveType {"," let s = String::deserialize(deserializer)?;"," if s.starts_with(\"decimal\") {"," deserialize_decimal(s.into_deserializer())"," } else if s.starts_with(\"fixed\") {"," deserialize_fixed(s.into_deserializer())"," PrimitiveType::deserialize(s.into_deserializer())","impl Serialize for PrimitiveType {"," PrimitiveType::Decimal { precision, scale } => {"," serialize_decimal(precision, scale, serializer)"," PrimitiveType::Fixed(l) => serialize_fixed(l, serializer),"," _ => PrimitiveType::serialize(self, serializer),","fn deserialize_decimal<'de, D>(deserializer: D) -> std::result::Result","where D: Deserializer<'de> {"," let s = String::deserialize(deserializer)?;"," let (precision, scale) = s"," .trim_start_matches(r\"decimal(\")"," .trim_end_matches(')')"," .split_once(',')"," .ok_or_else(|| D::Error::custom(\"Decimal requires precision and scale: {s}\"))?;"," Ok(PrimitiveType::Decimal {"," precision: precision.trim().parse().map_err(D::Error::custom)?,"," scale: scale.trim().parse().map_err(D::Error::custom)?,"," })","fn serialize_decimal("," precision: &u32,"," scale: &u32,"," serializer: S,",") -> std::result::Result","where"," S: Serializer,","{"," serializer.serialize_str(&format!(\"decimal({precision},{scale})\"))","fn deserialize_fixed<'de, D>(deserializer: D) -> std::result::Result"," let fixed = String::deserialize(deserializer)?"," .trim_start_matches(r\"fixed[\")"," .trim_end_matches(']')"," .to_owned();"," fixed"," .parse()"," .map(PrimitiveType::Fixed)"," .map_err(D::Error::custom)","fn serialize_fixed(value: &u64, serializer: S) -> std::result::Result","where S: Serializer {"," serializer.serialize_str(&format!(\"fixed[{value}]\"))","impl fmt::Display for PrimitiveType {"," PrimitiveType::Unknown => write!(f, \"unknown\"),"," PrimitiveType::Boolean => write!(f, \"boolean\"),"," PrimitiveType::Int => write!(f, \"int\"),"," PrimitiveType::Long => write!(f, \"long\"),"," PrimitiveType::Float => write!(f, \"float\"),"," PrimitiveType::Double => write!(f, \"double\"),"," write!(f, \"decimal({precision},{scale})\")"," PrimitiveType::Date => write!(f, \"date\"),"," PrimitiveType::Time => write!(f, \"time\"),"," PrimitiveType::Timestamp => write!(f, \"timestamp\"),"," PrimitiveType::Timestamptz => write!(f, \"timestamptz\"),"," PrimitiveType::TimestampNs => write!(f, \"timestamp_ns\"),"," PrimitiveType::TimestamptzNs => write!(f, \"timestamptz_ns\"),"," PrimitiveType::String => write!(f, \"string\"),"," PrimitiveType::Uuid => write!(f, \"uuid\"),"," PrimitiveType::Fixed(size) => write!(f, \"fixed({size})\"),"," PrimitiveType::Binary => write!(f, \"binary\"),","/// DataType for a specific struct","#[derive(Debug, Serialize, Clone, Default)]","#[serde(rename = \"struct\", tag = \"type\")]","pub struct StructType {"," /// Struct fields"," /// Lookup for index by field id"," #[serde(skip_serializing)]"," id_lookup: OnceLock>,"," name_lookup: OnceLock>,","impl<'de> Deserialize<'de> for StructType {"," #[derive(Deserialize)]"," #[serde(field_identifier, rename_all = \"lowercase\")]"," enum Field {"," Type,"," Fields,"," struct StructTypeVisitor;"," impl<'de> Visitor<'de> for StructTypeVisitor {"," type Value = StructType;"," fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {"," formatter.write_str(\"struct\")"," fn visit_map(self, mut map: V) -> std::result::Result"," where V: MapAccess<'de> {"," let mut fields = None;"," while let Some(key) = map.next_key()? {"," match key {"," Field::Type => {"," let type_val: String = map.next_value()?;"," if type_val != \"struct\" {"," return Err(serde::de::Error::custom(format!("," \"expected type 'struct', got '{type_val}'\""," )));"," Field::Fields => {"," if fields.is_some() {"," return Err(serde::de::Error::duplicate_field(\"fields\"));"," fields = Some(map.next_value()?);"," let fields: Vec ="," fields.ok_or_else(|| de::Error::missing_field(\"fields\"))?;"," Ok(StructType::new(fields))"," const FIELDS: &[&str] = &[\"type\", \"fields\"];"," deserializer.deserialize_struct(\"struct\", FIELDS, StructTypeVisitor)","impl StructType {"," /// Creates a struct type with the given fields."," pub fn new(fields: Vec) -> Self {"," id_lookup: OnceLock::new(),"," name_lookup: OnceLock::new(),"," /// Get struct field with certain id"," pub fn field_by_id(&self, id: i32) -> Option<&NestedFieldRef> {"," self.field_id_to_index(id).map(|idx| &self.fields[idx])"," fn field_id_to_index(&self, field_id: i32) -> Option {"," self.id_lookup"," .get_or_init(|| {"," HashMap::from_iter(self.fields.iter().enumerate().map(|(i, x)| (x.id, i)))"," .get(&field_id)"," .copied()"," /// Get struct field with certain field name"," pub fn field_by_name(&self, name: &str) -> Option<&NestedFieldRef> {"," self.field_name_to_index(name).map(|idx| &self.fields[idx])"," fn field_name_to_index(&self, name: &str) -> Option {"," self.name_lookup"," HashMap::from_iter("," self.fields"," .iter()"," .enumerate()"," .map(|(i, x)| (x.name.clone(), i)),"," .get(name)"," /// Get fields."," pub fn fields(&self) -> &[NestedFieldRef] {"," &self.fields","impl PartialEq for StructType {"," self.fields == other.fields","impl Eq for StructType {}","impl Index for StructType {"," type Output = NestedField;"," fn index(&self, index: usize) -> &Self::Output {"," &self.fields[index]","impl fmt::Display for StructType {"," write!(f, \"struct<\")?;"," write!(f, \"{}\", field.field_type)?;"," write!(f, \">\")","#[derive(Debug, PartialEq, Serialize, Deserialize, Eq, Clone)]","#[serde(try_from = \"SerdeNestedField\", into = \"SerdeNestedField\")]","/// A struct is a tuple of typed values. Each field in the tuple is named and has an integer id that is unique in the table schema.","/// Each field can be either optional or required, meaning that values can (or cannot) be null. Fields may be any type.","/// Fields may have an optional comment or doc string. Fields can have default values.","pub struct NestedField {"," /// Id unique in table schema"," pub id: i32,"," /// Field Name"," pub name: String,"," /// Optional or required"," pub required: bool,"," /// Datatype"," pub field_type: Box,"," /// Fields may have an optional comment or doc string."," pub doc: Option,"," /// Used to populate the field’s value for all records that were written before the field was added to the schema"," pub initial_default: Option,"," /// Used to populate the field’s value for any records written after the field was added to the schema, if the writer does not supply the field’s value"," pub write_default: Option,","struct SerdeNestedField {"," #[serde(rename = \"type\")]"," #[serde(skip_serializing_if = \"Option::is_none\")]"," pub initial_default: Option,"," pub write_default: Option,","fn parse_field_default("," default: Option,"," field_type: &Type,"," field_name: &str,"," default_name: &'static str,",") -> Result> {"," default"," .map(|value| {"," Literal::try_from_json(value, field_type).map_err(|err| {"," crate::Error::new("," err.kind(),"," \"Invalid {default_name} for field {field_name}: {}\","," err.message()"," .with_source(err)"," .transpose()"," .map(Option::flatten)","impl TryFrom for NestedField {"," type Error = crate::Error;"," fn try_from(value: SerdeNestedField) -> Result {"," let initial_default = parse_field_default("," value.initial_default,"," &value.field_type,"," &value.name,"," \"initial-default\","," let write_default = parse_field_default("," value.write_default,"," \"write-default\","," Ok(NestedField {"," id: value.id,"," name: value.name,"," required: value.required,"," initial_default,"," write_default,"," field_type: value.field_type,"," doc: value.doc,","impl From for SerdeNestedField {"," fn from(value: NestedField) -> Self {"," let initial_default = value.initial_default.map(|x| x.try_into_json(&value.field_type).expect(\"We should have checked this in NestedField::with_initial_default, it can't be converted to json value\"));"," let write_default = value.write_default.map(|x| x.try_into_json(&value.field_type).expect(\"We should have checked this in NestedField::with_write_default, it can't be converted to json value\"));"," SerdeNestedField {","/// Reference to nested field.","pub type NestedFieldRef = Arc;","impl NestedField {"," /// Construct a new field."," pub fn new(id: i32, name: impl ToString, field_type: Type, required: bool) -> Self {"," id,"," name: name.to_string(),"," required,"," field_type: Box::new(field_type),"," doc: None,"," initial_default: None,"," write_default: None,"," /// Construct a required field."," pub fn required(id: i32, name: impl ToString, field_type: Type) -> Self {"," Self::new(id, name, field_type, true)"," /// Construct an optional field."," pub fn optional(id: i32, name: impl ToString, field_type: Type) -> Self {"," Self::new(id, name, field_type, false)"," /// Construct list type's element field."," pub fn list_element(id: i32, field_type: Type, required: bool) -> Self {"," Self::new(id, LIST_FIELD_NAME, field_type, required)"," /// Construct map type's key field."," pub fn map_key_element(id: i32, field_type: Type) -> Self {"," Self::required(id, MAP_KEY_FIELD_NAME, field_type)"," /// Construct map type's value field."," pub fn map_value_element(id: i32, field_type: Type, required: bool) -> Self {"," Self::new(id, MAP_VALUE_FIELD_NAME, field_type, required)"," /// Set the field's doc."," pub fn with_doc(mut self, doc: impl ToString) -> Self {"," self.doc = Some(doc.to_string());"," /// Set the field's initial default value."," pub fn with_initial_default(mut self, value: Literal) -> Self {"," self.initial_default = Some(value);"," pub fn with_write_default(mut self, value: Literal) -> Self {"," self.write_default = Some(value);"," /// Set the id of the field."," pub(crate) fn with_id(mut self, id: i32) -> Self {"," self.id = id;","impl fmt::Display for NestedField {"," write!(f, \"{}: \", self.id)?;"," write!(f, \"{}: \", self.name)?;"," if self.required {"," write!(f, \"required \")?;"," write!(f, \"optional \")?;"," write!(f, \"{} \", self.field_type)?;"," if let Some(doc) = &self.doc {"," write!(f, \"{doc}\")?;","/// A list is a collection of values with some element type. The element field has an integer id that is unique in the table schema.","/// Elements can be either optional or required. Element types may be any type.","pub struct ListType {"," /// Element field of list type."," pub element_field: NestedFieldRef,","impl ListType {"," /// Construct a list type with the given element field."," pub fn new(element_field: NestedFieldRef) -> Self {"," Self { element_field }","/// Module for type serialization/deserialization."," use std::borrow::Cow;"," use serde_derive::{Deserialize, Serialize};"," use crate::spec::datatypes::Type::Map;"," /// List type for serialization and deserialization"," #[derive(Serialize, Deserialize)]"," pub(super) enum SerdeType<'a> {"," #[serde(rename_all = \"kebab-case\")]"," List {"," r#type: String,"," element_id: i32,"," element_required: bool,"," element: Cow<'a, Type>,"," },"," Struct {"," fields: Cow<'a, [NestedFieldRef]>,"," Map {"," key_id: i32,"," key: Cow<'a, Type>,"," value_id: i32,"," value_required: bool,"," value: Cow<'a, Type>,"," Primitive(PrimitiveType),"," impl From> for Type {"," fn from(value: SerdeType) -> Self {"," SerdeType::List {"," r#type: _,"," element_id,"," element_required,"," element,"," } => Self::List(ListType {"," element_field: NestedField::list_element("," element_id,"," element.into_owned(),"," element_required,"," SerdeType::Map {"," key_id,"," key,"," value_id,"," value_required,"," value,"," } => Map(MapType {"," key_field: NestedField::map_key_element(key_id, key.into_owned()).into(),"," value_field: NestedField::map_value_element("," value_id,"," value.into_owned(),"," value_required,"," SerdeType::Struct { r#type: _, fields } => {"," Self::Struct(StructType::new(fields.into_owned()))"," SerdeType::Primitive(p) => Self::Primitive(p),"," impl<'a> From<&'a Type> for SerdeType<'a> {"," fn from(value: &'a Type) -> Self {"," Type::List(list) => SerdeType::List {"," r#type: \"list\".to_string(),"," element_id: list.element_field.id,"," element_required: list.element_field.required,"," element: Cow::Borrowed(&list.element_field.field_type),"," Type::Map(map) => SerdeType::Map {"," r#type: \"map\".to_string(),"," key_id: map.key_field.id,"," key: Cow::Borrowed(&map.key_field.field_type),"," value_id: map.value_field.id,"," value_required: map.value_field.required,"," value: Cow::Borrowed(&map.value_field.field_type),"," Type::Struct(s) => SerdeType::Struct {"," r#type: \"struct\".to_string(),"," fields: Cow::Borrowed(&s.fields),"," Type::Primitive(p) => SerdeType::Primitive(p.clone()),","/// A map is a collection of key-value pairs with a key type and a value type.","/// Both the key field and value field each have an integer id that is unique in the table schema.","/// Map keys are required and map values can be either optional or required.","/// Both map keys and map values may be any type, including nested types.","pub struct MapType {"," /// Field for key."," pub key_field: NestedFieldRef,"," /// Field for value."," pub value_field: NestedFieldRef,","impl MapType {"," /// Construct a map type with the given key and value fields."," pub fn new(key_field: NestedFieldRef, value_field: NestedFieldRef) -> Self {"," key_field,"," value_field,"," /// Construct an optional map type with the given key and value fields."," pub fn optional(key_id: i32, key_type: Type, value_id: i32, value_type: Type) -> Self {"," key_field: NestedField::map_key_element(key_id, key_type).into(),"," value_field: NestedField::map_value_element(value_id, value_type, false).into(),"," /// Construct a required map type with the given key and value fields."," pub fn required(key_id: i32, key_type: Type, value_id: i32, value_type: Type) -> Self {"," value_field: NestedField::map_value_element(value_id, value_type, true).into(),"," use crate::spec::values::PrimitiveLiteral;"," fn check_type_serde(json: &str, expected_type: Type) {"," let desered_type: Type = serde_json::from_str(json).unwrap();"," let parsed_json_value = serde_json::from_str::(&sered_json).unwrap();"," let raw_json_value = serde_json::from_str::(json).unwrap();"," assert_eq!(parsed_json_value, raw_json_value);"," fn primitive_type_serde() {"," let record = r#\""," {"," \"type\": \"struct\","," \"fields\": ["," {\"id\": 17, \"name\": \"unknown_field\", \"required\": false, \"type\": \"unknown\"},"," {\"id\": 1, \"name\": \"bool_field\", \"required\": true, \"type\": \"boolean\"},"," {\"id\": 2, \"name\": \"int_field\", \"required\": true, \"type\": \"int\"},"," {\"id\": 3, \"name\": \"long_field\", \"required\": true, \"type\": \"long\"},"," {\"id\": 4, \"name\": \"float_field\", \"required\": true, \"type\": \"float\"},"," {\"id\": 5, \"name\": \"double_field\", \"required\": true, \"type\": \"double\"},"," {\"id\": 6, \"name\": \"decimal_field\", \"required\": true, \"type\": \"decimal(9,2)\"},"," {\"id\": 7, \"name\": \"date_field\", \"required\": true, \"type\": \"date\"},"," {\"id\": 8, \"name\": \"time_field\", \"required\": true, \"type\": \"time\"},"," {\"id\": 9, \"name\": \"timestamp_field\", \"required\": true, \"type\": \"timestamp\"},"," {\"id\": 10, \"name\": \"timestamptz_field\", \"required\": true, \"type\": \"timestamptz\"},"," {\"id\": 11, \"name\": \"timestamp_ns_field\", \"required\": true, \"type\": \"timestamp_ns\"},"," {\"id\": 12, \"name\": \"timestamptz_ns_field\", \"required\": true, \"type\": \"timestamptz_ns\"},"," {\"id\": 13, \"name\": \"uuid_field\", \"required\": true, \"type\": \"uuid\"},"," {\"id\": 14, \"name\": \"fixed_field\", \"required\": true, \"type\": \"fixed[10]\"},"," {\"id\": 15, \"name\": \"binary_field\", \"required\": true, \"type\": \"binary\"},"," {\"id\": 16, \"name\": \"string_field\", \"required\": true, \"type\": \"string\"}"," ]"," check_type_serde("," record,"," Type::Struct(StructType {"," fields: vec!["," 17,"," \"unknown_field\","," Type::Primitive(PrimitiveType::Unknown),"," NestedField::required(1, \"bool_field\", Type::Primitive(PrimitiveType::Boolean))"," NestedField::required(2, \"int_field\", Type::Primitive(PrimitiveType::Int))"," NestedField::required(3, \"long_field\", Type::Primitive(PrimitiveType::Long))"," NestedField::required(4, \"float_field\", Type::Primitive(PrimitiveType::Float))"," 5,"," \"double_field\","," Type::Primitive(PrimitiveType::Double),"," 6,"," \"decimal_field\","," Type::Primitive(PrimitiveType::Decimal {"," precision: 9,"," scale: 2,"," }),"," NestedField::required(7, \"date_field\", Type::Primitive(PrimitiveType::Date))"," NestedField::required(8, \"time_field\", Type::Primitive(PrimitiveType::Time))"," 9,"," \"timestamp_field\","," Type::Primitive(PrimitiveType::Timestamp),"," 10,"," \"timestamptz_field\","," Type::Primitive(PrimitiveType::Timestamptz),"," 11,"," \"timestamp_ns_field\","," Type::Primitive(PrimitiveType::TimestampNs),"," 12,"," \"timestamptz_ns_field\","," Type::Primitive(PrimitiveType::TimestamptzNs),"," NestedField::required(13, \"uuid_field\", Type::Primitive(PrimitiveType::Uuid))"," 14,"," \"fixed_field\","," Type::Primitive(PrimitiveType::Fixed(10)),"," 15,"," \"binary_field\","," Type::Primitive(PrimitiveType::Binary),"," 16,"," \"string_field\","," Type::Primitive(PrimitiveType::String),"," id_lookup: OnceLock::default(),"," name_lookup: OnceLock::default(),"," fn struct_type() {"," \"name\": \"id\","," \"required\": true,"," \"type\": \"uuid\","," \"initial-default\": \"0db3e2a8-9d1d-42b9-aa7b-74ebe558dceb\","," \"write-default\": \"ec5911be-b0a7-458c-8438-c9a3e53cffae\""," }, {"," \"id\": 2,"," \"name\": \"data\","," \"type\": \"int\""," NestedField::required(1, \"id\", Type::Primitive(PrimitiveType::Uuid))"," .with_initial_default(Literal::Primitive(PrimitiveLiteral::UInt128("," Uuid::parse_str(\"0db3e2a8-9d1d-42b9-aa7b-74ebe558dceb\")"," .unwrap()"," .as_u128(),"," )))"," .with_write_default(Literal::Primitive(PrimitiveLiteral::UInt128("," Uuid::parse_str(\"ec5911be-b0a7-458c-8438-c9a3e53cffae\")"," NestedField::optional(2, \"data\", Type::Primitive(PrimitiveType::Int)).into(),"," id_lookup: HashMap::from([(1, 0), (2, 1)]).into(),"," name_lookup: HashMap::from([(\"id\".to_string(), 0), (\"data\".to_string(), 1)]).into(),"," fn test_deeply_nested_struct() {"," \"type\": \"struct\","," \"fields\": ["," \"id\": 1,"," \"name\": \"id\","," \"required\": true,"," \"type\": \"uuid\","," \"initial-default\": \"0db3e2a8-9d1d-42b9-aa7b-74ebe558dceb\","," \"write-default\": \"ec5911be-b0a7-458c-8438-c9a3e53cffae\""," \"id\": 2,"," \"name\": \"data\","," \"required\": false,"," \"type\": \"int\""," \"id\": 3,"," \"name\": \"address\","," \"type\": {"," {"," \"id\": 4,"," \"name\": \"street\","," \"required\": true,"," \"type\": \"string\""," },"," \"id\": 5,"," \"name\": \"province\","," \"required\": false,"," \"id\": 6,"," \"name\": \"zip\","," \"type\": \"int\""," }"," ]","\"#;"," let struct_type = Type::Struct(StructType::new(vec!["," NestedField::required(1, \"id\", Type::Primitive(PrimitiveType::Uuid))"," .with_initial_default(Literal::Primitive(PrimitiveLiteral::UInt128("," Uuid::parse_str(\"0db3e2a8-9d1d-42b9-aa7b-74ebe558dceb\")"," .as_u128(),"," )))"," .with_write_default(Literal::Primitive(PrimitiveLiteral::UInt128("," Uuid::parse_str(\"ec5911be-b0a7-458c-8438-c9a3e53cffae\")"," NestedField::optional(2, \"data\", Type::Primitive(PrimitiveType::Int)).into(),"," NestedField::required("," \"address\","," Type::Struct(StructType::new(vec!["," NestedField::required(4, \"street\", Type::Primitive(PrimitiveType::String))"," NestedField::optional(5, \"province\", Type::Primitive(PrimitiveType::String))"," NestedField::required(6, \"zip\", Type::Primitive(PrimitiveType::Int)).into(),"," ])),"," .into(),"," ]));"," check_type_serde(record, struct_type)"," fn list() {"," \"type\": \"list\","," \"element-id\": 3,"," \"element-required\": true,"," \"element\": \"string\""," Type::List(ListType {"," element_field: NestedField::list_element("," fn map() {"," \"type\": \"map\","," \"key-id\": 4,"," \"key\": \"string\","," \"value-id\": 5,"," \"value-required\": false,"," \"value\": \"double\""," Type::Map(MapType {"," key_field: NestedField::map_key_element(4, Type::Primitive(PrimitiveType::String))"," value_field: NestedField::map_value_element("," false,"," Type::Map(MapType::optional("," Type::Primitive(PrimitiveType::String),"," Type::Primitive(PrimitiveType::Double),"," )),"," fn map_int() {"," \"key\": \"int\","," \"value\": \"string\""," key_field: NestedField::map_key_element(4, Type::Primitive(PrimitiveType::Int))"," Type::Primitive(PrimitiveType::Int),"," fn map_required_int() {"," \"value-required\": true,"," Type::Map(MapType::required("," fn test_decimal_precision() {"," let expected_max_precision = ["," 2, 4, 6, 9, 11, 14, 16, 18, 21, 23, 26, 28, 31, 33, 35, 38, 40, 43, 45, 47, 50, 52, 55,"," 57,"," ];"," for (i, max_precision) in expected_max_precision.iter().enumerate() {"," *max_precision,"," Type::decimal_max_precision(i as u32 + 1).unwrap(),"," \"Failed calculate max precision for {i}\""," assert_eq!(5, Type::decimal_required_bytes(10).unwrap());"," assert_eq!(16, Type::decimal_required_bytes(38).unwrap());"," fn test_primitive_type_compatible() {"," let pairs = vec!["," (PrimitiveType::Boolean, PrimitiveLiteral::Boolean(true)),"," (PrimitiveType::Int, PrimitiveLiteral::Int(1)),"," (PrimitiveType::Long, PrimitiveLiteral::Long(1)),"," (PrimitiveType::Float, PrimitiveLiteral::Float(1.0.into())),"," (PrimitiveType::Double, PrimitiveLiteral::Double(1.0.into())),"," PrimitiveType::Decimal {"," precision: 9,"," scale: 2,"," PrimitiveLiteral::Int128(1),"," (PrimitiveType::Date, PrimitiveLiteral::Int(1)),"," (PrimitiveType::Time, PrimitiveLiteral::Long(1)),"," (PrimitiveType::Timestamptz, PrimitiveLiteral::Long(1)),"," (PrimitiveType::Timestamp, PrimitiveLiteral::Long(1)),"," (PrimitiveType::TimestamptzNs, PrimitiveLiteral::Long(1)),"," (PrimitiveType::TimestampNs, PrimitiveLiteral::Long(1)),"," PrimitiveType::Uuid,"," PrimitiveLiteral::UInt128(Uuid::new_v4().as_u128()),"," (PrimitiveType::Fixed(8), PrimitiveLiteral::Binary(vec![1])),"," (PrimitiveType::Binary, PrimitiveLiteral::Binary(vec![1])),"," for (ty, literal) in pairs {"," assert!(ty.compatible(&literal));"," assert!(!PrimitiveType::Unknown.compatible(&PrimitiveLiteral::Int(1)));"," fn struct_type_with_type_field() {"," // Test that StructType properly deserializes JSON with \"type\":\"struct\" field"," // This was previously broken because the deserializer wasn't consuming the type field value"," let json = r#\""," {\"id\": 1, \"name\": \"field1\", \"required\": true, \"type\": \"string\"}"," let struct_type: StructType = serde_json::from_str(json)"," .expect(\"Should successfully deserialize StructType with type field\");"," assert_eq!(struct_type.fields().len(), 1);"," assert_eq!(struct_type.fields()[0].name, \"field1\");"," fn struct_type_rejects_wrong_type() {"," // Test that StructType validation rejects incorrect type field values"," let result = serde_json::from_str::(json);"," \"Should reject StructType with wrong type field\""," result"," .contains(\"expected type 'struct'\")",[5256,5257,5258,5259,5260,5261,5262,5263,5264],{"_295":49,"_49":5277},{"_295":4389,"_412":4486,"_419":5275,"_421":5276},{"_295":49,"_49":5274},{"_295":4389,"_412":4486,"_419":5272,"_421":5273},{"_295":49,"_49":5271},{"_295":4389,"_412":3697,"_419":5269,"_421":5270},{"_295":49,"_49":5268},{"_295":4389,"_412":3697,"_419":5266,"_421":5267},{"_295":49,"_49":5265},"\n\nCommitted the changes with `2ffa4ca` and created a follow-up PR titled `fix(spec): preserve unknown default deserialization errors`.\n\n**Testing**\n* ✅ `cargo test -p iceberg --lib test_unknown_type -- --nocapture`\n* ✅ `cargo fmt --check`\n* ✅ `git diff --check`",1311,1328,"\n* Kept explicit `null` defaults valid for `unknown` fields. ",1268,1309,"\n* Expanded the `schema/mod.rs` regression test to check both `initial-default` and `write-default` non-null values for `unknown` fields, including direct `NestedField` deserialization and schema JSON deserialization coverage. ",592,607,"\n* Wired both default fields through the new parsing helper during `NestedField` deserialization, so invalid defaults fail deserialization with field/default context. ",569,590,"**Summary**\n* Removed the prior set-predicate formatting follow-up from this branch so the new PR focuses on the `mod.rs` review feedback about unknown-type defaults.\n* Added contextual nested-field default parsing so `initial-default` and `write-default` JSON values are parsed fallibly with `Literal::try_from_json`, preserving errors instead of dropping invalid non-null defaults. ",{"_112":385,"_388":4410,"_147":5279,"_389":-5,"_364":5280,"_391":5281,"_393":5282,"_395":5283,"_397":5284,"_399":4476,"_401":5285},"1fc1b645d7b72a7c9b73b64911a1f7596a7dbbe3","diff --git a/crates/iceberg/src/expr/predicate.rs b/crates/iceberg/src/expr/predicate.rs\nindex 8d3ff94c1e30df2b0a6da2e78b64ede3e12a43a5..35e88ff3e77bafa839a23e29a3d4f89bddcd73f7 100644\n--- a/crates/iceberg/src/expr/predicate.rs\n+++ b/crates/iceberg/src/expr/predicate.rs\n@@ -288,58 +288,51 @@ impl SetExpression {\n pub fn literals(&self) -> &FnvHashSet {\n &self.literals\n }\n \n /// Return the term of this predicate.\n pub fn term(&self) -> &T {\n &self.term\n }\n }\n \n impl Bind for SetExpression {\n type Bound = SetExpression;\n \n fn bind(&self, schema: SchemaRef, case_sensitive: bool) -> Result {\n let bound_term = self.term.bind(schema.clone(), case_sensitive)?;\n Ok(SetExpression::new(\n self.op,\n bound_term,\n self.literals.clone(),\n ))\n }\n }\n \n impl Display for SetExpression {\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n- let mut literal_strs = self\n- .literals\n- .iter()\n- .sorted_by(|a, b| {\n- a.partial_cmp(b)\n- .unwrap_or_else(|| format!(\"{a}\").cmp(&format!(\"{b}\")))\n- })\n- .map(|l| format!(\"{l}\"));\n+ let mut literal_strs = self.literals.iter().map(|l| format!(\"{l}\"));\n \n write!(f, \"{} {} ({})\", self.term, self.op, literal_strs.join(\", \"))\n }\n }\n \n /// Unbound predicate expression before binding to a schema.\n #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]\n pub enum Predicate {\n /// AlwaysTrue predicate, for example, `TRUE`.\n AlwaysTrue,\n /// AlwaysFalse predicate, for example, `FALSE`.\n AlwaysFalse,\n /// And predicate, for example, `a > 10 AND b < 20`.\n And(LogicalExpression),\n /// Or predicate, for example, `a > 10 OR b < 20`.\n Or(LogicalExpression),\n /// Not predicate, for example, `NOT (a > 10)`.\n Not(LogicalExpression),\n /// Unary expression, for example, `a IS NULL`.\n Unary(UnaryExpression),\n /// Binary expression, for example, `a > 10`.\n Binary(BinaryExpression),\n /// Set predicates, for example, `a in (1, 2, 3)`.\n Set(SetExpression),\n }\n@@ -1348,86 +1341,86 @@ mod tests {\n assert!(bound_expr.is_err());\n }\n \n #[test]\n fn test_bind_not_starts_with() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"foo\").not_starts_with(Datum::string(\"abcd\"));\n let bound_expr = expr.bind(schema, true).unwrap();\n assert_eq!(&format!(\"{bound_expr}\"), r#\"foo NOT STARTS WITH \"abcd\"\"#);\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_not_starts_with_wrong_type() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").not_starts_with(Datum::string(\"abcd\"));\n let bound_expr = expr.bind(schema, true);\n assert!(bound_expr.is_err());\n }\n \n #[test]\n fn test_bind_in() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_in([Datum::int(10), Datum::int(20)]);\n let bound_expr = expr.bind(schema, true).unwrap();\n- assert_eq!(&format!(\"{bound_expr}\"), \"bar IN (10, 20)\");\n+ assert_eq!(&format!(\"{bound_expr}\"), \"bar IN (20, 10)\");\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_in_empty() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_in(vec![]);\n let bound_expr = expr.bind(schema, true).unwrap();\n assert_eq!(&format!(\"{bound_expr}\"), \"False\");\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_in_one_literal() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_in(vec![Datum::int(10)]);\n let bound_expr = expr.bind(schema, true).unwrap();\n assert_eq!(&format!(\"{bound_expr}\"), \"bar = 10\");\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_in_wrong_type() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_in(vec![Datum::int(10), Datum::string(\"abcd\")]);\n let bound_expr = expr.bind(schema, true);\n assert!(bound_expr.is_err());\n }\n \n #[test]\n fn test_bind_not_in() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_not_in([Datum::int(10), Datum::int(20)]);\n let bound_expr = expr.bind(schema, true).unwrap();\n- assert_eq!(&format!(\"{bound_expr}\"), \"bar NOT IN (10, 20)\");\n+ assert_eq!(&format!(\"{bound_expr}\"), \"bar NOT IN (20, 10)\");\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_not_in_empty() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_not_in(vec![]);\n let bound_expr = expr.bind(schema, true).unwrap();\n assert_eq!(&format!(\"{bound_expr}\"), \"True\");\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_not_in_one_literal() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_not_in(vec![Datum::int(10)]);\n let bound_expr = expr.bind(schema, true).unwrap();\n assert_eq!(&format!(\"{bound_expr}\"), \"bar != 10\");\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_not_in_wrong_type() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_not_in([Datum::int(10), Datum::string(\"abcd\")]);\ndiff --git a/crates/iceberg/src/expr/visitors/strict_projection.rs b/crates/iceberg/src/expr/visitors/strict_projection.rs\nindex 414e676f813c7181e0b2f51985d44ae050d6d475..ebc6212c767e3e26533279af9d1b993535cc9bdc 100644\n--- a/crates/iceberg/src/expr/visitors/strict_projection.rs\n+++ b/crates/iceberg/src/expr/visitors/strict_projection.rs\n@@ -402,51 +402,51 @@ mod tests {\n // test not in\n let predicate =\n Reference::new(\"col1\")\n .is_not_in(\n vec![\n Datum::date_from_str(\"1970-01-01\").unwrap(),\n Datum::date_from_str(\"1969-12-31\").unwrap(),\n ]\n .into_iter(),\n )\n .and(Reference::new(\"col2\").is_not_in(\n vec![Datum::timestamp_micros(0), Datum::timestamp_micros(-1)].into_iter(),\n ))\n .and(Reference::new(\"col3\").is_not_in(\n vec![Datum::timestamptz_micros(0), Datum::timestamptz_micros(-1)].into_iter(),\n ))\n .and(Reference::new(\"col4\").is_not_in(\n vec![Datum::timestamp_nanos(0), Datum::timestamp_nanos(-1)].into_iter(),\n ))\n .and(Reference::new(\"col5\").is_not_in(\n vec![Datum::timestamptz_nanos(0), Datum::timestamptz_nanos(-1)].into_iter(),\n ))\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (-1, 0)) AND (pcol2 NOT IN (-1, 0))) AND (pcol3 NOT IN (-1, 0))) AND (pcol4 NOT IN (-1, 0))) AND (pcol5 NOT IN (-1, 0))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (0, -1)) AND (pcol2 NOT IN (0, -1))) AND (pcol3 NOT IN (0, -1))) AND (pcol4 NOT IN (0, -1))) AND (pcol5 NOT IN (0, -1))\".to_string());\n \n // test in\n let predicate =\n Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"1970-01-01\").unwrap(),\n Datum::date_from_str(\"1969-12-31\").unwrap(),\n ]\n .into_iter(),\n )\n .and(Reference::new(\"col2\").is_in(\n vec![Datum::timestamp_micros(0), Datum::timestamp_micros(-1)].into_iter(),\n ))\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n #[tokio::test]\n async fn test_strict_projection_month_lower_bound() {\n let schema = Arc::new(\n Schema::builder()\n .with_fields(vec![\n@@ -636,51 +636,51 @@ mod tests {\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col4\").is_not_in(\n vec![\n Datum::timestamp_nanos(1483228800000000000),\n Datum::timestamp_nanos(1512182400000000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::timestamptz_nanos(1483228800000000000),\n Datum::timestamptz_nanos(1512182400000000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (564, 575)) AND (pcol2 NOT IN (564, 575))) AND (pcol3 NOT IN (564, 575))) AND (pcol4 NOT IN (564, 575))) AND (pcol5 NOT IN (564, 575))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (575, 564)) AND (pcol2 NOT IN (575, 564))) AND (pcol3 NOT IN (575, 564))) AND (pcol4 NOT IN (575, 564))) AND (pcol5 NOT IN (575, 564))\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"2017-01-01\").unwrap(),\n Datum::date_from_str(\"2017-01-02\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_in(\n vec![\n Datum::timestamp_micros(1483228800000000),\n Datum::timestamp_micros(1483315200000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n@@ -864,51 +864,51 @@ mod tests {\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col4\").is_not_in(\n vec![\n Datum::timestamp_nanos(-86400000000000),\n Datum::timestamp_nanos(-31536000000000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::timestamptz_nanos(-86400000000000),\n Datum::timestamptz_nanos(-31536000000000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (-12, -1)) AND (pcol2 NOT IN (-12, -1))) AND (pcol3 NOT IN (-12, -1))) AND (pcol4 NOT IN (-12, -1))) AND (pcol5 NOT IN (-12, -1))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (-1, -12)) AND (pcol2 NOT IN (-1, -12))) AND (pcol3 NOT IN (-1, -12))) AND (pcol4 NOT IN (-1, -12))) AND (pcol5 NOT IN (-1, -12))\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"1969-01-01\").unwrap(),\n Datum::date_from_str(\"1969-12-31\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_in(\n vec![\n Datum::timestamp_micros(-315619200000000),\n Datum::timestamp_micros(-86400000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n@@ -1044,99 +1044,99 @@ mod tests {\n .and(\n Reference::new(\"col5\")\n .greater_than_or_equal_to(Datum::timestamptz_nanos(1514764799000000000)),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(\n result.to_string(),\n \"((((pcol1 > 575) AND (pcol2 > 575)) AND (pcol3 > 575)) AND (pcol4 > 575)) AND (pcol5 > 575)\"\n .to_string()\n );\n \n // test not eq: (col1 != 2017-12-31) AND (col2 != 2017-12-31) AND (col3 != 2017-12-31) AND (col4 != 2017-12-31) AND (col5 != 2017-12-31)\n let predicate = Reference::new(\"col1\")\n .not_equal_to(Datum::date_from_str(\"2017-12-31\").unwrap())\n .and(Reference::new(\"col2\").not_equal_to(Datum::timestamp_micros(1514764799000000)))\n .and(Reference::new(\"col3\").not_equal_to(Datum::timestamptz_micros(1514764799000000)))\n .and(Reference::new(\"col4\").not_equal_to(Datum::timestamp_nanos(1514764799000000000)))\n .and(Reference::new(\"col5\").not_equal_to(Datum::timestamptz_nanos(1514764799000000000)))\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"((((pcol1 != 575) AND (pcol2 != 575)) AND (pcol3 != 575)) AND (pcol4 != 575)) AND (pcol5 != 575)\".to_string());\n \n- // test not in: (col1 NOT IN (2017-01-01, 2017-12-31)) AND (col2 NOT IN (2017-01-01, 2017-12-31)) AND (col3 NOT IN (2017-01-01, 2017-12-31)) AND (col4 NOT IN (2017-01-01, 2017-12-31)) AND (col5 NOT IN (2017-01-01, 2017-12-31))\n+ // test not in: (col1 NOT IN (2017-12-31, 2017-01-01)) AND (col2 NOT IN (2017-12-31, 2017-01-01)) AND (col3 NOT IN (2017-12-31, 2017-01-01)) AND (col4 NOT IN (2017-12-31, 2017-01-01)) AND (col5 NOT IN (2017-12-31, 2017-01-01))\n let predicate = Reference::new(\"col1\")\n .is_not_in(\n vec![\n Datum::date_from_str(\"2017-12-31\").unwrap(),\n Datum::date_from_str(\"2017-01-01\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_not_in(\n vec![\n Datum::timestamp_micros(1514764799000000),\n Datum::timestamp_micros(1483228800000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col3\").is_not_in(\n vec![\n Datum::timestamptz_micros(1514764799000000),\n Datum::timestamptz_micros(1483228800000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col4\").is_not_in(\n vec![\n Datum::timestamp_nanos(1514764799000000000),\n Datum::timestamp_nanos(1483228800000000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::timestamptz_nanos(1514764799000000000),\n Datum::timestamptz_nanos(1483228800000000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (564, 575)) AND (pcol2 NOT IN (564, 575))) AND (pcol3 NOT IN (564, 575))) AND (pcol4 NOT IN (564, 575))) AND (pcol5 NOT IN (564, 575))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (575, 564)) AND (pcol2 NOT IN (575, 564))) AND (pcol3 NOT IN (575, 564))) AND (pcol4 NOT IN (575, 564))) AND (pcol5 NOT IN (575, 564))\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"2017-12-31\").unwrap(),\n Datum::date_from_str(\"2017-01-01\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_in(\n vec![\n Datum::timestamp_micros(1514764799000000),\n Datum::timestamp_micros(1483228800000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n@@ -1702,51 +1702,51 @@ mod tests {\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col4\").is_not_in(\n vec![\n Datum::timestamp_nanos(-172800000000000),\n Datum::timestamp_nanos(-1),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::timestamptz_nanos(-172800000000000),\n Datum::timestamptz_nanos(-1),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (1969-12-30, 1969-12-31)) AND (pcol2 NOT IN (1969-12-30, 1969-12-31))) AND (pcol3 NOT IN (1969-12-30, 1969-12-31))) AND (pcol4 NOT IN (1969-12-30, 1969-12-31))) AND (pcol5 NOT IN (1969-12-30, 1969-12-31))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (1969-12-31, 1969-12-30)) AND (pcol2 NOT IN (1969-12-31, 1969-12-30))) AND (pcol3 NOT IN (1969-12-31, 1969-12-30))) AND (pcol4 NOT IN (1969-12-31, 1969-12-30))) AND (pcol5 NOT IN (1969-12-31, 1969-12-30))\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"1969-12-30\").unwrap(),\n Datum::date_from_str(\"1969-12-31\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_in(\n vec![\n Datum::timestamp_micros(-172800000000),\n Datum::timestamp_micros(-1),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n@@ -1930,51 +1930,51 @@ mod tests {\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col4\").is_not_in(\n vec![\n Datum::timestamp_nanos(1483228800000000000),\n Datum::timestamp_nanos(1483142400000000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::timestamptz_nanos(1483228800000000000),\n Datum::timestamptz_nanos(1483142400000000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (46, 47)) AND (pcol2 NOT IN (46, 47))) AND (pcol3 NOT IN (46, 47))) AND (pcol4 NOT IN (46, 47))) AND (pcol5 NOT IN (46, 47))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (47, 46)) AND (pcol2 NOT IN (47, 46))) AND (pcol3 NOT IN (47, 46))) AND (pcol4 NOT IN (47, 46))) AND (pcol5 NOT IN (47, 46))\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"2017-01-01\").unwrap(),\n Datum::date_from_str(\"2017-12-31\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_in(\n vec![\n Datum::timestamp_micros(1483228800000000),\n Datum::timestamp_micros(1514764799000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n@@ -2314,99 +2314,99 @@ mod tests {\n .and(\n Reference::new(\"col5\")\n .greater_than_or_equal_to(Datum::timestamptz_nanos(1514764799000000000)),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(\n result.to_string(),\n \"((((pcol1 > 47) AND (pcol2 > 47)) AND (pcol3 > 47)) AND (pcol4 > 47)) AND (pcol5 > 47)\"\n .to_string()\n );\n \n // test not eq: (col1 != 2017-12-31) AND (col2 != 2017-12-31) AND (col3 != 2017-12-31) AND (col4 != 2017-12-31) AND (col5 != 2017-12-31)\n let predicate = Reference::new(\"col1\")\n .not_equal_to(Datum::date_from_str(\"2017-12-31\").unwrap())\n .and(Reference::new(\"col2\").not_equal_to(Datum::timestamp_micros(1514764799000000)))\n .and(Reference::new(\"col3\").not_equal_to(Datum::timestamptz_micros(1514764799000000)))\n .and(Reference::new(\"col4\").not_equal_to(Datum::timestamp_nanos(1514764799000000000)))\n .and(Reference::new(\"col5\").not_equal_to(Datum::timestamptz_nanos(1514764799000000000)))\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"((((pcol1 != 47) AND (pcol2 != 47)) AND (pcol3 != 47)) AND (pcol4 != 47)) AND (pcol5 != 47)\".to_string());\n \n- // test not in: (col1 NOT IN (2016-01-01, 2017-12-31)) AND (col2 NOT IN (2016-01-01, 2017-12-31)) AND (col3 NOT IN (2016-01-01, 2017-12-31)) AND (col4 NOT IN (2016-01-01, 2017-12-31)) AND (col5 NOT IN (2016-01-01, 2017-12-31))\n+ // test not in: (col1 NOT IN (2017-12-31, 2016-01-01)) AND (col2 NOT IN (2017-12-31, 2016-01-01)) AND (col3 NOT IN (2017-12-31, 2016-01-01)) AND (col4 NOT IN (2017-12-31, 2016-01-01)) AND (col5 NOT IN (2017-12-31, 2016-01-01))\n let predicate = Reference::new(\"col1\")\n .is_not_in(\n vec![\n Datum::date_from_str(\"2017-12-31\").unwrap(),\n Datum::date_from_str(\"2016-01-01\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_not_in(\n vec![\n Datum::timestamp_micros(1514764799000000),\n Datum::timestamp_micros(1451606400000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col3\").is_not_in(\n vec![\n Datum::timestamptz_micros(1514764799000000),\n Datum::timestamptz_micros(1451606400000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col4\").is_not_in(\n vec![\n Datum::timestamp_nanos(1514764799000000000),\n Datum::timestamp_nanos(1451606400000000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::timestamptz_nanos(1514764799000000000),\n Datum::timestamptz_nanos(1451606400000000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (46, 47)) AND (pcol2 NOT IN (46, 47))) AND (pcol3 NOT IN (46, 47))) AND (pcol4 NOT IN (46, 47))) AND (pcol5 NOT IN (46, 47))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (47, 46)) AND (pcol2 NOT IN (47, 46))) AND (pcol3 NOT IN (47, 46))) AND (pcol4 NOT IN (47, 46))) AND (pcol5 NOT IN (47, 46))\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"2017-12-31\").unwrap(),\n Datum::date_from_str(\"2017-01-01\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_in(\n vec![\n Datum::timestamp_micros(1514764799000000),\n Datum::timestamp_micros(1483228800000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n@@ -2571,51 +2571,51 @@ mod tests {\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::binary(\"abcdefg\".as_bytes().to_vec()),\n Datum::binary(\"abcdehij\".as_bytes().to_vec()),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col6\").is_not_in(\n vec![\n Datum::uuid(\n Uuid::parse_str(\"00000000-0000-007b-0000-0000000001c8\").unwrap(),\n ),\n Datum::uuid(\n Uuid::parse_str(\"00000000-0000-01c8-0000-00000000007b\").unwrap(),\n ),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"(((((pcol1 NOT IN (6, 7, 8)) AND (pcol2 NOT IN (6, 7, 8))) AND (pcol3 NOT IN (2, 6))) AND (pcol4 NOT IN (4, 9))) AND (pcol5 NOT IN (4, 6))) AND (pcol6 NOT IN (4, 6))\".to_string());\n+ assert_eq!(result.to_string(), \"(((((pcol1 NOT IN (8, 7, 6)) AND (pcol2 NOT IN (8, 7, 6))) AND (pcol3 NOT IN (6, 2))) AND (pcol4 NOT IN (9, 4))) AND (pcol5 NOT IN (4, 6))) AND (pcol6 NOT IN (4, 6))\".to_string());\n }\n \n #[tokio::test]\n async fn test_strict_projection_identity() {\n let schema = Arc::new(\n Schema::builder()\n .with_fields(vec![Arc::new(NestedField::optional(\n 1,\n \"col1\",\n Type::Primitive(PrimitiveType::Long),\n ))])\n .build()\n .unwrap(),\n );\n \n let partition_spec = Arc::new(\n PartitionSpec::builder(schema.clone())\n .with_spec_id(1)\n .add_partition_field(\"col1\", \"pcol1\", Transform::Identity)\n .unwrap()\n .build()\n .unwrap(),\n );\n \n let mut strict_projection = StrictProjection::new(partition_spec.clone());\n@@ -2668,59 +2668,59 @@ mod tests {\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"pcol1 >= 100\".to_string());\n \n // test eq\n let predicate = Reference::new(\"col1\")\n .equal_to(Datum::long(100))\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"pcol1 = 100\".to_string());\n \n // test not eq\n let predicate = Reference::new(\"col1\")\n .not_equal_to(Datum::long(100))\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"pcol1 != 100\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(vec![Datum::long(100), Datum::long(101)].into_iter())\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"pcol1 IN (100, 101)\".to_string());\n+ assert_eq!(result.to_string(), \"pcol1 IN (101, 100)\".to_string());\n \n // test not in\n let predicate = Reference::new(\"col1\")\n .is_not_in(vec![Datum::long(100), Datum::long(101)].into_iter())\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"pcol1 NOT IN (100, 101)\".to_string());\n+ assert_eq!(result.to_string(), \"pcol1 NOT IN (101, 100)\".to_string());\n }\n \n #[tokio::test]\n async fn test_strict_projection_truncate_lower_bound() {\n // int, long, decimal\n let schema = Arc::new(\n Schema::builder()\n .with_fields(vec![\n Arc::new(NestedField::required(\n 1,\n \"col1\",\n Type::Primitive(PrimitiveType::Int),\n )),\n Arc::new(NestedField::required(\n 2,\n \"col2\",\n Type::Primitive(PrimitiveType::Long),\n )),\n Arc::new(NestedField::required(\n 3,\n \"col3\",\n Type::Primitive(PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n }),\n@@ -2858,51 +2858,51 @@ mod tests {\n PrimitiveLiteral::Int128(9900),\n ),\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n PrimitiveLiteral::Int128(10000),\n ),\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n PrimitiveLiteral::Int128(10100),\n ),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(\n result.to_string(),\n- \"((pcol1 NOT IN (90, 100)) AND (pcol2 NOT IN (90, 100))) AND (pcol3 NOT IN (9900, 10000, 10100))\"\n+ \"((pcol1 NOT IN (100, 90)) AND (pcol2 NOT IN (100, 90))) AND (pcol3 NOT IN (10000, 10100, 9900))\"\n .to_string()\n );\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(vec![Datum::int(99), Datum::int(100), Datum::int(101)].into_iter())\n .and(\n Reference::new(\"col2\")\n .is_in(vec![Datum::long(99), Datum::long(100), Datum::long(101)].into_iter()),\n )\n .and(\n Reference::new(\"col3\").is_in(\n vec![\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n PrimitiveLiteral::Int128(9900),\n ),\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n@@ -3081,51 +3081,51 @@ mod tests {\n PrimitiveLiteral::Int128(9999),\n ),\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n PrimitiveLiteral::Int128(9899),\n ),\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n PrimitiveLiteral::Int128(10099),\n ),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(\n result.to_string(),\n- \"((pcol1 NOT IN (90, 100)) AND (pcol2 NOT IN (90, 100))) AND (pcol3 NOT IN (9890, 9990, 10090))\"\n+ \"((pcol1 NOT IN (100, 90)) AND (pcol2 NOT IN (100, 90))) AND (pcol3 NOT IN (9890, 9990, 10090))\"\n .to_string()\n );\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(vec![Datum::int(99), Datum::int(100), Datum::int(98)].into_iter())\n .and(\n Reference::new(\"col2\")\n .is_in(vec![Datum::long(99), Datum::long(100), Datum::long(98)].into_iter()),\n )\n .and(\n Reference::new(\"col3\").is_in(\n vec![\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n PrimitiveLiteral::Int128(9999),\n ),\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\ndiff --git a/crates/iceberg/src/spec/datatypes.rs b/crates/iceberg/src/spec/datatypes.rs\nindex 14595ee6d0c7d5ee7f03d03760b459dcb89fa5b5..963093f5955b1e97ee51579ceb8ed9c0460f25c2 100644\n--- a/crates/iceberg/src/spec/datatypes.rs\n+++ b/crates/iceberg/src/spec/datatypes.rs\n@@ -544,64 +544,89 @@ pub struct NestedField {\n pub field_type: Box,\n /// Fields may have an optional comment or doc string.\n pub doc: Option,\n /// Used to populate the field’s value for all records that were written before the field was added to the schema\n pub initial_default: Option,\n /// Used to populate the field’s value for any records written after the field was added to the schema, if the writer does not supply the field’s value\n pub write_default: Option,\n }\n \n #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]\n #[serde(rename_all = \"kebab-case\")]\n struct SerdeNestedField {\n pub id: i32,\n pub name: String,\n pub required: bool,\n #[serde(rename = \"type\")]\n pub field_type: Box,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub doc: Option,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub initial_default: Option,\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub write_default: Option,\n }\n \n+fn parse_field_default(\n+ default: Option,\n+ field_type: &Type,\n+ field_name: &str,\n+ default_name: &'static str,\n+) -> Result> {\n+ default\n+ .map(|value| {\n+ Literal::try_from_json(value, field_type).map_err(|err| {\n+ crate::Error::new(\n+ err.kind(),\n+ format!(\n+ \"Invalid {default_name} for field {field_name}: {}\",\n+ err.message()\n+ ),\n+ )\n+ .with_source(err)\n+ })\n+ })\n+ .transpose()\n+ .map(Option::flatten)\n+}\n+\n impl TryFrom for NestedField {\n type Error = crate::Error;\n \n fn try_from(value: SerdeNestedField) -> Result {\n- let initial_default = value\n- .initial_default\n- .map(|x| Literal::try_from_json(x, &value.field_type))\n- .transpose()?\n- .flatten();\n- let write_default = value\n- .write_default\n- .map(|x| Literal::try_from_json(x, &value.field_type))\n- .transpose()?\n- .flatten();\n+ let initial_default = parse_field_default(\n+ value.initial_default,\n+ &value.field_type,\n+ &value.name,\n+ \"initial-default\",\n+ )?;\n+ let write_default = parse_field_default(\n+ value.write_default,\n+ &value.field_type,\n+ &value.name,\n+ \"write-default\",\n+ )?;\n \n Ok(NestedField {\n id: value.id,\n name: value.name,\n required: value.required,\n initial_default,\n write_default,\n field_type: value.field_type,\n doc: value.doc,\n })\n }\n }\n \n impl From for SerdeNestedField {\n fn from(value: NestedField) -> Self {\n let initial_default = value.initial_default.map(|x| x.try_into_json(&value.field_type).expect(\"We should have checked this in NestedField::with_initial_default, it can't be converted to json value\"));\n let write_default = value.write_default.map(|x| x.try_into_json(&value.field_type).expect(\"We should have checked this in NestedField::with_write_default, it can't be converted to json value\"));\n SerdeNestedField {\n id: value.id,\n name: value.name,\n required: value.required,\n field_type: value.field_type,\n doc: value.doc,\n initial_default,\n write_default,\ndiff --git a/crates/iceberg/src/spec/schema/mod.rs b/crates/iceberg/src/spec/schema/mod.rs\nindex 4d43e411552e83d011a379fa2e58a83245cb8399..64827b20b57359463829daf2dde6deeeb109ac2b 100644\n--- a/crates/iceberg/src/spec/schema/mod.rs\n+++ b/crates/iceberg/src/spec/schema/mod.rs\n@@ -1244,72 +1244,90 @@ table {\n assert!(\n Schema::builder()\n .with_schema_id(1)\n .with_identifier_field_ids(vec![1])\n .with_fields(vec![\n NestedField::required(1, \"Required\", Type::Primitive(PrimitiveType::String),)\n .into()\n ])\n .build()\n .is_ok()\n );\n assert!(\n Schema::builder()\n .with_schema_id(1)\n .with_identifier_field_ids(vec![1])\n .with_fields(vec![\n NestedField::optional(1, \"Optional\", Type::Primitive(PrimitiveType::String),)\n .into()\n ])\n .build()\n .is_err()\n );\n }\n \n #[test]\n- fn test_unknown_type_deserialization_rejects_non_null_default() {\n- let schema_json = serde_json::json!({\n- \"type\": \"struct\",\n- \"schema-id\": 1,\n- \"fields\": [\n- {\n- \"id\": 1,\n- \"name\": \"empty\",\n- \"required\": false,\n- \"type\": \"unknown\",\n- \"initial-default\": 1\n- }\n- ]\n- });\n+ fn test_unknown_type_deserialization_rejects_non_null_defaults() {\n+ for default_name in [\"initial-default\", \"write-default\"] {\n+ let field_json = serde_json::json!({\n+ \"id\": 1,\n+ \"name\": \"empty\",\n+ \"required\": false,\n+ \"type\": \"unknown\",\n+ default_name: 1\n+ });\n+\n+ let field_error = serde_json::from_value::(field_json).unwrap_err();\n+ assert!(\n+ field_error\n+ .to_string()\n+ .contains(&format!(\"Invalid {default_name} for field empty\")),\n+ \"unexpected error for {default_name}: {field_error}\"\n+ );\n \n- let error = serde_json::from_value::(schema_json).unwrap_err();\n- assert!(\n- error\n- .to_string()\n- .contains(\"did not match any variant of untagged enum SchemaEnum\"),\n- \"unexpected error: {error}\"\n- );\n+ let schema_json = serde_json::json!({\n+ \"type\": \"struct\",\n+ \"schema-id\": 1,\n+ \"fields\": [\n+ {\n+ \"id\": 1,\n+ \"name\": \"empty\",\n+ \"required\": false,\n+ \"type\": \"unknown\",\n+ default_name: 1\n+ }\n+ ]\n+ });\n+\n+ let schema_error = serde_json::from_value::(schema_json).unwrap_err();\n+ assert!(\n+ schema_error\n+ .to_string()\n+ .contains(\"did not match any variant of untagged enum SchemaEnum\"),\n+ \"unexpected error for {default_name}: {schema_error}\"\n+ );\n+ }\n }\n \n #[test]\n fn test_unknown_type_deserialization_accepts_null_defaults() {\n let schema_json = serde_json::json!({\n \"type\": \"struct\",\n \"schema-id\": 1,\n \"fields\": [\n {\n \"id\": 1,\n \"name\": \"empty\",\n \"required\": false,\n \"type\": \"unknown\",\n \"initial-default\": null,\n \"write-default\": null\n }\n ]\n });\n \n serde_json::from_value::(schema_json).unwrap();\n }\n \n #[test]\n fn test_unknown_type_must_be_optional_with_null_defaults() {\n assert!(\ndiff --git a/crates/iceberg/src/transform/bucket.rs b/crates/iceberg/src/transform/bucket.rs\nindex befdb019f361806263cab178408e665cde5c0438..52fb72f1cf838921ceb14565774414921ef3ac1c 100644\n--- a/crates/iceberg/src/transform/bucket.rs\n+++ b/crates/iceberg/src/transform/bucket.rs\n@@ -497,51 +497,51 @@ mod test {\n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::string(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::string(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThan, Datum::string(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::string(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::string(value),\n Datum::string(another),\n ]),\n- Some(\"name IN (4, 9)\"),\n+ Some(\"name IN (9, 4)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::string(value),\n Datum::string(another),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_bucket_decimal() -> Result<()> {\n let prev = \"99.00\";\n let curr = \"100.00\";\n let next = \"101.00\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Bucket(10),\n \"name\",\n NestedField::required(\n 1,\n \"value\",\n@@ -634,51 +634,51 @@ mod test {\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::long(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::long(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThan, Datum::long(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::long(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::long(value - 1),\n Datum::long(value),\n Datum::long(value + 1),\n ]),\n- Some(\"name IN (6, 7, 8)\"),\n+ Some(\"name IN (8, 7, 6)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::long(value),\n Datum::long(value + 1),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_bucket_integer() -> Result<()> {\n let value = 100;\n \n let fixture = TestProjectionFixture::new(\n Transform::Bucket(10),\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Int)),\n );\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::int(value)),\n@@ -694,51 +694,51 @@ mod test {\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::int(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::int(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThan, Datum::int(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::int(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::int(value - 1),\n Datum::int(value),\n Datum::int(value + 1),\n ]),\n- Some(\"name IN (6, 7, 8)\"),\n+ Some(\"name IN (8, 7, 6)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::int(value),\n Datum::int(value + 1),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_hash() {\n // test int\n assert_eq!(Bucket::hash_int(34), 2017239379);\n // test long\n assert_eq!(Bucket::hash_long(34), 2017239379);\n // test decimal\n assert_eq!(Bucket::hash_decimal(1420), -500754589);\n // test date\n let date = NaiveDate::from_ymd_opt(2017, 11, 16).unwrap();\n assert_eq!(\n Bucket::hash_date(\ndiff --git a/crates/iceberg/src/transform/temporal.rs b/crates/iceberg/src/transform/temporal.rs\nindex 890e011ab1be99bb1d81635d6b63bbf0cbf36838..1cd4d6a4369f645b2963c979d0b8841b36767f0b 100644\n--- a/crates/iceberg/src/transform/temporal.rs\n+++ b/crates/iceberg/src/transform/temporal.rs\n@@ -639,51 +639,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 420034\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name = 420034\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (412007, 420034)\"),\n+ Some(\"name IN (420034, 412007)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_hour_lower_bound() -> Result<()> {\n // 420034\n let value = \"2017-12-01T10:00:00.000000\";\n // 411288\n let another = \"2016-12-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Hour,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n@@ -785,51 +785,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name = 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (46, 47)\"),\n+ Some(\"name IN (47, 46)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_year_lower_bound() -> Result<()> {\n let value = \"2017-01-01T00:00:00.000000\";\n let another = \"2016-12-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Year,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n \n fixture.assert_projection(\n@@ -857,51 +857,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name = 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (46, 47)\"),\n+ Some(\"name IN (47, 46)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_month_negative_upper_bound() -> Result<()> {\n let value = \"1969-12-31T23:59:59.999999\";\n let another = \"1970-01-01T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n \n fixture.assert_projection(\n@@ -929,51 +929,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= -1\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name IN (-1, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (-1, 0)\"),\n+ Some(\"name IN (0, -1)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_month_upper_bound() -> Result<()> {\n let value = \"2017-12-01T23:59:59.999999\";\n let another = \"2017-11-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n \n fixture.assert_projection(\n@@ -1001,51 +1001,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 575\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name = 575\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (574, 575)\"),\n+ Some(\"name IN (575, 574)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_month_negative_lower_bound() -> Result<()> {\n let value = \"1969-01-01T00:00:00.000000\";\n let another = \"1969-03-01T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n@@ -1072,51 +1072,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= -12\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name IN (-12, -11)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (-12, -11, -10, -9)\"),\n+ Some(\"name IN (-10, -9, -12, -11)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_month_lower_bound() -> Result<()> {\n let value = \"2017-12-01T00:00:00.000000\";\n let another = \"2017-12-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n \n fixture.assert_projection(\n@@ -1218,51 +1218,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 1969-12-31\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name IN (1969-12-31, 1970-01-01)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (1969-12-31, 1970-01-01)\"),\n+ Some(\"name IN (1970-01-01, 1969-12-31)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_day_upper_bound() -> Result<()> {\n // 17501\n let value = \"2017-12-01T23:59:59.999999\";\n // 17502\n let another = \"2017-12-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Day,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n@@ -1292,51 +1292,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 2017-12-01\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name = 2017-12-01\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (2017-12-01, 2017-12-02)\"),\n+ Some(\"name IN (2017-12-02, 2017-12-01)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_day_negative_lower_bound() -> Result<()> {\n // -365\n let value = \"1969-01-01T00:00:00.000000\";\n // -364\n let another = \"1969-01-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Day,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n@@ -1366,51 +1366,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 1969-01-01\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name IN (1969-01-01, 1969-01-02)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (1969-01-01, 1969-01-02, 1969-01-03)\"),\n+ Some(\"name IN (1969-01-02, 1969-01-01, 1969-01-03)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_day_lower_bound() -> Result<()> {\n // 17501\n let value = \"2017-12-01T00:00:00.000000\";\n // 17502\n let another = \"2017-12-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Day,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n@@ -1440,51 +1440,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 2017-12-01\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name = 2017-12-01\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (2017-12-01, 2017-12-02)\"),\n+ Some(\"name IN (2017-12-02, 2017-12-01)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_day_epoch() -> Result<()> {\n // 0\n let value = \"1970-01-01T00:00:00.00000\";\n // 1\n let another = \"1970-01-02T00:00:00.00000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Day,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n@@ -1718,51 +1718,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= -1\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name IN (-1, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (-12, -11, -1, 0)\"),\n+ Some(\"name IN (-1, -12, -11, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_month_upper_bound() -> Result<()> {\n // 575 => 2017-12\n let value = \"2017-12-31\";\n // 564 => 2017-01\n let another = \"2017-01-01\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -1786,51 +1786,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= 575\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name = 575\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (564, 575)\"),\n+ Some(\"name IN (575, 564)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_month_negative_lower_bound() -> Result<()> {\n // -12 => 1969-01\n let value = \"1969-01-01\";\n // -1 => 1969-12\n let another = \"1969-12-31\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -1854,51 +1854,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= -12\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name IN (-12, -11)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (-12, -11, -1, 0)\"),\n+ Some(\"name IN (-1, -12, -11, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_month_lower_bound() -> Result<()> {\n // 575 => 2017-12\n let value = \"2017-12-01\";\n // 564 => 2017-01\n let another = \"2017-01-01\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -1922,51 +1922,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= 575\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name = 575\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (564, 575)\"),\n+ Some(\"name IN (575, 564)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_month_epoch() -> Result<()> {\n // 0 => 1970-01\n let value = \"1970-01-01\";\n // -1 => 1969-12\n let another = \"1969-12-31\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -1990,51 +1990,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= 0\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name = 0\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (-1, 0)\"),\n+ Some(\"name IN (0, -1)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_year_negative_upper_bound() -> Result<()> {\n // -1 => 1969\n let value = \"1969-12-31\";\n let another = \"1969-01-01\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Year,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n \n@@ -2057,51 +2057,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= -1\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name IN (-1, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (-1, 0)\"),\n+ Some(\"name IN (0, -1)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_year_upper_bound() -> Result<()> {\n // 47 => 2017\n let value = \"2017-12-31\";\n // 46 => 2016\n let another = \"2016-01-01\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Year,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -2125,51 +2125,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name = 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (46, 47)\"),\n+ Some(\"name IN (47, 46)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_year_negative_lower_bound() -> Result<()> {\n // 0 => 1970\n let value = \"1970-01-01\";\n // -1 => 1969\n let another = \"1969-12-31\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Year,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -2193,51 +2193,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= 0\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name = 0\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (-1, 0)\"),\n+ Some(\"name IN (0, -1)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_year_lower_bound() -> Result<()> {\n // 47 => 2017\n let value = \"2017-01-01\";\n // 46 => 2016\n let another = \"2016-12-31\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Year,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -2261,51 +2261,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name = 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (46, 47)\"),\n+ Some(\"name IN (47, 46)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_transform_years() {\n let year = super::Year;\n \n // Test Date32\n let ori_date = vec![\n NaiveDate::from_ymd_opt(1970, 1, 1).unwrap(),\n NaiveDate::from_ymd_opt(2000, 1, 1).unwrap(),\n NaiveDate::from_ymd_opt(2030, 1, 1).unwrap(),\n NaiveDate::from_ymd_opt(2060, 1, 1).unwrap(),\n NaiveDate::from_ymd_opt(1969, 1, 1).unwrap(),\n ];\ndiff --git a/crates/iceberg/src/transform/truncate.rs b/crates/iceberg/src/transform/truncate.rs\nindex cf7e3485e607d2e912ca92d9f6a704b5162e12fe..4fac48f7d593cb21aeee7e559c4098f5d17e88ee 100644\n--- a/crates/iceberg/src/transform/truncate.rs\n+++ b/crates/iceberg/src/transform/truncate.rs\n@@ -447,51 +447,51 @@ mod test {\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::decimal_from_str(curr)?,\n ),\n Some(\"name >= 10000\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::decimal_from_str(curr)?),\n Some(\"name = 10000\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::decimal_from_str(curr)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::decimal_from_str(prev)?,\n Datum::decimal_from_str(curr)?,\n Datum::decimal_from_str(next)?,\n ]),\n- Some(\"name IN (9900, 10000, 10100)\"),\n+ Some(\"name IN (10000, 10100, 9900)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::decimal_from_str(curr)?,\n Datum::decimal_from_str(next)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_truncate_upper_bound_long() -> Result<()> {\n let value = 99i64;\n \n let fixture = TestProjectionFixture::new(\n Transform::Truncate(10),\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Long)),\n );\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::long(value)),\n@@ -502,51 +502,51 @@ mod test {\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::long(value)),\n Some(\"name <= 90\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::long(value)),\n Some(\"name >= 90\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::long(value)),\n Some(\"name = 90\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::long(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::long(value - 1),\n Datum::long(value),\n Datum::long(value + 1),\n ]),\n- Some(\"name IN (90, 100)\"),\n+ Some(\"name IN (100, 90)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::long(value),\n Datum::long(value + 1),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_truncate_lower_bound_long() -> Result<()> {\n let value = 100i64;\n \n let fixture = TestProjectionFixture::new(\n Transform::Truncate(10),\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Long)),\n );\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::long(value)),\n@@ -557,51 +557,51 @@ mod test {\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::long(value)),\n Some(\"name <= 100\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::long(value)),\n Some(\"name >= 100\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::long(value)),\n Some(\"name = 100\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::long(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::long(value - 1),\n Datum::long(value),\n Datum::long(value + 1),\n ]),\n- Some(\"name IN (90, 100)\"),\n+ Some(\"name IN (100, 90)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::long(value),\n Datum::long(value + 1),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_truncate_upper_bound_integer() -> Result<()> {\n let value = 99;\n \n let fixture = TestProjectionFixture::new(\n Transform::Truncate(10),\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Int)),\n );\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::int(value)),\n@@ -612,51 +612,51 @@ mod test {\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::int(value)),\n Some(\"name <= 90\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::int(value)),\n Some(\"name >= 90\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::int(value)),\n Some(\"name = 90\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::int(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::int(value - 1),\n Datum::int(value),\n Datum::int(value + 1),\n ]),\n- Some(\"name IN (90, 100)\"),\n+ Some(\"name IN (100, 90)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::int(value),\n Datum::int(value + 1),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_truncate_lower_bound_integer() -> Result<()> {\n let value = 100;\n \n let fixture = TestProjectionFixture::new(\n Transform::Truncate(10),\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Int)),\n );\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::int(value)),\n@@ -667,51 +667,51 @@ mod test {\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::int(value)),\n Some(\"name <= 100\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::int(value)),\n Some(\"name >= 100\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::int(value)),\n Some(\"name = 100\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::int(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::int(value - 1),\n Datum::int(value),\n Datum::int(value + 1),\n ]),\n- Some(\"name IN (90, 100)\"),\n+ Some(\"name IN (100, 90)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::int(value),\n Datum::int(value + 1),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n // Test case ref from: https://iceberg.apache.org/spec/#truncate-transform-details\n #[test]\n fn test_truncate_simple() {\n // test truncate int\n let input = Arc::new(Int32Array::from(vec![1, -1]));\n let res = super::Truncate::new(10).transform(input).unwrap();\n assert_eq!(\n res.as_any().downcast_ref::().unwrap().value(0),\n 0\n );\n assert_eq!(\n res.as_any().downcast_ref::().unwrap().value(1),\n",{"_403":5286,"_405":-5},7,118,82,[],"file_00000000255c722fac35d4b95b780efe",{"_112":284,"_45":96,"_116":284,"_285":5289,"_287":-5,"_288":289,"_150":94,"_138":5290},[98],[5291],1778207590.831742,{"_112":280,"_116":284,"_292":5292},[5293],{"_295":49,"_49":5294},"check review comments on mod.rs",{"_112":113,"_45":94,"_114":-5,"_115":-5,"_116":113,"_117":5297,"_119":5298,"_121":122,"_123":-5,"_125":-5,"_126":5299,"_128":5300,"_130":5301,"_132":304,"_134":-5,"_135":136,"_137":-5,"_138":5302,"_140":-5,"_141":142,"_143":5303,"_145":146,"_147":309,"_148":-5,"_149":-5,"_150":92,"_151":5304,"_153":-5,"_154":-5,"_155":18,"_156":157,"_158":-5},[96],[5334,5335],[],{"_276":5333},{"_273":5332},{"_273":5331},1778139527.568431,{"_45":142,"_160":161,"_162":163,"_164":18,"_165":166,"_167":168,"_169":5319,"_171":-5,"_172":173,"_174":18,"_175":5320,"_177":166,"_178":166,"_179":5321,"_181":5322,"_183":5323,"_185":-5,"_186":394,"_188":189,"_190":191,"_192":5324,"_58":-5,"_138":194,"_195":5325,"_197":5326,"_199":5327,"_201":18,"_202":18},{"_151":5305},[5306,5307,5308],{"_316":5315,"_318":5316},{"_316":5312,"_318":5313},{"_316":5309,"_318":5310},{"_227":320,"_112":321,"_138":5311},"file_000000008c5071f78f6b4a75c5c33511","2026-05-07T04:06:59.263219",{"_227":329,"_112":321,"_138":5314},"file_00000000ecd071f7b671039fcafd76a8","2026-05-07T04:06:47.221499",{"_227":5317,"_112":321,"_138":5318},"file_00000000e78071f780c2dae9dc889796","warm_up_git_repo_1778139533","2026-05-07T07:38:53.679851",{"_266":267,"_268":-5,"_269":-5,"_270":-5,"_271":-5,"_272":-5},[224],{"_224":5328},{"_206":207,"_208":209,"_210":211,"_212":213,"_214":215,"_216":217,"_218":219,"_220":221,"_222":223},{},[],{"_205":62},{"_203":62,"_204":166},"\"5100c9c3-0000-0200-0000-69fc383b0000\"",{"_45":226,"_227":228,"_229":5329,"_231":163,"_232":233,"_234":235,"_236":237,"_238":239,"_240":241,"_242":67,"_243":18,"_244":18,"_245":62,"_246":62,"_247":62,"_248":18,"_249":-5,"_250":251,"_252":-5,"_58":5330},{"_258":259,"_45":260,"_112":261,"_262":263,"_264":265},{"_254":62,"_255":18,"_256":62,"_257":62},[],[],[],{"_112":280,"_116":113,"_292":6034},{"_112":406,"_407":5336},[5337,5338,5339],{"_412":3697,"_414":-5,"_415":6024,"_417":-5},{"_412":4486,"_414":-5,"_415":6013,"_417":-5},{"_412":5340,"_414":-5,"_415":5341,"_417":-5},"crates/iceberg/src/expr/predicate.rs",[5342],{"_419":420,"_421":5343,"_292":5344,"_424":62},1712,[425,426,427,428,429,430,431,432,433,432,434,435,436,437,438,439,166,5345,5346,5347,166,5348,5349,166,5350,5351,5352,2052,166,3717,5353,5354,5355,5356,5357,2064,166,5358,5359,5360,5361,475,166,5362,4668,5363,5364,551,475,166,5365,4673,5366,5367,5368,5369,5370,5371,1332,551,475,166,5372,2858,5373,5374,5375,551,475,166,5376,5377,5378,551,166,5379,5380,5381,5382,5383,570,4521,551,475,166,5384,5385,4708,5386,166,5387,5388,5389,5390,570,166,5391,5392,5393,551,475,166,5394,5395,5396,5397,5398,5399,5400,5401,475,166,5402,2858,5403,5404,5405,5375,551,475,166,5406,2858,5407,551,475,166,5408,5409,166,5387,5410,5411,551,475,166,5412,5413,489,5414,489,5415,5416,489,5417,5418,5419,5420,5421,551,166,5422,5423,5424,551,166,5425,5426,5427,551,475,166,5428,5395,5429,5430,5398,5431,5400,5401,5432,5433,475,166,5434,2858,5435,5404,5405,5436,5375,551,475,166,5437,5438,489,5414,489,5415,5439,5440,489,5441,5442,5443,5444,5445,5418,5446,5447,5448,551,166,5449,5423,5424,551,166,5450,5451,5452,551,166,5425,5426,5427,551,475,166,5453,2858,5454,551,475,166,5455,5456,166,5387,5457,5458,5459,5460,5461,1332,551,475,166,5462,5395,5463,5464,5398,5465,5401,5466,5467,475,166,5468,2858,5469,5404,5405,5470,5375,551,475,166,5471,5472,489,5414,489,5415,5473,5474,5440,489,5475,5476,5443,5477,5445,5418,5478,5479,5480,551,166,5422,5423,5424,551,166,5481,5482,5483,551,166,5425,5426,5427,551,475,166,5484,5485,166,5387,5457,5486,5459,5460,5487,1332,551,475,166,5488,2858,5489,5490,653,5491,5492,5493,995,5494,166,5495,551,475,166,5496,5497,5498,5499,5500,5501,5502,5503,5504,5505,5506,5507,5508,5509,5510,5511,5512,5513,5514,475,166,5515,5516,166,5517,2859,5518,5519,166,5520,5521,5522,5523,1191,5524,5523,1191,5525,5526,5527,1613,624,5528,5519,5529,5530,5531,5532,5533,1613,624,5534,5519,5520,5521,5535,5536,5537,1187,5538,1191,5539,5540,5541,1613,624,5542,5519,166,5543,5544,5545,5546,3017,1191,5547,5545,5548,3017,1191,5549,5550,5551,2670,5552,5553,5554,5555,5556,3017,1191,5557,5558,2806,5559,5560,1191,616,166,5561,624,5562,5519,5563,166,5564,5565,5566,5567,5568,5548,3017,5569,5570,5571,5546,3017,5572,1612,5573,5569,5570,5568,5548,3017,5566,5567,5571,5546,3017,5572,1612,5574,616,166,5575,5576,5577,5578,5161,624,5579,5519,5580,5581,2574,5582,5583,166,5543,5584,5585,5546,3017,5586,5587,5588,5589,5590,5591,3017,1191,5592,5585,5548,3017,5586,5587,5593,5589,5590,5591,3017,1191,5557,5558,2806,5594,5560,1191,616,166,5595,5576,5577,5596,5161,624,5597,5598,570,551,475,166,5599,2858,2859,5600,5601,624,5602,5603,624,5518,5604,624,5534,5605,624,5528,5606,624,5542,5607,624,5562,5607,624,5579,5607,624,570,551,475,166,5608,5609,489,5414,489,5415,5610,489,5611,5612,5440,5613,489,5614,489,5615,489,5616,5418,5617,5618,5619,5620,5621,5622,5623,570,551,166,5624,489,5414,489,5415,5610,489,5611,5612,5440,5613,489,5614,489,5625,489,5626,5418,5627,5618,5628,5629,5630,5631,5632,570,551,166,5633,5634,5635,489,5414,489,5415,5610,489,5611,5636,5440,5613,5637,5638,5639,489,5640,5641,489,5642,5643,5418,5644,2859,5645,5646,5647,5648,5196,5649,5648,5196,5528,5650,5651,624,5542,5652,624,5653,5654,5655,5656,5196,5657,5654,5655,5658,5196,570,551,5659,5660,5661,5662,5663,489,5414,489,5415,5664,489,5636,5440,489,5665,5666,489,5667,5418,5668,5669,5670,551,475,166,5671,5672,166,5673,489,5674,5675,489,5414,1168,5676,5610,489,5611,5612,5440,5613,489,5677,489,5678,5418,5679,5680,551,475,166,5681,5682,5683,5684,5500,5685,5502,5686,5687,5688,5689,5690,5691,5509,5692,5511,5693,5694,5695,475,166,5696,5697,5698,551,166,5699,5700,551,166,5701,2859,5702,5703,5704,5648,5196,5705,5648,5196,5706,5650,5651,624,5707,5708,624,5709,5654,5655,5656,5196,5710,5654,5655,5658,5196,570,551,166,5659,5660,5661,5662,5663,489,5414,489,5415,5664,489,5711,5440,489,5712,5713,5714,5418,5715,5716,5670,551,475,166,5717,2858,2859,5718,5719,624,5720,5721,624,5722,5604,624,5723,5605,624,5706,5606,624,5707,5607,624,5724,5607,624,5725,5607,624,570,551,475,166,1281,1282,5726,2459,166,5727,5728,5729,166,1333,5730,5731,5732,5733,5734,166,5735,5736,5737,166,5738,166,5739,551,166,1333,5740,5731,5732,5741,5734,166,5735,5736,5742,166,5738,166,5739,551,166,1333,5743,5744,5745,5734,166,5746,166,5738,166,5739,551,166,1333,5747,5748,166,5749,166,5738,166,5739,551,166,1333,5750,5751,166,5752,166,5738,166,5739,551,166,1333,5753,5754,5755,166,5756,5732,5757,5758,166,5759,5760,166,5761,5732,5762,5763,551,166,1333,5764,5765,5766,166,5767,5768,166,5769,5770,166,5761,5732,5771,5772,551,166,1333,5773,5731,5732,5774,166,5735,5736,5742,166,5775,166,5739,551,166,1333,5776,5731,5736,5742,166,5735,5732,5774,166,5775,166,5739,551,166,1333,5777,5731,5736,5734,166,5778,166,5775,166,5739,551,166,1333,5779,5780,166,5781,166,5775,166,5739,551,166,1333,5782,5783,166,5749,166,5775,166,5739,551,166,1333,5784,5785,166,5786,166,5775,166,5739,551,166,5787,5788,4281,4282,4283,4284,5789,5790,5791,5792,4296,3517,4251,594,551,166,5793,5794,5795,5796,551,166,1333,5797,5798,5799,5800,5801,5802,551,166,1333,5803,5798,5804,5800,5805,5802,551,166,1333,5806,5798,5807,5800,5808,5802,551,166,1333,5809,5798,5810,5800,5811,5802,551,166,1333,5812,5798,5813,5800,5814,166,5815,5816,5817,5818,5802,551,166,1333,5819,5798,5820,5821,5822,551,166,1333,5823,5798,5824,5800,5825,5802,551,166,1333,5826,5798,5827,5821,5822,551,166,1333,5828,5798,5829,5800,5830,5802,551,166,1333,5831,5798,5832,5821,5822,551,166,1333,5833,5798,5834,5800,5835,5802,551,166,1333,5836,5798,5837,5821,5822,551,166,1333,5838,5798,5839,5800,5840,5802,551,166,1333,5841,5798,5842,5821,5822,551,166,1333,5843,5798,5844,5800,5845,5802,551,166,1333,5846,5798,5847,5821,5822,551,166,1333,5848,5798,5849,5800,5850,5802,551,166,1333,5851,5798,5852,5853,5800,5805,5802,551,166,1333,5854,5798,5855,5856,5800,5805,5802,551,166,1333,5857,5798,5852,5858,5800,5811,5802,551,166,1333,5859,5798,5855,5860,5800,5811,5802,551,166,1333,5861,5798,5852,5862,5800,5811,5802,551,166,1333,5863,5798,5855,5864,5800,5805,5802,551,166,1333,5865,5798,5852,5866,5800,5811,5802,551,166,1333,5867,5798,5855,5868,5800,5805,5802,551,166,1333,5869,5798,5852,5870,5800,5805,5802,551,166,1333,5871,5798,5855,5872,5800,5811,5802,551,166,1333,5873,5798,5852,5874,5800,5805,5802,551,166,1333,5875,5798,5855,5876,5800,5811,5802,551,166,1333,5877,5798,5878,5821,5822,551,166,1333,5879,5798,5880,5800,5881,5802,551,166,1333,5882,5798,5883,5821,5822,551,166,1333,5884,5798,5885,5800,5886,5802,551,166,1333,5887,5798,5888,5821,5822,551,166,1333,5889,5798,5890,5800,5891,5802,551,166,1333,5892,5798,5893,5821,5822,551,166,1333,5894,5798,5895,5800,5896,5802,551,166,1333,5897,5798,5898,5800,5805,5802,551,166,1333,5899,5798,5900,5800,5850,5802,551,166,1333,5901,5798,5902,5821,5822,551,166,1333,5903,5798,5904,5800,5905,5802,551,166,1333,5906,5798,5907,5800,5811,5802,551,166,1333,5908,5798,5909,5800,5881,5802,551,166,1333,5910,5798,5911,5821,5822,551,166,1333,5912,5798,5913,5914,5915,5800,5916,5802,551,166,1333,5917,5798,5918,5919,5920,5800,5805,5802,551,166,1333,5921,5798,5918,5919,5922,5800,5923,5802,551,166,1333,5924,5798,5913,5914,5925,5800,5926,5802,551,166,1333,5927,5798,5918,5919,5928,5800,5811,5802,551,166,1333,5929,5798,5918,5919,5930,5800,5923,5802,551,166,1333,5931,5798,5932,5800,5933,5802,551,166,1333,5934,5798,5935,5800,5805,5802,551,166,1333,5936,5798,5937,5800,5938,5802,551,166,1333,5939,5798,166,5940,5941,5942,5943,166,5944,5945,5946,166,5947,5948,551,166,1333,5949,5798,166,5950,5951,5942,5943,166,5952,5953,5946,166,5947,5954,551,166,1333,5955,5798,166,5956,5957,5958,5734,5942,5943,166,5959,5960,5946,166,5947,5961,5962,1341,5963,5964,5965,826,551,166,1333,5966,5798,166,5967,5968,5957,5914,5969,5734,166,5942,5943,166,5970,5971,5972,5973,166,5946,166,5947,5974,551,166,1333,5975,5798,166,5976,5977,5957,5914,5978,5734,166,5942,5943,166,5979,5971,5972,5980,166,5946,166,5947,5981,551,166,1333,5982,5798,166,5983,5984,5942,5943,166,5985,5986,5946,166,5947,5987,551,166,1333,5988,5798,166,5989,5990,5942,5943,166,5991,5992,166,5993,5994,5995,5996,166,5997,5998,551,166,1333,5999,5798,166,6000,6001,6002,6003,5972,6004,5734,166,6005,6006,5734,166,6007,5943,166,6008,6009,5971,5972,6004,6010,166,5946,166,5947,1494,6011,6012,826,551,475],"//! This module contains predicate expressions.","//! Predicate expressions are used to filter data, and evaluates to a boolean value. For example,","//! `a > 10` is a predicate expression, and it evaluates to `true` if `a` is greater than `10`,","use std::fmt::{Debug, Display, Formatter};","use std::ops::Not;","use array_init::array_init;","use fnv::FnvHashSet;","use itertools::Itertools;","use crate::expr::visitors::bound_predicate_visitor::visit as visit_bound;","use crate::expr::visitors::predicate_visitor::visit;","use crate::expr::visitors::rewrite_not::RewriteNotVisitor;","use crate::expr::{Bind, BoundReference, PredicateOperator, Reference};","use crate::spec::{Datum, PrimitiveLiteral, SchemaRef};","/// Logical expression, such as `AND`, `OR`, `NOT`.","#[derive(PartialEq, Clone)]","pub struct LogicalExpression {"," inputs: [Box; N],","impl Serialize for LogicalExpression {"," where S: serde::Serializer {"," self.inputs.serialize(serializer)","impl<'de, T: Deserialize<'de>, const N: usize> Deserialize<'de> for LogicalExpression {"," where D: serde::Deserializer<'de> {"," let inputs = Vec::>::deserialize(deserializer)?;"," Ok(LogicalExpression::new("," array_init::from_iter(inputs.into_iter()).ok_or_else(|| {"," serde::de::Error::custom(format!(\"Failed to deserialize LogicalExpression: the len of inputs is not match with the len of LogicalExpression {N}\"))"," })?,","impl Debug for LogicalExpression {"," f.debug_struct(\"LogicalExpression\")"," .field(\"inputs\", &self.inputs)"," .finish()","impl LogicalExpression {"," fn new(inputs: [Box; N]) -> Self {"," Self { inputs }"," /// Return inputs of this logical expression."," pub fn inputs(&self) -> [&T; N] {"," let mut ret: [&T; N] = [self.inputs[0].as_ref(); N];"," for (i, item) in ret.iter_mut().enumerate() {"," *item = &self.inputs[i];","impl Bind for LogicalExpression","where T::Bound: Sized"," type Bound = LogicalExpression;"," fn bind(&self, schema: SchemaRef, case_sensitive: bool) -> Result {"," let mut outputs: [Option>; N] = array_init(|_| None);"," for (i, input) in self.inputs.iter().enumerate() {"," outputs[i] = Some(Box::new(input.bind(schema.clone(), case_sensitive)?));"," // It's safe to use `unwrap` here since they are all `Some`."," let bound_inputs = array_init::from_iter(outputs.into_iter().map(Option::unwrap)).unwrap();"," Ok(LogicalExpression::new(bound_inputs))","/// Unary predicate, for example, `a IS NULL`.","#[derive(PartialEq, Clone, Serialize, Deserialize)]","pub struct UnaryExpression {"," /// Operator of this predicate, must be single operand operator."," op: PredicateOperator,"," /// Term of this predicate, for example, `a` in `a IS NULL`."," #[serde(bound(serialize = \"T: Serialize\", deserialize = \"T: Deserialize<'de>\"))]"," term: T,","impl Debug for UnaryExpression {"," f.debug_struct(\"UnaryExpression\")"," .field(\"op\", &self.op)"," .field(\"term\", &self.term)","impl Display for UnaryExpression {"," write!(f, \"{} {}\", self.term, self.op)","impl Bind for UnaryExpression {"," type Bound = UnaryExpression;"," let bound_term = self.term.bind(schema, case_sensitive)?;"," Ok(UnaryExpression::new(self.op, bound_term))","impl UnaryExpression {"," /// Creates a unary expression with the given operator and term."," /// # Example"," /// ```rust"," /// use iceberg::expr::{PredicateOperator, Reference, UnaryExpression};"," /// UnaryExpression::new(PredicateOperator::IsNull, Reference::new(\"c\"));"," /// ```"," pub fn new(op: PredicateOperator, term: T) -> Self {"," debug_assert!(op.is_unary());"," Self { op, term }"," /// Return the operator of this predicate."," pub fn op(&self) -> PredicateOperator {"," self.op"," /// Return the term of this predicate."," pub fn term(&self) -> &T {"," &self.term","/// Binary predicate, for example, `a > 10`.","pub struct BinaryExpression {"," /// Operator of this predicate, must be binary operator, such as `=`, `>`, `<`, etc."," /// Term of this predicate, for example, `a` in `a > 10`."," /// Literal of this predicate, for example, `10` in `a > 10`."," literal: Datum,","impl Debug for BinaryExpression {"," f.debug_struct(\"BinaryExpression\")"," .field(\"literal\", &self.literal)","impl BinaryExpression {"," /// Creates a binary expression with the given operator, term and literal."," /// use iceberg::expr::{BinaryExpression, PredicateOperator, Reference};"," /// use iceberg::spec::Datum;"," /// BinaryExpression::new("," /// PredicateOperator::LessThanOrEq,"," /// Reference::new(\"a\"),"," /// Datum::int(10),"," /// );"," pub fn new(op: PredicateOperator, term: T, literal: Datum) -> Self {"," debug_assert!(op.is_binary());"," Self { op, term, literal }"," /// Return the operator used by this predicate expression."," /// Return the literal of this predicate."," pub fn literal(&self) -> &Datum {"," &self.literal","impl Display for BinaryExpression {"," write!(f, \"{} {} {}\", self.term, self.op, self.literal)","impl Bind for BinaryExpression {"," type Bound = BinaryExpression;"," let bound_term = self.term.bind(schema.clone(), case_sensitive)?;"," Ok(BinaryExpression::new("," self.op,"," bound_term,"," self.literal.clone(),","/// Set predicates, for example, `a in (1, 2, 3)`.","pub struct SetExpression {"," /// Operator of this predicate, must be set operator, such as `IN`, `NOT IN`, etc."," /// Term of this predicate, for example, `a` in `a in (1, 2, 3)`."," /// Literals of this predicate, for example, `(1, 2, 3)` in `a in (1, 2, 3)`."," literals: FnvHashSet,","impl Debug for SetExpression {"," f.debug_struct(\"SetExpression\")"," .field(\"literal\", &self.literals)","impl SetExpression {"," /// Creates a set expression with the given operator, term and literal."," /// use fnv::FnvHashSet;"," /// use iceberg::expr::{PredicateOperator, Reference, SetExpression};"," /// SetExpression::new("," /// PredicateOperator::In,"," /// FnvHashSet::from_iter(vec![Datum::int(1)]),"," pub fn new(op: PredicateOperator, term: T, literals: FnvHashSet) -> Self {"," debug_assert!(op.is_set());"," Self { op, term, literals }"," /// Return the hash set of values compared against the term in this expression."," pub fn literals(&self) -> &FnvHashSet {"," &self.literals","impl Bind for SetExpression {"," type Bound = SetExpression;"," Ok(SetExpression::new("," self.literals.clone(),","impl Display for SetExpression {"," let mut literal_strs = self"," .literals"," .sorted_by(|a, b| {"," a.partial_cmp(b)"," .unwrap_or_else(|| format!(\"{a}\").cmp(&format!(\"{b}\")))"," .map(|l| format!(\"{l}\"));"," write!(f, \"{} {} ({})\", self.term, self.op, literal_strs.join(\", \"))","/// Unbound predicate expression before binding to a schema.","#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]","pub enum Predicate {"," /// AlwaysTrue predicate, for example, `TRUE`."," AlwaysTrue,"," /// AlwaysFalse predicate, for example, `FALSE`."," AlwaysFalse,"," /// And predicate, for example, `a > 10 AND b < 20`."," And(LogicalExpression),"," /// Or predicate, for example, `a > 10 OR b < 20`."," Or(LogicalExpression),"," /// Not predicate, for example, `NOT (a > 10)`."," Not(LogicalExpression),"," /// Unary expression, for example, `a IS NULL`."," Unary(UnaryExpression),"," /// Binary expression, for example, `a > 10`."," Binary(BinaryExpression),"," /// Set predicates, for example, `a in (1, 2, 3)`."," Set(SetExpression),","impl Bind for Predicate {"," type Bound = BoundPredicate;"," fn bind(&self, schema: SchemaRef, case_sensitive: bool) -> Result {"," Predicate::And(expr) => {"," let bound_expr = expr.bind(schema, case_sensitive)?;"," let [left, right] = bound_expr.inputs;"," Ok(match (left, right) {"," (_, r) if matches!(&*r, &BoundPredicate::AlwaysFalse) => {"," BoundPredicate::AlwaysFalse"," (l, _) if matches!(&*l, &BoundPredicate::AlwaysFalse) => {"," (left, r) if matches!(&*r, &BoundPredicate::AlwaysTrue) => *left,"," (l, right) if matches!(&*l, &BoundPredicate::AlwaysTrue) => *right,"," (left, right) => BoundPredicate::And(LogicalExpression::new([left, right])),"," Predicate::Not(expr) => {"," let [inner] = bound_expr.inputs;"," Ok(match inner {"," e if matches!(&*e, &BoundPredicate::AlwaysTrue) => BoundPredicate::AlwaysFalse,"," e if matches!(&*e, &BoundPredicate::AlwaysFalse) => BoundPredicate::AlwaysTrue,"," e => BoundPredicate::Not(LogicalExpression::new([e])),"," Predicate::Or(expr) => {"," (l, r)"," if matches!(&*r, &BoundPredicate::AlwaysTrue)"," || matches!(&*l, &BoundPredicate::AlwaysTrue) =>"," BoundPredicate::AlwaysTrue"," (left, r) if matches!(&*r, &BoundPredicate::AlwaysFalse) => *left,"," (l, right) if matches!(&*l, &BoundPredicate::AlwaysFalse) => *right,"," (left, right) => BoundPredicate::Or(LogicalExpression::new([left, right])),"," Predicate::Unary(expr) => {"," match &bound_expr.op {"," &PredicateOperator::IsNull => {"," if bound_expr.term.field().required {"," return Ok(BoundPredicate::AlwaysFalse);"," &PredicateOperator::NotNull => {"," return Ok(BoundPredicate::AlwaysTrue);"," &PredicateOperator::IsNan | &PredicateOperator::NotNan => {"," if !bound_expr.term.field().field_type.is_floating_type() {"," return Err(Error::new("," format!("," \"Expecting floating point type, but found {}\","," bound_expr.term.field().field_type"," ),"," ));"," op => {"," return Err(Error::new("," format!(\"Expecting unary operator, but found {op}\"),"," ));"," Ok(BoundPredicate::Unary(bound_expr))"," Predicate::Binary(expr) => {"," let bound_literal = bound_expr.literal.to(&bound_expr.term.field().field_type)?;"," match bound_literal.literal() {"," PrimitiveLiteral::AboveMax => match &bound_expr.op {"," &PredicateOperator::LessThan"," | &PredicateOperator::LessThanOrEq"," | &PredicateOperator::NotEq => {"," &PredicateOperator::GreaterThan"," | &PredicateOperator::GreaterThanOrEq"," | &PredicateOperator::Eq => {"," _ => {}"," PrimitiveLiteral::BelowMin => match &bound_expr.op {"," _ => {}"," Ok(BoundPredicate::Binary(BinaryExpression::new("," bound_expr.op,"," bound_expr.term,"," bound_literal,"," Predicate::Set(expr) => {"," let bound_literals = bound_expr"," .literals"," .map(|l| l.to(&bound_expr.term.field().field_type))"," .collect::>>()?;"," &PredicateOperator::In => {"," if bound_literals.is_empty() {"," if bound_literals.len() == 1 {"," return Ok(BoundPredicate::Binary(BinaryExpression::new("," PredicateOperator::Eq,"," bound_expr.term,"," bound_literals.into_iter().next().unwrap(),"," )));"," &PredicateOperator::NotIn => {"," PredicateOperator::NotEq,"," format!(\"Expecting unary operator,but found {op}\"),"," Ok(BoundPredicate::Set(SetExpression::new("," bound_literals,"," Predicate::AlwaysTrue => Ok(BoundPredicate::AlwaysTrue),"," Predicate::AlwaysFalse => Ok(BoundPredicate::AlwaysFalse),","impl Display for Predicate {"," Predicate::AlwaysTrue => {"," write!(f, \"TRUE\")"," Predicate::AlwaysFalse => {"," write!(f, \"FALSE\")"," write!(f, \"({}) AND ({})\", expr.inputs()[0], expr.inputs()[1])"," write!(f, \"({}) OR ({})\", expr.inputs()[0], expr.inputs()[1])"," write!(f, \"NOT ({})\", expr.inputs()[0])"," write!(f, \"{expr}\")","impl Predicate {"," /// Combines two predicates with `AND`."," /// use std::ops::Bound::Unbounded;"," /// use iceberg::expr::BoundPredicate::Unary;"," /// use iceberg::expr::Reference;"," /// let expr1 = Reference::new(\"a\").less_than(Datum::long(10));"," /// let expr2 = Reference::new(\"b\").less_than(Datum::long(20));"," /// let expr = expr1.and(expr2);"," /// assert_eq!(&format!(\"{expr}\"), \"(a < 10) AND (b < 20)\");"," pub fn and(self, other: Predicate) -> Predicate {"," match (self, other) {"," (Predicate::AlwaysFalse, _) => Predicate::AlwaysFalse,"," (_, Predicate::AlwaysFalse) => Predicate::AlwaysFalse,"," (Predicate::AlwaysTrue, rhs) => rhs,"," (lhs, Predicate::AlwaysTrue) => lhs,"," (lhs, rhs) => Predicate::And(LogicalExpression::new([Box::new(lhs), Box::new(rhs)])),"," /// Combines two predicates with `OR`."," /// let expr = expr1.or(expr2);"," /// assert_eq!(&format!(\"{expr}\"), \"(a < 10) OR (b < 20)\");"," pub fn or(self, other: Predicate) -> Predicate {"," (Predicate::AlwaysTrue, _) => Predicate::AlwaysTrue,"," (_, Predicate::AlwaysTrue) => Predicate::AlwaysTrue,"," (Predicate::AlwaysFalse, rhs) => rhs,"," (lhs, Predicate::AlwaysFalse) => lhs,"," (lhs, rhs) => Predicate::Or(LogicalExpression::new([Box::new(lhs), Box::new(rhs)])),"," /// Returns a predicate representing the negation ('NOT') of this one,"," /// by using inverse predicates rather than wrapping in a `NOT`."," /// Used for `NOT` elimination."," /// use iceberg::expr::{LogicalExpression, Predicate, Reference};"," /// let expr2 = Reference::new(\"b\")"," /// .less_than(Datum::long(5))"," /// .and(Reference::new(\"c\").less_than(Datum::long(10)));"," /// let result = expr1.negate();"," /// assert_eq!(&format!(\"{result}\"), \"a >= 10\");"," /// let result = expr2.negate();"," /// assert_eq!(&format!(\"{result}\"), \"(b >= 5) OR (c >= 10)\");"," pub fn negate(self) -> Predicate {"," Predicate::AlwaysTrue => Predicate::AlwaysFalse,"," Predicate::AlwaysFalse => Predicate::AlwaysTrue,"," Predicate::And(expr) => Predicate::Or(LogicalExpression::new("," expr.inputs.map(|expr| Box::new(expr.negate())),"," Predicate::Or(expr) => Predicate::And(LogicalExpression::new("," let LogicalExpression { inputs: [input_0] } = expr;"," *input_0"," Predicate::Unary(UnaryExpression::new(expr.op.negate(), expr.term))"," Predicate::Binary(expr) => Predicate::Binary(BinaryExpression::new("," expr.op.negate(),"," expr.term,"," expr.literal,"," Predicate::Set(expr) => Predicate::Set(SetExpression::new("," expr.literals,"," /// Simplifies the expression by removing `NOT` predicates,"," /// directly negating the inner expressions instead. The transformation"," /// applies logical laws (such as De Morgan's laws) to"," /// recursively negate and simplify inner expressions within `NOT`"," /// predicates."," /// use std::ops::Not;"," /// let expression = Reference::new(\"a\").less_than(Datum::long(5)).not();"," /// let result = expression.rewrite_not();"," /// assert_eq!(&format!(\"{result}\"), \"a >= 5\");"," pub fn rewrite_not(self) -> Predicate {"," visit(&mut RewriteNotVisitor::new(), &self)"," .expect(\"RewriteNotVisitor guarantees always success\")","impl Not for Predicate {"," type Output = Predicate;"," /// Create a predicate which is the reverse of this predicate. For example: `NOT (a > 10)`."," /// This is different from [`Predicate::negate()`] since it doesn't rewrite expression, but"," /// just adds a `NOT` operator."," ///```rust"," /// let expr = !expr1;"," /// assert_eq!(&format!(\"{expr}\"), \"NOT (a < 10)\");"," fn not(self) -> Self::Output {"," Predicate::Not(LogicalExpression::new([Box::new(self)]))","/// Bound predicate expression after binding to a schema.","#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]","pub enum BoundPredicate {"," /// An expression always evaluates to true."," /// An expression always evaluates to false."," /// An expression combined by `AND`, for example, `a > 10 AND b < 20`."," And(LogicalExpression),"," /// An expression combined by `OR`, for example, `a > 10 OR b < 20`."," Or(LogicalExpression),"," /// An expression combined by `NOT`, for example, `NOT (a > 10)`."," Not(LogicalExpression),"," Unary(UnaryExpression),"," Binary(BinaryExpression),"," /// Set predicates, for example, `a IN (1, 2, 3)`."," Set(SetExpression),","impl BoundPredicate {"," pub(crate) fn and(self, other: BoundPredicate) -> BoundPredicate {"," BoundPredicate::And(LogicalExpression::new([Box::new(self), Box::new(other)]))"," pub(crate) fn or(self, other: BoundPredicate) -> BoundPredicate {"," BoundPredicate::Or(LogicalExpression::new([Box::new(self), Box::new(other)]))"," pub(crate) fn negate(self) -> BoundPredicate {"," BoundPredicate::AlwaysTrue => BoundPredicate::AlwaysFalse,"," BoundPredicate::AlwaysFalse => BoundPredicate::AlwaysTrue,"," BoundPredicate::And(expr) => BoundPredicate::Or(LogicalExpression::new("," BoundPredicate::Or(expr) => BoundPredicate::And(LogicalExpression::new("," BoundPredicate::Not(expr) => {"," BoundPredicate::Unary(expr) => {"," BoundPredicate::Unary(UnaryExpression::new(expr.op.negate(), expr.term))"," BoundPredicate::Binary(expr) => BoundPredicate::Binary(BinaryExpression::new("," BoundPredicate::Set(expr) => BoundPredicate::Set(SetExpression::new("," /// use iceberg::expr::{Bind, BoundPredicate, Reference};"," /// // This would need to be bound first, but the concept is:"," /// // let expression = bound_predicate.not();"," /// // let result = expression.rewrite_not();"," pub fn rewrite_not(self) -> BoundPredicate {"," visit_bound(&mut RewriteNotVisitor::new(), &self)","impl Display for BoundPredicate {"," BoundPredicate::AlwaysTrue => {"," write!(f, \"True\")"," BoundPredicate::AlwaysFalse => {"," write!(f, \"False\")"," BoundPredicate::And(expr) => {"," BoundPredicate::Or(expr) => {"," BoundPredicate::Binary(expr) => {"," BoundPredicate::Set(expr) => {"," use std::ops::Not;"," use crate::expr::Predicate::{AlwaysFalse, AlwaysTrue};"," use crate::expr::{Bind, BoundPredicate, Reference};"," use crate::spec::{Datum, NestedField, PrimitiveType, Schema, SchemaRef, Type};"," fn test_logical_or_rewrite_not() {"," let expression = Reference::new(\"b\")"," .less_than(Datum::long(5))"," .or(Reference::new(\"c\").less_than(Datum::long(10)))"," .not();"," let expected = Reference::new(\"b\")"," .greater_than_or_equal_to(Datum::long(5))"," .and(Reference::new(\"c\").greater_than_or_equal_to(Datum::long(10)));"," let result = expression.rewrite_not();"," assert_eq!(result, expected);"," fn test_logical_and_rewrite_not() {"," .and(Reference::new(\"c\").less_than(Datum::long(10)))"," .or(Reference::new(\"c\").greater_than_or_equal_to(Datum::long(10)));"," fn test_set_rewrite_not() {"," let expression = Reference::new(\"a\")"," .is_in([Datum::int(5), Datum::int(6)])"," let expected = Reference::new(\"a\").is_not_in([Datum::int(5), Datum::int(6)]);"," fn test_binary_rewrite_not() {"," let expression = Reference::new(\"a\").less_than(Datum::long(5)).not();"," let expected = Reference::new(\"a\").greater_than_or_equal_to(Datum::long(5));"," fn test_unary_rewrite_not() {"," let expression = Reference::new(\"a\").is_null().not();"," let expected = Reference::new(\"a\").is_not_null();"," fn test_predicate_and_reduce_always_true_false() {"," let true_or_expr = AlwaysTrue.and(Reference::new(\"b\").less_than(Datum::long(5)));"," assert_eq!(&format!(\"{true_or_expr}\"), \"b < 5\");"," let expr_or_true = Reference::new(\"b\")"," .and(AlwaysTrue);"," assert_eq!(&format!(\"{expr_or_true}\"), \"b < 5\");"," let false_or_expr = AlwaysFalse.and(Reference::new(\"b\").less_than(Datum::long(5)));"," assert_eq!(&format!(\"{false_or_expr}\"), \"FALSE\");"," let expr_or_false = Reference::new(\"b\")"," .and(AlwaysFalse);"," assert_eq!(&format!(\"{expr_or_false}\"), \"FALSE\");"," fn test_predicate_or_reduce_always_true_false() {"," let true_or_expr = AlwaysTrue.or(Reference::new(\"b\").less_than(Datum::long(5)));"," assert_eq!(&format!(\"{true_or_expr}\"), \"TRUE\");"," let expr_or_true = Reference::new(\"b\").less_than(Datum::long(5)).or(AlwaysTrue);"," assert_eq!(&format!(\"{expr_or_true}\"), \"TRUE\");"," let false_or_expr = AlwaysFalse.or(Reference::new(\"b\").less_than(Datum::long(5)));"," assert_eq!(&format!(\"{false_or_expr}\"), \"b < 5\");"," .or(AlwaysFalse);"," assert_eq!(&format!(\"{expr_or_false}\"), \"b < 5\");"," fn test_predicate_negate_and() {"," .and(Reference::new(\"c\").less_than(Datum::long(10)));"," let result = expression.negate();"," fn test_predicate_negate_or() {"," fn test_predicate_negate_not() {"," let expected = Reference::new(\"b\").greater_than_or_equal_to(Datum::long(5));"," fn test_predicate_negate_unary() {"," let expression = Reference::new(\"b\").is_not_null();"," let expected = Reference::new(\"b\").is_null();"," fn test_predicate_negate_binary() {"," let expression = Reference::new(\"a\").less_than(Datum::long(5));"," fn test_predicate_negate_set() {"," let expression = Reference::new(\"a\").is_in([Datum::long(5), Datum::long(6)]);"," let expected = Reference::new(\"a\").is_not_in([Datum::long(5), Datum::long(6)]);"," pub fn table_schema_simple() -> SchemaRef {"," Arc::new("," NestedField::optional(1, \"foo\", Type::Primitive(PrimitiveType::String)).into(),"," NestedField::required(2, \"bar\", Type::Primitive(PrimitiveType::Int)).into(),"," NestedField::optional(3, \"baz\", Type::Primitive(PrimitiveType::Boolean)).into(),"," NestedField::optional(4, \"qux\", Type::Primitive(PrimitiveType::Float)).into(),"," fn test_bound_predicate_serialize_diserialize(bound_predicate: BoundPredicate) {"," let serialized = serde_json::to_string(&bound_predicate).unwrap();"," let deserialized: BoundPredicate = serde_json::from_str(&serialized).unwrap();"," assert_eq!(bound_predicate, deserialized);"," fn test_bind_is_null() {"," let schema = table_schema_simple();"," let expr = Reference::new(\"foo\").is_null();"," let bound_expr = expr.bind(schema, true).unwrap();"," assert_eq!(&format!(\"{bound_expr}\"), \"foo IS NULL\");"," test_bound_predicate_serialize_diserialize(bound_expr);"," fn test_bind_is_null_required() {"," let expr = Reference::new(\"bar\").is_null();"," assert_eq!(&format!(\"{bound_expr}\"), \"False\");"," fn test_bind_is_not_null() {"," let expr = Reference::new(\"foo\").is_not_null();"," assert_eq!(&format!(\"{bound_expr}\"), \"foo IS NOT NULL\");"," fn test_bind_is_not_null_required() {"," let expr = Reference::new(\"bar\").is_not_null();"," assert_eq!(&format!(\"{bound_expr}\"), \"True\");"," fn test_bind_is_nan() {"," let expr = Reference::new(\"qux\").is_nan();"," assert_eq!(&format!(\"{bound_expr}\"), \"qux IS NAN\");"," let schema_string = table_schema_simple();"," let expr_string = Reference::new(\"foo\").is_nan();"," let bound_expr_string = expr_string.bind(schema_string, true);"," assert!(bound_expr_string.is_err());"," fn test_bind_is_nan_wrong_type() {"," let expr = Reference::new(\"foo\").is_nan();"," let bound_expr = expr.bind(schema, true);"," assert!(bound_expr.is_err());"," fn test_bind_is_not_nan() {"," let expr = Reference::new(\"qux\").is_not_nan();"," assert_eq!(&format!(\"{bound_expr}\"), \"qux IS NOT NAN\");"," fn test_bind_is_not_nan_wrong_type() {"," let expr = Reference::new(\"foo\").is_not_nan();"," fn test_bind_less_than() {"," let expr = Reference::new(\"bar\").less_than(Datum::int(10));"," assert_eq!(&format!(\"{bound_expr}\"), \"bar < 10\");"," fn test_bind_less_than_wrong_type() {"," let expr = Reference::new(\"bar\").less_than(Datum::string(\"abcd\"));"," fn test_bind_less_than_or_eq() {"," let expr = Reference::new(\"bar\").less_than_or_equal_to(Datum::int(10));"," assert_eq!(&format!(\"{bound_expr}\"), \"bar <= 10\");"," fn test_bind_less_than_or_eq_wrong_type() {"," let expr = Reference::new(\"bar\").less_than_or_equal_to(Datum::string(\"abcd\"));"," fn test_bind_greater_than() {"," let expr = Reference::new(\"bar\").greater_than(Datum::int(10));"," assert_eq!(&format!(\"{bound_expr}\"), \"bar > 10\");"," fn test_bind_greater_than_wrong_type() {"," let expr = Reference::new(\"bar\").greater_than(Datum::string(\"abcd\"));"," fn test_bind_greater_than_or_eq() {"," let expr = Reference::new(\"bar\").greater_than_or_equal_to(Datum::int(10));"," assert_eq!(&format!(\"{bound_expr}\"), \"bar >= 10\");"," fn test_bind_greater_than_or_eq_wrong_type() {"," let expr = Reference::new(\"bar\").greater_than_or_equal_to(Datum::string(\"abcd\"));"," fn test_bind_equal_to() {"," let expr = Reference::new(\"bar\").equal_to(Datum::int(10));"," assert_eq!(&format!(\"{bound_expr}\"), \"bar = 10\");"," fn test_bind_equal_to_above_max() {"," // int32 can hold up to 2147483647"," let expr = Reference::new(\"bar\").equal_to(Datum::long(2147483648i64));"," fn test_bind_equal_to_below_min() {"," // int32 can hold up to -2147483647"," let expr = Reference::new(\"bar\").equal_to(Datum::long(-2147483649i64));"," fn test_bind_not_equal_to_above_max() {"," let expr = Reference::new(\"bar\").not_equal_to(Datum::long(2147483648i64));"," fn test_bind_not_equal_to_below_min() {"," let expr = Reference::new(\"bar\").not_equal_to(Datum::long(-2147483649i64));"," fn test_bind_less_than_above_max() {"," let expr = Reference::new(\"bar\").less_than(Datum::long(2147483648i64));"," fn test_bind_less_than_below_min() {"," let expr = Reference::new(\"bar\").less_than(Datum::long(-2147483649i64));"," fn test_bind_less_than_or_equal_to_above_max() {"," let expr = Reference::new(\"bar\").less_than_or_equal_to(Datum::long(2147483648i64));"," fn test_bind_less_than_or_equal_to_below_min() {"," let expr = Reference::new(\"bar\").less_than_or_equal_to(Datum::long(-2147483649i64));"," fn test_bind_great_than_above_max() {"," let expr = Reference::new(\"bar\").greater_than(Datum::long(2147483648i64));"," fn test_bind_great_than_below_min() {"," let expr = Reference::new(\"bar\").greater_than(Datum::long(-2147483649i64));"," fn test_bind_great_than_or_equal_to_above_max() {"," let expr = Reference::new(\"bar\").greater_than_or_equal_to(Datum::long(2147483648i64));"," fn test_bind_great_than_or_equal_to_below_min() {"," let expr = Reference::new(\"bar\").greater_than_or_equal_to(Datum::long(-2147483649i64));"," fn test_bind_equal_to_wrong_type() {"," let expr = Reference::new(\"bar\").equal_to(Datum::string(\"abcd\"));"," fn test_bind_not_equal_to() {"," let expr = Reference::new(\"bar\").not_equal_to(Datum::int(10));"," assert_eq!(&format!(\"{bound_expr}\"), \"bar != 10\");"," fn test_bind_not_equal_to_wrong_type() {"," let expr = Reference::new(\"bar\").not_equal_to(Datum::string(\"abcd\"));"," fn test_bind_starts_with() {"," let expr = Reference::new(\"foo\").starts_with(Datum::string(\"abcd\"));"," assert_eq!(&format!(\"{bound_expr}\"), r#\"foo STARTS WITH \"abcd\"\"#);"," fn test_bind_starts_with_wrong_type() {"," let expr = Reference::new(\"bar\").starts_with(Datum::string(\"abcd\"));"," fn test_bind_not_starts_with() {"," let expr = Reference::new(\"foo\").not_starts_with(Datum::string(\"abcd\"));"," assert_eq!(&format!(\"{bound_expr}\"), r#\"foo NOT STARTS WITH \"abcd\"\"#);"," fn test_bind_not_starts_with_wrong_type() {"," let expr = Reference::new(\"bar\").not_starts_with(Datum::string(\"abcd\"));"," fn test_bind_in() {"," let expr = Reference::new(\"bar\").is_in([Datum::int(10), Datum::int(20)]);"," assert_eq!(&format!(\"{bound_expr}\"), \"bar IN (10, 20)\");"," fn test_bind_in_empty() {"," let expr = Reference::new(\"bar\").is_in(vec![]);"," fn test_bind_in_one_literal() {"," let expr = Reference::new(\"bar\").is_in(vec![Datum::int(10)]);"," fn test_bind_in_wrong_type() {"," let expr = Reference::new(\"bar\").is_in(vec![Datum::int(10), Datum::string(\"abcd\")]);"," fn test_bind_not_in() {"," let expr = Reference::new(\"bar\").is_not_in([Datum::int(10), Datum::int(20)]);"," assert_eq!(&format!(\"{bound_expr}\"), \"bar NOT IN (10, 20)\");"," fn test_bind_not_in_empty() {"," let expr = Reference::new(\"bar\").is_not_in(vec![]);"," fn test_bind_not_in_one_literal() {"," let expr = Reference::new(\"bar\").is_not_in(vec![Datum::int(10)]);"," fn test_bind_not_in_wrong_type() {"," let expr = Reference::new(\"bar\").is_not_in([Datum::int(10), Datum::string(\"abcd\")]);"," fn test_bind_and() {"," let expr = Reference::new(\"bar\")"," .less_than(Datum::int(10))"," .and(Reference::new(\"foo\").is_null());"," assert_eq!(&format!(\"{bound_expr}\"), \"(bar < 10) AND (foo IS NULL)\");"," fn test_bind_and_always_false() {"," let expr = Reference::new(\"foo\")"," .less_than(Datum::string(\"abcd\"))"," .and(Reference::new(\"bar\").is_null());"," fn test_bind_and_always_true() {"," .and(Reference::new(\"bar\").is_not_null());"," assert_eq!(&format!(\"{bound_expr}\"), r#\"foo < \"abcd\"\"#);"," fn test_bind_or() {"," .or(Reference::new(\"foo\").is_null());"," assert_eq!(&format!(\"{bound_expr}\"), \"(bar < 10) OR (foo IS NULL)\");"," fn test_bind_or_always_true() {"," .or(Reference::new(\"bar\").is_not_null());"," fn test_bind_or_always_false() {"," .or(Reference::new(\"bar\").is_null());"," fn test_bind_not() {"," let expr = !Reference::new(\"bar\").less_than(Datum::int(10));"," assert_eq!(&format!(\"{bound_expr}\"), \"NOT (bar < 10)\");"," fn test_bind_not_always_true() {"," let expr = !Reference::new(\"bar\").is_not_null();"," fn test_bind_not_always_false() {"," let expr = !Reference::new(\"bar\").is_null();"," assert_eq!(&format!(\"{bound_expr}\"), r#\"True\"#);"," fn test_bound_predicate_rewrite_not_binary() {"," // Test NOT elimination on binary predicates: NOT(bar < 10) => bar >= 10"," let predicate = Reference::new(\"bar\").less_than(Datum::int(10)).not();"," let bound_predicate = predicate.bind(schema.clone(), true).unwrap();"," let result = bound_predicate.rewrite_not();"," // The result should be bar >= 10"," let expected_predicate = Reference::new(\"bar\").greater_than_or_equal_to(Datum::int(10));"," let expected_bound = expected_predicate.bind(schema, true).unwrap();"," assert_eq!(result, expected_bound);"," assert_eq!(&format!(\"{result}\"), \"bar >= 10\");"," fn test_bound_predicate_rewrite_not_unary() {"," // Test NOT elimination on unary predicates: NOT(foo IS NULL) => foo IS NOT NULL"," let predicate = Reference::new(\"foo\").is_null().not();"," // The result should be foo IS NOT NULL"," let expected_predicate = Reference::new(\"foo\").is_not_null();"," assert_eq!(&format!(\"{result}\"), \"foo IS NOT NULL\");"," fn test_bound_predicate_rewrite_not_set() {"," // Test NOT elimination on set predicates: NOT(bar IN (10, 20)) => bar NOT IN (10, 20)"," let predicate = Reference::new(\"bar\")"," .is_in([Datum::int(10), Datum::int(20)])"," // The result should be bar NOT IN (10, 20)"," let expected_predicate = Reference::new(\"bar\").is_not_in([Datum::int(10), Datum::int(20)]);"," // Note: HashSet order may vary, so we check that it contains the expected format"," let result_str = format!(\"{result}\");"," result_str.contains(\"bar NOT IN\")"," && result_str.contains(\"10\")"," && result_str.contains(\"20\")"," fn test_bound_predicate_rewrite_not_and_demorgan() {"," // Test De Morgan's law: NOT(A AND B) = (NOT A) OR (NOT B)"," // NOT((bar < 10) AND (foo IS NULL)) => (bar >= 10) OR (foo IS NOT NULL)"," .and(Reference::new(\"foo\").is_null())"," // Expected: (bar >= 10) OR (foo IS NOT NULL)"," let expected_predicate = Reference::new(\"bar\")"," .greater_than_or_equal_to(Datum::int(10))"," .or(Reference::new(\"foo\").is_not_null());"," assert_eq!(&format!(\"{result}\"), \"(bar >= 10) OR (foo IS NOT NULL)\");"," fn test_bound_predicate_rewrite_not_or_demorgan() {"," // Test De Morgan's law: NOT(A OR B) = (NOT A) AND (NOT B)"," // NOT((bar < 10) OR (foo IS NULL)) => (bar >= 10) AND (foo IS NOT NULL)"," .or(Reference::new(\"foo\").is_null())"," // Expected: (bar >= 10) AND (foo IS NOT NULL)"," .and(Reference::new(\"foo\").is_not_null());"," assert_eq!(&format!(\"{result}\"), \"(bar >= 10) AND (foo IS NOT NULL)\");"," fn test_bound_predicate_rewrite_not_double_negative() {"," // Test double negative elimination: NOT(NOT(bar < 10)) => bar < 10"," let predicate = Reference::new(\"bar\").less_than(Datum::int(10)).not().not();"," // The result should be bar < 10 (original predicate)"," let expected_predicate = Reference::new(\"bar\").less_than(Datum::int(10));"," assert_eq!(&format!(\"{result}\"), \"bar < 10\");"," fn test_bound_predicate_rewrite_not_always_true_false() {"," // Test NOT(AlwaysTrue) => AlwaysFalse"," let predicate = Reference::new(\"bar\").is_not_null().not(); // This becomes NOT(AlwaysTrue) since bar is required"," assert_eq!(result, BoundPredicate::AlwaysFalse);"," assert_eq!(&format!(\"{result}\"), \"False\");"," // Test NOT(AlwaysFalse) => AlwaysTrue"," let predicate2 = Reference::new(\"bar\").is_null().not(); // This becomes NOT(AlwaysFalse) since bar is required"," let bound_predicate2 = predicate2.bind(schema, true).unwrap();"," let result2 = bound_predicate2.rewrite_not();"," assert_eq!(result2, BoundPredicate::AlwaysTrue);"," assert_eq!(&format!(\"{result2}\"), \"True\");"," fn test_bound_predicate_rewrite_not_complex_nested() {"," // Test complex nested expression:"," // NOT(NOT((bar >= 10) AND (foo IS NOT NULL)) OR (bar < 5))"," // Should become: ((bar >= 10) AND (foo IS NOT NULL)) AND (bar >= 5)"," let inner_predicate = Reference::new(\"bar\")"," .and(Reference::new(\"foo\").is_not_null())"," let complex_predicate = inner_predicate"," .or(Reference::new(\"bar\").less_than(Datum::int(5)))"," let bound_predicate = complex_predicate.bind(schema.clone(), true).unwrap();"," // Expected: ((bar >= 10) AND (foo IS NOT NULL)) AND (bar >= 5)"," // This is because NOT(NOT(A) OR B) = A AND NOT(B)"," .and(Reference::new(\"bar\").greater_than_or_equal_to(Datum::int(5)));"," &format!(\"{result}\"),"," \"((bar >= 10) AND (foo IS NOT NULL)) AND (bar >= 5)\"",[6014],{"_419":420,"_421":6015,"_292":6016,"_424":62},1339,[425,426,427,428,429,430,431,432,433,432,434,435,436,437,438,439,166,4491,4492,4493,2047,4494,4495,4496,166,4497,4498,4499,4500,166,4501,4502,3717,4503,4504,166,4505,4506,4507,4508,4509,4510,166,4511,4512,166,4513,4514,166,4515,166,4516,4517,4518,4519,4520,570,166,4521,4522,166,4523,4524,4525,4526,4527,166,4528,4529,4530,4531,4532,1191,616,624,166,4533,591,475,166,4534,4535,4536,4537,4538,4539,4540,4541,4542,4543,4544,475,166,4545,4546,2859,4547,4548,4549,4550,570,551,475,166,4551,4552,4553,4554,4555,551,166,4556,4553,4557,4558,551,166,4559,4553,4560,4561,551,166,4562,4563,4564,4565,748,4566,570,551,166,4567,4568,4569,4570,748,4566,570,551,166,4571,4553,4572,4573,4574,4575,826,4576,551,166,4577,4553,4578,4573,4579,4580,826,4581,551,166,4582,4553,4583,4573,4579,4580,826,4584,551,166,4585,4553,4586,4587,4588,4589,594,551,475,166,4590,4591,4592,551,475,166,4593,4594,4595,551,475,166,4596,4597,4598,551,475,166,4599,4600,4601,551,475,166,4602,4603,4604,4605,4606,4607,4608,4609,4610,4611,4612,4613,4614,4615,4616,4617,4618,4619,4620,4621,4622,4623,4624,4625,4626,4627,4628,4629,4630,4631,4632,4633,4634,4635,4636,4637,4638,4639,4640,4641,4642,4643,4644,4645,4646,475,166,4647,4648,4649,4587,4650,4651,4652,4653,4654,4655,4656,4657,4658,4659,4660,4661,4662,4663,4664,4665,4666,594,551,475,166,4667,4668,4669,4670,4671,551,475,166,4672,4673,4674,4675,4676,551,475,166,4677,4673,4674,4678,4679,4680,4681,4682,748,4683,570,551,475,166,4684,4668,4669,2859,4685,4686,624,4687,4688,570,551,475,166,4689,4690,4691,4692,4693,4694,4695,4696,166,4697,4698,4699,4700,475,166,4701,4702,4703,4704,4705,4706,4707,4708,4709,475,166,4710,4690,4711,4712,4713,4714,166,4715,4716,4717,4718,475,166,4719,4720,4721,475,166,4722,4546,2859,4723,4724,4725,4726,4727,4728,4685,4729,624,4730,4731,4732,4733,4734,4735,4736,4737,4738,4739,570,551,475,166,4740,4741,4742,4743,4744,3753,4745,4746,4747,4746,4748,475,166,4749,4673,4674,4750,4751,4752,4753,4754,570,166,4755,166,4756,4757,166,4758,4759,624,166,4760,4761,4762,4763,4764,4765,4766,4767,4768,4769,4770,2927,3017,4771,4772,4773,2927,4774,3017,1191,616,4775,4776,166,4777,624,570,166,4778,4779,551,475,166,4780,4781,4782,562,998,4783,4784,570,551,166,4785,4786,4787,551,166,4788,4789,4790,4791,995,4792,4793,551,166,4794,4795,4796,551,166,4797,4798,4790,4799,4800,4801,4802,4803,871,995,4804,4793,551,166,4805,4806,4807,551,475,166,4808,3744,4809,551,475,166,4810,166,4811,4812,166,4813,4814,551,475,166,4815,4546,4816,3775,4817,570,4818,551,475,166,4819,4820,4821,4822,4823,4824,4825,4826,4827,4828,4829,4830,4831,4832,4833,4834,4835,4836,4837,4838,475,166,2863,2864,4839,4826,4828,4830,4840,4832,4841,4834,4841,4842,4841,4843,475,166,4860,4861,166,4862,6017,6018,6019,6020,6021,6022,6023,6019,6020,6021,166,4871,4872,4873,4874,4875,4876,4877,4878,999,551,475,166,4879,4880,4881,4882,4883,4872,4873,4874,4877,4878,4875,4876,570,551,475,166,4884,4885,166,4886,4887,4888,562,4889,4890,4891,4892,4893,4894,4895,570,551,166,4896,4897,4898,551,166,4899,4900,4901,551,166,4902,4903,4904,551,166,4905,4906,4907,551,166,4908,4909,4910,551,166,4911,4912,4913,600,551,166,4914,4915,4916,600,551,166,4914,4917,4918,600,551,166,4919,4920,4921,600,551,475,166,4922,4546,4923,4924,4925,4926,748,4927,570,4928,4929,4930,570,904,551,475,166,4534,4931,4932,4933,4934,4935,475,166,4936,4937,4938,4939,551,475,166,4940,2452,4941,166,4942,166,4943,3982,3983,1293,166,4944,4945,2472,4946,4947,4948,4949,4950,4951,4952,4953,4954,4949,4955,4953,4947,4956,4949,4957,4958,4959,4960,4961,4953,4962,551,166,4963,4964,2549,4965,4966,4967,4968,4969,4970,4971,4972,4973,4974,729,1824,2637,4975,4966,4976,4977,4978,4979,4980,4981,4982,4983,4984,4985,4986,729,1824,2637,4987,4988,616,4989,624,570,551,166,4990,4991,2549,4992,4993,4994,4995,4996,755,4997,4998,4999,5000,5001,5002,5003,755,5004,5005,5006,755,5007,624,570,551,475,166,4534,5008,5009,5010,5011,5012,5013,5014,5015,5016,475,166,5017,5018,5019,562,5020,5021,570,551,166,5022,5023,562,5024,5025,570,551,166,5026,5027,562,5024,5028,570,551,475,166,1281,1282,2886,2461,166,1286,5029,166,5030,5031,2899,166,2900,5032,5033,166,5034,551,166,1333,5035,5036,5037,5038,5039,5040,5041,5042,5043,5044,5045,5046,5047,5048,5049,5050,5051,5052,5053,5054,5055,5056,5057,551,3195,166,5058,5059,5060,5061,4307,5062,5063,5064,729,1824,5065,2811,5066,2811,5067,2811,5068,2811,4285,5069,5070,5071,729,1824,4285,5072,5073,5074,5075,5076,5077,729,1824,5078,2811,5079,2811,4285,5080,5081,5082,729,1824,4285,5083,5084,5085,729,1824,4285,5086,5087,5088,729,1824,4285,5089,5090,5091,729,1824,5092,2811,4285,5093,5094,5095,729,1824,4285,5096,5097,5098,729,1824,4285,5099,5100,5101,729,1824,2929,5102,5103,566,594,551,166,1333,5104,5036,679,4354,4356,992,4357,5105,5106,5107,5108,5109,5110,5111,5112,4359,5113,616,4109,570,2950,166,5058,5059,5060,5061,5114,5115,5116,5117,5118,5119,5120,5121,5117,5118,5119,2811,5122,2929,5123,5124,566,594,551,166,1333,5125,5036,4708,5126,5127,5037,5128,5129,5130,5131,5132,5133,4624,5037,5134,5135,5136,5137,4624,5037,5138,5139,5130,5140,5038,5039,5141,5142,5143,5144,5145,5146,5141,5147,5148,5149,5145,5146,5141,5150,5151,5144,5152,3105,5057,5153,551,5154,475,5155,166,5156,5157,5158,5159,3465,5160,5161,5162,5163,3465,5160,5161,1396,5164,5165,4177,5166,5167,5168,2811,5169,2811,5170,5171,586,5172,5173,166,5174,551,166,1333,5175,5036,679,5176,5177,5178,5179,570,2950,166,5058,5059,5180,5181,1413,3117,4209,871,1396,566,826,551,166,1333,5182,5036,679,5183,5184,5185,5186,5187,5188,570,2950,166,5058,5059,5189,5190,1824,5191,3115,3114,5192,871,1396,566,826,166,5058,5059,5193,3019,5194,4179,5195,5196,826,551,166,1333,5197,5036,679,5183,5184,5198,5186,5187,5199,570,2950,166,5058,5059,5189,5200,1824,5191,3115,3117,5192,871,1396,566,826,166,5058,5059,5193,3019,5201,4179,5194,5196,826,551,166,1333,5202,5036,679,5183,5184,5198,5186,5203,5199,570,2950,166,5058,5059,5204,3019,5201,4179,5194,5196,826,551,166,1333,5205,5206,5207,5208,5209,5210,4134,5211,5212,5213,2383,570,166,5214,5215,551,166,1333,5216,5217,5218,5219,5220,5221,5222,3618,5223,5224,5225,755,5226,3621,5227,5228,5229,5230,5231,5232,3618,5233,5234,3621,5235,5236,5209,5237,5238,570,166,5239,551,166,1333,5240,5241,5242,5243,679,4354,4356,5244,4109,570,2950,166,5245,5246,166,5247,5248,551,166,1333,5249,5250,5243,679,5176,4356,5244,4109,570,2950,166,5251,1341,3607,5252,826,1341,5253,1614,1615,5254,826,551,475]," let initial_default = value"," .initial_default"," .map(|x| Literal::try_from_json(x, &value.field_type))"," .transpose()?"," .flatten();"," let write_default = value"," .write_default",[6025],{"_419":420,"_421":6026,"_292":6027,"_424":62},1353,[425,426,427,428,429,430,431,432,433,432,434,435,436,437,438,439,166,3702,166,440,2048,441,166,3703,3704,3705,3706,3707,3708,3709,3710,3711,2052,166,3712,3713,3714,3715,3716,3717,3718,3719,3720,3721,449,3722,166,3723,3724,3725,3726,3727,3728,166,3729,3730,3731,3732,3733,3734,3735,3736,166,3737,3738,166,3739,3740,3741,166,3742,475,166,3743,3744,3745,3746,3747,551,475,166,3748,166,3749,3750,3751,3752,3753,3737,3736,3754,475,166,3755,3756,3757,3758,600,551,166,3759,3760,489,3761,3762,3763,600,551,166,3764,3765,3766,600,551,166,3767,3768,3769,600,551,166,3770,3771,3772,600,551,166,3773,3774,3775,3776,570,166,3777,166,3778,3779,166,3780,3781,3782,3783,3784,166,3785,3786,3787,3788,544,166,3789,653,3790,983,166,3791,166,3792,3793,3794,3795,3796,3797,3798,166,3799,3800,3801,166,3802,544,166,3803,3804,3805,3806,3807,3808,166,3809,3810,3811,3812,3813,3814,570,166,3815,551,166,3816,3817,3818,3819,3820,3821,3822,3823,3819,3824,3825,3822,3823,624,3826,3827,3828,616,624,3829,3830,624,3831,3832,3833,624,3834,570,166,904,551,166,3835,3836,166,3837,3838,3839,3840,3841,3842,616,166,3843,3844,3845,3846,3847,1191,616,3848,3849,616,624,570,166,3850,551,166,3851,3852,3853,3838,3839,3854,3855,616,3843,3856,166,3857,3858,3859,3860,3861,166,3862,616,3848,3849,616,624,570,166,3863,551,166,3864,3865,3866,3867,3868,3869,3870,3871,3872,2332,3873,3874,3875,869,692,693,3876,697,871,872,3877,3878,3879,3880,2383,3881,3819,3882,3883,3822,3823,719,691,692,693,3884,3885,697,698,624,166,3886,3887,3888,3889,3890,3819,3891,3892,3893,3894,3823,3819,3895,3896,3893,3894,3823,3897,624,570,166,904,551,475,166,3898,3899,3900,3901,3902,590,3903,3904,3905,570,551,166,3906,3907,3901,3794,3908,3797,3796,3905,570,551,166,3909,3910,3911,551,166,3912,489,3913,3914,3915,3916,3917,551,166,3918,489,3913,3919,3920,3921,3917,551,166,3922,3923,3924,3925,3917,551,166,3926,2158,3927,3928,551,166,3929,2158,3930,3931,551,166,3932,2158,3933,3934,551,166,3939,2158,3940,3941,551,166,3942,3943,3944,551,166,3945,3946,3947,551,166,3948,3949,3950,551,166,3951,3952,3953,3954,551,166,3955,3956,3957,3958,3959,551,166,3960,3961,3962,551,166,3963,3964,3965,551,475,166,3975,2858,3976,3977,3978,570,3979,551,475,166,1281,1282,2458,166,3980,166,3981,3982,3983,1293,3984,3985,3986,166,1333,3987,3988,3989,3990,3991,166,1385,3992,3993,3994,1304,1398,166,3995,3996,3997,3998,3999,551,166,4000,1385,1549,4001,1299,4002,4003,4004,1303,1304,1398,4005,4006,4007,4008,992,4009,4010,4011,4012,755,992,4013,4014,4015,4016,755,992,4017,4018,4011,4019,616,3160,4020,4021,4022,551,166,4023,1298,1549,4001,1299,4002,4003,4004,1389,2956,4024,4025,4026,4027,4028,4029,2616,2811,4030,871,1396,1389,4031,4032,4033,4034,4035,4028,2616,2811,4036,4037,4038,4039,4040,4041,4042,4043,4044,4045,4046,4047,4042,4043,4048,4029,2616,2811,4030,871,1396,1389,4049,4050,4025,4026,4051,4052,4053,4054,4055,4056,4042,4043,4053,4057,4058,4056,4042,4043,4059,4029,2616,2811,4030,871,1396,4060,4061,4062,1392,4063,1394,4064,1394,1395,871,1396,1303,1304,1305,551,166,1333,4065,4066,4067,4068,4069,4070,475,4071,166,4072,551,166,1333,4073,4074,1549,4075,1299,4076,4077,4078,4079,1303,1480,166,1341,4080,1343,4081,826,551,166,1333,4082,4083,4084,4085,166,4086,551,166,1333,4087,4088,4089,4090,4091,4092,4093,4094,4095,4096,4097,4098,4099,4100,4101,4102,4103,4104,4105,4106,4107,4108,4109,4110,826,166,4111,4112,551,166,1333,4113,4088,4089,4114,4115,4116,4117,4118,4119,4120,4121,4122,4123,4124,4125,4126,4127,4128,4129,4130,4131,4132,4109,4110,826,166,4111,4133,4134,4135,4136,2383,570,551,166,1333,4137,4138,4139,4140,4141,4142,4143,4144,4145,4146,4147,4148,4149,4150,4151,4152,1458,166,4111,4153,4134,4154,4155,4156,2383,570,551,166,1333,4157,4111,166,4158,551,166,1333,4159,4160,166,4161,166,4162,4134,4154,4155,4156,2383,570,551,166,1333,4163,4161,166,1494,4164,4165,826,1494,4166,4167,826,1494,4168,4169,826,166,4170,4171,551,166,1333,4172,4173,3618,3174,4174,3621,3618,4175,4176,3621,3618,4177,4178,3621,3618,3019,1389,2956,4024,4025,4026,4027,4028,4029,2616,2811,4030,610,3621,3618,4179,4180,3621,3618,4181,1389,4031,4032,4182,4034,4035,4183,2616,2811,4036,4037,4184,4039,4040,4185,4042,4043,4044,4045,4186,4047,4042,4043,4048,4029,2616,2811,4030,610,3621,3618,4187,4188,3621,3618,4189,1389,4190,4191,4182,4034,4192,4183,2616,2811,4036,4193,4194,4029,2616,2811,4030,610,3621,3618,4195,4196,3621,3618,4197,4198,3621,3618,4199,1389,4049,4050,4200,4026,4051,4201,4053,4054,4055,4202,4042,4043,4053,4057,4058,4202,4042,4043,4059,4029,2616,2811,4030,610,3621,3618,4203,4204,4205,4206,4207,1394,4208,1394,1395,4209,610,3621,3618,4210,4211,3621,3618,4212,4213,3621,3618,4214,4060,4061,4062,1392,4063,1394,4064,1394,1395,610,3621,3618,4215,4216,3621,3618,4217,4218,3621,1458,166,4111,4219,4134,4220,4221,4222,2383,570,551,166,1333,4223,4111,166,4224,4225,4226,4227,4228,4229,4230,4231,4232,4233,4234,4235,4236,4237,4238,4239,4240,4241,4242,1602,4243,4244,4245,4246,4247,1458,166,1494,4248,4249,3434,4250,4251,4252,826,1494,4248,4253,3434,4250,4251,4254,826,1494,4248,4255,3434,4250,4251,4256,826,1494,4248,4257,3434,4250,4251,4258,826,1494,4248,4259,3434,4250,4251,4260,826,551,166,1333,4261,4111,4262,166,4161,4263,551,166,1333,4264,4265,4266,551,166,1333,4267,4268,1549,4269,4270,1299,4271,4272,4004,1303,1304,1678,166,4273,551,166,1333,4274,4265,4275,1818,1199,4276,1304,1398,166,4277,4278,551,166,1333,4279,4280,1341,4281,4282,4283,4284,4285,4286,4287,4288,4289,4043,4290,4291,4292,4293,2672,1394,4294,729,4295,4296,3517,4297,826,1341,4281,4282,4298,4284,4285,4286,4287,4288,4289,4043,4290,4291,4292,4293,2672,1394,4294,729,4295,4296,3517,4297,826,166,4299,1341,4281,4282,4283,4284,4285,4286,4300,4301,4302,4303,4304,4305,2672,1394,4294,729,4295,4296,3517,4297,826,166,4306,1341,4281,4282,4283,4284,4307,4286,4308,4309,4310,4303,4311,4312,2672,1394,4313,4043,4314,729,4295,4296,3517,4297,826,166,4315,1341,4281,4282,4316,4284,4317,4318,4296,3517,4297,826,1341,4281,4282,4316,4284,4319,4318,4296,3517,4297,826,166,4320,1341,4281,4282,4316,4284,4321,4318,4296,3517,4322,826,1341,4281,4282,4316,4284,4323,4318,4296,3517,4297,826,551,166,1333,6028,4353,4354,4355,4356,992,4357,4358,4359,4360,6029,616,4109,591,166,6030,1341,6031,1615,6032,6033,826,551,166,1333,4352,4353,4354,4355,4356,992,4357,4358,4359,4360,4361,4362,616,4109,591,166,4363,551,166,1333,4364,1341,4281,4282,4284,4365,4296,3517,4322,826,166,4366,1549,1299,4367,1303,1304,1678,1341,4368,1343,4369,826,166,4370,1549,1299,4371,4372,1824,1303,1304,1678,1341,4373,1343,4374,826,551,475]," fn test_unknown_type_deserialization_rejects_non_null_default() {"," \"initial-default\": 1"," let error = serde_json::from_value::(schema_json).unwrap_err();"," error"," .contains(\"did not match any variant of untagged enum SchemaEnum\"),"," \"unexpected error: {error}\"",[6035,6036,6037,6038,6039,6040,6041,6042,6043,6044,6045,6046,6047,6048,6049],{"_295":49,"_49":6070},{"_295":4389,"_412":3697,"_419":6068,"_421":6069},{"_295":49,"_49":6067},{"_295":4389,"_412":4486,"_419":5275,"_421":6066},{"_295":49,"_49":6065},{"_295":4389,"_412":3697,"_419":6063,"_421":6064},{"_295":49,"_49":6062},{"_295":4389,"_412":5340,"_419":6060,"_421":6061},{"_295":49,"_49":6059},{"_295":4389,"_412":5340,"_419":6057,"_421":6058},{"_295":49,"_49":6056},{"_295":4389,"_412":5340,"_419":6054,"_421":6055},{"_295":49,"_49":6053},{"_295":4389,"_412":5340,"_419":6051,"_421":6052},{"_295":49,"_49":6050},"\n\n### Commands used\n\n* ✅ `git status --short && git log --oneline -5 && nl -ba crates/iceberg/src/expr/predicate.rs | sed -n '242,324p;1368,1410p' && nl -ba crates/iceberg/src/spec/schema/mod.rs | sed -n '191,205p;1269,1310p' && nl -ba crates/iceberg/src/spec/datatypes.rs | sed -n '532,584p'`\n* ✅ `cargo test -p iceberg --lib test_unknown_type -- --nocapture`\n* ❌ `cargo test -p iceberg --lib test_unknown_type -- --nocapture && cargo test -p iceberg --lib expr::predicate::tests::test_bind_in expr::predicate::tests::test_bind_not_in -- --nocapture` — the unknown tests passed, but the second `cargo test` invocation was invalid because Cargo accepts only one test-name filter in that position.\n* ✅ `cargo test -p iceberg --lib expr::predicate::tests::test_bind_in -- --nocapture && cargo test -p iceberg --lib expr::predicate::tests::test_bind_not_in -- --nocapture`\n\nNo code changes were made for this answer, so I did not create a new commit or PR.",1403,1408,"\n* `bar NOT IN (10, 20)`. ",1368,1374,"\n\nThat directly matches the failing assertion pattern, e.g. predicate tests now expect deterministic formatting like:\n\n* `bar IN (10, 20)`. ",311,323,"\n\nThe previous fix changed `Display for SetExpression` to sort the literals before formatting them. ",242,249,"\n* Those targeted unknown datatype tests passed when I ran them.\n\n### What the failure was actually about\n\nThe failures were from `IN` / `NOT IN` string comparisons. `SetExpression` stores literals in an `FnvHashSet`, so iteration order is not a stable semantic ordering. ",1269,1310,"\n* The regression tests specifically cover rejecting a non-null default on an `unknown` field and accepting explicit `null` defaults. ",582,"\n* The review-comment fix also preserves deserialization errors for `initial-default` and `write-default` by using fallible `Literal::try_from_json(...).transpose()?` instead of dropping parse errors. ",191,203,"### Short answer\n\nNo — the test failure does **not** appear to be caused by the unknown datatype logic itself.\n\nThe unknown datatype tests pass, and the failing tests were in predicate/projection display assertions where `IN` / `NOT IN` literal order came from a hash set. The unknown datatype code is about schema validation/default deserialization, while the failures were about nondeterministic formatting of set predicates.\n\n### Why it is not directly related to `unknown`\n\n* The unknown-type validation is scoped to rejecting required `unknown` fields and rejecting non-null defaults for `unknown` fields. ",{"_112":284,"_45":92,"_116":284,"_285":6073,"_287":-5,"_288":289,"_150":90,"_138":6074},[94],[6075],1778139527.082626,{"_112":280,"_116":284,"_292":6076},[6077],{"_295":49,"_49":6078},"is test failure related to unknown datatype",{"_112":113,"_45":90,"_114":-5,"_115":-5,"_116":113,"_117":6081,"_119":6082,"_121":122,"_123":-5,"_125":-5,"_126":6083,"_128":6084,"_130":6085,"_132":304,"_134":-5,"_135":6086,"_137":6087,"_138":6088,"_140":-5,"_141":142,"_143":6089,"_145":146,"_147":309,"_148":-5,"_149":-5,"_150":88,"_151":6090,"_153":-5,"_154":-5,"_155":18,"_156":157,"_158":-5},[92],[6127,6128,6129],[],{"_276":6126},{"_273":6125},{"_273":6124},"externally_created",{"_344":420,"_264":6117,"_347":348,"_349":18,"_350":62,"_351":18,"_352":6118,"_354":6119,"_356":235,"_357":146,"_358":6120,"_360":309,"_362":6121,"_363":-5,"_364":-5,"_284":6122,"_366":4474,"_367":336,"_369":6123,"_371":372},1778137147.222332,{"_45":142,"_160":161,"_162":163,"_164":18,"_165":166,"_167":168,"_169":6105,"_171":-5,"_172":173,"_174":18,"_175":6106,"_177":166,"_178":166,"_179":6107,"_181":6108,"_183":6109,"_185":-5,"_186":345,"_188":189,"_190":191,"_192":6110,"_58":-5,"_138":194,"_195":6111,"_197":6112,"_199":6113,"_201":18,"_202":18},{"_151":6091},[6092,6093,6094],{"_316":6102,"_318":6103},{"_316":6098,"_318":6099},{"_316":6095,"_318":6096},{"_227":320,"_112":321,"_138":6097},"file_00000000309c71f7bcf3af3ca3d382c8","2026-05-07T04:06:47.581262",{"_227":6100,"_112":321,"_138":6101},"file_000000003e5471f7885a0a27092fb0dd","warm_up_git_repo_1778137151","2026-05-07T06:59:11.379142",{"_227":329,"_112":321,"_138":6104},"file_00000000483071f78a6a7d9d1f54d068","2026-05-07T04:06:38.989506",{"_266":267,"_268":-5,"_269":-5,"_270":-5,"_271":-5,"_272":-5},[224],{"_224":6114},{"_206":207,"_208":209,"_210":211,"_212":213,"_214":215,"_216":217,"_218":219,"_220":221,"_222":223},{},[],{"_205":62},{"_203":62,"_204":166},"\"4c008838-0000-0200-0000-69fc100d0000\"",{"_45":226,"_227":228,"_229":6115,"_231":163,"_232":233,"_234":235,"_236":237,"_238":239,"_240":241,"_242":67,"_243":18,"_244":18,"_245":62,"_246":62,"_247":62,"_248":18,"_249":-5,"_250":251,"_252":-5,"_58":6116},{"_258":259,"_45":260,"_112":261,"_262":263,"_264":265},{"_254":62,"_255":18,"_256":62,"_257":62},"https://github.com/manuzhang/iceberg-rust/pull/1","feat(spec): add unknown datatype support","Add PrimitiveType::Unknown with JSON, Arrow, and Avro null mappings. Validate unknown fields as optional with null defaults and reject unsupported catalog conversions.\r\n\r\n## Which issue does this PR close?\r\n\r\n\r\n\r\n- Closes #.\r\n\r\n## What changes are included in this PR?\r\n\r\n\r\n\r\n## Are these changes tested?\r\n\r\n","db8f44e4ec34e265c6276cd4672667af6bf195d6","14a8638489ff10697d770c6f2768bde5afe85570",{"_258":259,"_227":259,"_373":-5,"_262":263,"_45":260},232,[],[],[],{"_112":280,"_116":113,"_292":6141},{"_112":406,"_407":6140},{"_112":381,"_382":6130,"_383":6131,"_385":6132,"_387":-5},"fix(tests): stabilize set predicate formatting","### Motivation\n\n- Tests were flaky because `IN`/`NOT IN` formatting relied on hash-set iteration order, producing nondeterministic literal sequences. \n- Make predicate display deterministic so test expectations and diagnostic output are stable across runs.\n\n### Description\n\n- Sort set literals before formatting in `Display for SetExpression` by using a stable `iter().sorted_by(...)` comparison so `IN`/`NOT IN` outputs are deterministic. \n- Update affected test expectations to the new canonical ordering in `crates/iceberg/src/expr/predicate.rs`, `crates/iceberg/src/expr/visitors/strict_projection.rs`, `crates/iceberg/src/transform/bucket.rs`, `crates/iceberg/src/transform/temporal.rs`, and `crates/iceberg/src/transform/truncate.rs`. \n- This is a small follow-up to the earlier spec changes (unknown datatype handling) that fixes remaining library test failures caused by nondeterministic display ordering.\n\n### Testing\n\n- Ran `cargo fmt --check` and it succeeded. \n- Ran the full library test suite with `cargo test -p iceberg --lib` and all tests passed. \n- Ran targeted unit tests used during development (including `test_unknown_type`) and they passed.",{"_112":385,"_388":4410,"_147":309,"_389":-5,"_364":6133,"_391":6134,"_393":6135,"_395":6136,"_397":6137,"_399":6130,"_401":6138},"diff --git a/crates/iceberg/src/expr/predicate.rs b/crates/iceberg/src/expr/predicate.rs\nindex 35e88ff3e77bafa839a23e29a3d4f89bddcd73f7..8d3ff94c1e30df2b0a6da2e78b64ede3e12a43a5 100644\n--- a/crates/iceberg/src/expr/predicate.rs\n+++ b/crates/iceberg/src/expr/predicate.rs\n@@ -288,51 +288,58 @@ impl SetExpression {\n pub fn literals(&self) -> &FnvHashSet {\n &self.literals\n }\n \n /// Return the term of this predicate.\n pub fn term(&self) -> &T {\n &self.term\n }\n }\n \n impl Bind for SetExpression {\n type Bound = SetExpression;\n \n fn bind(&self, schema: SchemaRef, case_sensitive: bool) -> Result {\n let bound_term = self.term.bind(schema.clone(), case_sensitive)?;\n Ok(SetExpression::new(\n self.op,\n bound_term,\n self.literals.clone(),\n ))\n }\n }\n \n impl Display for SetExpression {\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n- let mut literal_strs = self.literals.iter().map(|l| format!(\"{l}\"));\n+ let mut literal_strs = self\n+ .literals\n+ .iter()\n+ .sorted_by(|a, b| {\n+ a.partial_cmp(b)\n+ .unwrap_or_else(|| format!(\"{a}\").cmp(&format!(\"{b}\")))\n+ })\n+ .map(|l| format!(\"{l}\"));\n \n write!(f, \"{} {} ({})\", self.term, self.op, literal_strs.join(\", \"))\n }\n }\n \n /// Unbound predicate expression before binding to a schema.\n #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]\n pub enum Predicate {\n /// AlwaysTrue predicate, for example, `TRUE`.\n AlwaysTrue,\n /// AlwaysFalse predicate, for example, `FALSE`.\n AlwaysFalse,\n /// And predicate, for example, `a > 10 AND b < 20`.\n And(LogicalExpression),\n /// Or predicate, for example, `a > 10 OR b < 20`.\n Or(LogicalExpression),\n /// Not predicate, for example, `NOT (a > 10)`.\n Not(LogicalExpression),\n /// Unary expression, for example, `a IS NULL`.\n Unary(UnaryExpression),\n /// Binary expression, for example, `a > 10`.\n Binary(BinaryExpression),\n /// Set predicates, for example, `a in (1, 2, 3)`.\n Set(SetExpression),\n }\n@@ -1341,86 +1348,86 @@ mod tests {\n assert!(bound_expr.is_err());\n }\n \n #[test]\n fn test_bind_not_starts_with() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"foo\").not_starts_with(Datum::string(\"abcd\"));\n let bound_expr = expr.bind(schema, true).unwrap();\n assert_eq!(&format!(\"{bound_expr}\"), r#\"foo NOT STARTS WITH \"abcd\"\"#);\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_not_starts_with_wrong_type() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").not_starts_with(Datum::string(\"abcd\"));\n let bound_expr = expr.bind(schema, true);\n assert!(bound_expr.is_err());\n }\n \n #[test]\n fn test_bind_in() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_in([Datum::int(10), Datum::int(20)]);\n let bound_expr = expr.bind(schema, true).unwrap();\n- assert_eq!(&format!(\"{bound_expr}\"), \"bar IN (20, 10)\");\n+ assert_eq!(&format!(\"{bound_expr}\"), \"bar IN (10, 20)\");\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_in_empty() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_in(vec![]);\n let bound_expr = expr.bind(schema, true).unwrap();\n assert_eq!(&format!(\"{bound_expr}\"), \"False\");\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_in_one_literal() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_in(vec![Datum::int(10)]);\n let bound_expr = expr.bind(schema, true).unwrap();\n assert_eq!(&format!(\"{bound_expr}\"), \"bar = 10\");\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_in_wrong_type() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_in(vec![Datum::int(10), Datum::string(\"abcd\")]);\n let bound_expr = expr.bind(schema, true);\n assert!(bound_expr.is_err());\n }\n \n #[test]\n fn test_bind_not_in() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_not_in([Datum::int(10), Datum::int(20)]);\n let bound_expr = expr.bind(schema, true).unwrap();\n- assert_eq!(&format!(\"{bound_expr}\"), \"bar NOT IN (20, 10)\");\n+ assert_eq!(&format!(\"{bound_expr}\"), \"bar NOT IN (10, 20)\");\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_not_in_empty() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_not_in(vec![]);\n let bound_expr = expr.bind(schema, true).unwrap();\n assert_eq!(&format!(\"{bound_expr}\"), \"True\");\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_not_in_one_literal() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_not_in(vec![Datum::int(10)]);\n let bound_expr = expr.bind(schema, true).unwrap();\n assert_eq!(&format!(\"{bound_expr}\"), \"bar != 10\");\n test_bound_predicate_serialize_diserialize(bound_expr);\n }\n \n #[test]\n fn test_bind_not_in_wrong_type() {\n let schema = table_schema_simple();\n let expr = Reference::new(\"bar\").is_not_in([Datum::int(10), Datum::string(\"abcd\")]);\ndiff --git a/crates/iceberg/src/expr/visitors/strict_projection.rs b/crates/iceberg/src/expr/visitors/strict_projection.rs\nindex ebc6212c767e3e26533279af9d1b993535cc9bdc..414e676f813c7181e0b2f51985d44ae050d6d475 100644\n--- a/crates/iceberg/src/expr/visitors/strict_projection.rs\n+++ b/crates/iceberg/src/expr/visitors/strict_projection.rs\n@@ -402,51 +402,51 @@ mod tests {\n // test not in\n let predicate =\n Reference::new(\"col1\")\n .is_not_in(\n vec![\n Datum::date_from_str(\"1970-01-01\").unwrap(),\n Datum::date_from_str(\"1969-12-31\").unwrap(),\n ]\n .into_iter(),\n )\n .and(Reference::new(\"col2\").is_not_in(\n vec![Datum::timestamp_micros(0), Datum::timestamp_micros(-1)].into_iter(),\n ))\n .and(Reference::new(\"col3\").is_not_in(\n vec![Datum::timestamptz_micros(0), Datum::timestamptz_micros(-1)].into_iter(),\n ))\n .and(Reference::new(\"col4\").is_not_in(\n vec![Datum::timestamp_nanos(0), Datum::timestamp_nanos(-1)].into_iter(),\n ))\n .and(Reference::new(\"col5\").is_not_in(\n vec![Datum::timestamptz_nanos(0), Datum::timestamptz_nanos(-1)].into_iter(),\n ))\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (0, -1)) AND (pcol2 NOT IN (0, -1))) AND (pcol3 NOT IN (0, -1))) AND (pcol4 NOT IN (0, -1))) AND (pcol5 NOT IN (0, -1))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (-1, 0)) AND (pcol2 NOT IN (-1, 0))) AND (pcol3 NOT IN (-1, 0))) AND (pcol4 NOT IN (-1, 0))) AND (pcol5 NOT IN (-1, 0))\".to_string());\n \n // test in\n let predicate =\n Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"1970-01-01\").unwrap(),\n Datum::date_from_str(\"1969-12-31\").unwrap(),\n ]\n .into_iter(),\n )\n .and(Reference::new(\"col2\").is_in(\n vec![Datum::timestamp_micros(0), Datum::timestamp_micros(-1)].into_iter(),\n ))\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n #[tokio::test]\n async fn test_strict_projection_month_lower_bound() {\n let schema = Arc::new(\n Schema::builder()\n .with_fields(vec![\n@@ -636,51 +636,51 @@ mod tests {\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col4\").is_not_in(\n vec![\n Datum::timestamp_nanos(1483228800000000000),\n Datum::timestamp_nanos(1512182400000000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::timestamptz_nanos(1483228800000000000),\n Datum::timestamptz_nanos(1512182400000000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (575, 564)) AND (pcol2 NOT IN (575, 564))) AND (pcol3 NOT IN (575, 564))) AND (pcol4 NOT IN (575, 564))) AND (pcol5 NOT IN (575, 564))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (564, 575)) AND (pcol2 NOT IN (564, 575))) AND (pcol3 NOT IN (564, 575))) AND (pcol4 NOT IN (564, 575))) AND (pcol5 NOT IN (564, 575))\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"2017-01-01\").unwrap(),\n Datum::date_from_str(\"2017-01-02\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_in(\n vec![\n Datum::timestamp_micros(1483228800000000),\n Datum::timestamp_micros(1483315200000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n@@ -864,51 +864,51 @@ mod tests {\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col4\").is_not_in(\n vec![\n Datum::timestamp_nanos(-86400000000000),\n Datum::timestamp_nanos(-31536000000000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::timestamptz_nanos(-86400000000000),\n Datum::timestamptz_nanos(-31536000000000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (-1, -12)) AND (pcol2 NOT IN (-1, -12))) AND (pcol3 NOT IN (-1, -12))) AND (pcol4 NOT IN (-1, -12))) AND (pcol5 NOT IN (-1, -12))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (-12, -1)) AND (pcol2 NOT IN (-12, -1))) AND (pcol3 NOT IN (-12, -1))) AND (pcol4 NOT IN (-12, -1))) AND (pcol5 NOT IN (-12, -1))\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"1969-01-01\").unwrap(),\n Datum::date_from_str(\"1969-12-31\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_in(\n vec![\n Datum::timestamp_micros(-315619200000000),\n Datum::timestamp_micros(-86400000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n@@ -1044,99 +1044,99 @@ mod tests {\n .and(\n Reference::new(\"col5\")\n .greater_than_or_equal_to(Datum::timestamptz_nanos(1514764799000000000)),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(\n result.to_string(),\n \"((((pcol1 > 575) AND (pcol2 > 575)) AND (pcol3 > 575)) AND (pcol4 > 575)) AND (pcol5 > 575)\"\n .to_string()\n );\n \n // test not eq: (col1 != 2017-12-31) AND (col2 != 2017-12-31) AND (col3 != 2017-12-31) AND (col4 != 2017-12-31) AND (col5 != 2017-12-31)\n let predicate = Reference::new(\"col1\")\n .not_equal_to(Datum::date_from_str(\"2017-12-31\").unwrap())\n .and(Reference::new(\"col2\").not_equal_to(Datum::timestamp_micros(1514764799000000)))\n .and(Reference::new(\"col3\").not_equal_to(Datum::timestamptz_micros(1514764799000000)))\n .and(Reference::new(\"col4\").not_equal_to(Datum::timestamp_nanos(1514764799000000000)))\n .and(Reference::new(\"col5\").not_equal_to(Datum::timestamptz_nanos(1514764799000000000)))\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"((((pcol1 != 575) AND (pcol2 != 575)) AND (pcol3 != 575)) AND (pcol4 != 575)) AND (pcol5 != 575)\".to_string());\n \n- // test not in: (col1 NOT IN (2017-12-31, 2017-01-01)) AND (col2 NOT IN (2017-12-31, 2017-01-01)) AND (col3 NOT IN (2017-12-31, 2017-01-01)) AND (col4 NOT IN (2017-12-31, 2017-01-01)) AND (col5 NOT IN (2017-12-31, 2017-01-01))\n+ // test not in: (col1 NOT IN (2017-01-01, 2017-12-31)) AND (col2 NOT IN (2017-01-01, 2017-12-31)) AND (col3 NOT IN (2017-01-01, 2017-12-31)) AND (col4 NOT IN (2017-01-01, 2017-12-31)) AND (col5 NOT IN (2017-01-01, 2017-12-31))\n let predicate = Reference::new(\"col1\")\n .is_not_in(\n vec![\n Datum::date_from_str(\"2017-12-31\").unwrap(),\n Datum::date_from_str(\"2017-01-01\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_not_in(\n vec![\n Datum::timestamp_micros(1514764799000000),\n Datum::timestamp_micros(1483228800000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col3\").is_not_in(\n vec![\n Datum::timestamptz_micros(1514764799000000),\n Datum::timestamptz_micros(1483228800000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col4\").is_not_in(\n vec![\n Datum::timestamp_nanos(1514764799000000000),\n Datum::timestamp_nanos(1483228800000000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::timestamptz_nanos(1514764799000000000),\n Datum::timestamptz_nanos(1483228800000000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (575, 564)) AND (pcol2 NOT IN (575, 564))) AND (pcol3 NOT IN (575, 564))) AND (pcol4 NOT IN (575, 564))) AND (pcol5 NOT IN (575, 564))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (564, 575)) AND (pcol2 NOT IN (564, 575))) AND (pcol3 NOT IN (564, 575))) AND (pcol4 NOT IN (564, 575))) AND (pcol5 NOT IN (564, 575))\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"2017-12-31\").unwrap(),\n Datum::date_from_str(\"2017-01-01\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_in(\n vec![\n Datum::timestamp_micros(1514764799000000),\n Datum::timestamp_micros(1483228800000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n@@ -1702,51 +1702,51 @@ mod tests {\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col4\").is_not_in(\n vec![\n Datum::timestamp_nanos(-172800000000000),\n Datum::timestamp_nanos(-1),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::timestamptz_nanos(-172800000000000),\n Datum::timestamptz_nanos(-1),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (1969-12-31, 1969-12-30)) AND (pcol2 NOT IN (1969-12-31, 1969-12-30))) AND (pcol3 NOT IN (1969-12-31, 1969-12-30))) AND (pcol4 NOT IN (1969-12-31, 1969-12-30))) AND (pcol5 NOT IN (1969-12-31, 1969-12-30))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (1969-12-30, 1969-12-31)) AND (pcol2 NOT IN (1969-12-30, 1969-12-31))) AND (pcol3 NOT IN (1969-12-30, 1969-12-31))) AND (pcol4 NOT IN (1969-12-30, 1969-12-31))) AND (pcol5 NOT IN (1969-12-30, 1969-12-31))\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"1969-12-30\").unwrap(),\n Datum::date_from_str(\"1969-12-31\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_in(\n vec![\n Datum::timestamp_micros(-172800000000),\n Datum::timestamp_micros(-1),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n@@ -1930,51 +1930,51 @@ mod tests {\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col4\").is_not_in(\n vec![\n Datum::timestamp_nanos(1483228800000000000),\n Datum::timestamp_nanos(1483142400000000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::timestamptz_nanos(1483228800000000000),\n Datum::timestamptz_nanos(1483142400000000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (47, 46)) AND (pcol2 NOT IN (47, 46))) AND (pcol3 NOT IN (47, 46))) AND (pcol4 NOT IN (47, 46))) AND (pcol5 NOT IN (47, 46))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (46, 47)) AND (pcol2 NOT IN (46, 47))) AND (pcol3 NOT IN (46, 47))) AND (pcol4 NOT IN (46, 47))) AND (pcol5 NOT IN (46, 47))\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"2017-01-01\").unwrap(),\n Datum::date_from_str(\"2017-12-31\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_in(\n vec![\n Datum::timestamp_micros(1483228800000000),\n Datum::timestamp_micros(1514764799000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n@@ -2314,99 +2314,99 @@ mod tests {\n .and(\n Reference::new(\"col5\")\n .greater_than_or_equal_to(Datum::timestamptz_nanos(1514764799000000000)),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(\n result.to_string(),\n \"((((pcol1 > 47) AND (pcol2 > 47)) AND (pcol3 > 47)) AND (pcol4 > 47)) AND (pcol5 > 47)\"\n .to_string()\n );\n \n // test not eq: (col1 != 2017-12-31) AND (col2 != 2017-12-31) AND (col3 != 2017-12-31) AND (col4 != 2017-12-31) AND (col5 != 2017-12-31)\n let predicate = Reference::new(\"col1\")\n .not_equal_to(Datum::date_from_str(\"2017-12-31\").unwrap())\n .and(Reference::new(\"col2\").not_equal_to(Datum::timestamp_micros(1514764799000000)))\n .and(Reference::new(\"col3\").not_equal_to(Datum::timestamptz_micros(1514764799000000)))\n .and(Reference::new(\"col4\").not_equal_to(Datum::timestamp_nanos(1514764799000000000)))\n .and(Reference::new(\"col5\").not_equal_to(Datum::timestamptz_nanos(1514764799000000000)))\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"((((pcol1 != 47) AND (pcol2 != 47)) AND (pcol3 != 47)) AND (pcol4 != 47)) AND (pcol5 != 47)\".to_string());\n \n- // test not in: (col1 NOT IN (2017-12-31, 2016-01-01)) AND (col2 NOT IN (2017-12-31, 2016-01-01)) AND (col3 NOT IN (2017-12-31, 2016-01-01)) AND (col4 NOT IN (2017-12-31, 2016-01-01)) AND (col5 NOT IN (2017-12-31, 2016-01-01))\n+ // test not in: (col1 NOT IN (2016-01-01, 2017-12-31)) AND (col2 NOT IN (2016-01-01, 2017-12-31)) AND (col3 NOT IN (2016-01-01, 2017-12-31)) AND (col4 NOT IN (2016-01-01, 2017-12-31)) AND (col5 NOT IN (2016-01-01, 2017-12-31))\n let predicate = Reference::new(\"col1\")\n .is_not_in(\n vec![\n Datum::date_from_str(\"2017-12-31\").unwrap(),\n Datum::date_from_str(\"2016-01-01\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_not_in(\n vec![\n Datum::timestamp_micros(1514764799000000),\n Datum::timestamp_micros(1451606400000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col3\").is_not_in(\n vec![\n Datum::timestamptz_micros(1514764799000000),\n Datum::timestamptz_micros(1451606400000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col4\").is_not_in(\n vec![\n Datum::timestamp_nanos(1514764799000000000),\n Datum::timestamp_nanos(1451606400000000000),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::timestamptz_nanos(1514764799000000000),\n Datum::timestamptz_nanos(1451606400000000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"((((pcol1 NOT IN (47, 46)) AND (pcol2 NOT IN (47, 46))) AND (pcol3 NOT IN (47, 46))) AND (pcol4 NOT IN (47, 46))) AND (pcol5 NOT IN (47, 46))\".to_string());\n+ assert_eq!(result.to_string(), \"((((pcol1 NOT IN (46, 47)) AND (pcol2 NOT IN (46, 47))) AND (pcol3 NOT IN (46, 47))) AND (pcol4 NOT IN (46, 47))) AND (pcol5 NOT IN (46, 47))\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(\n vec![\n Datum::date_from_str(\"2017-12-31\").unwrap(),\n Datum::date_from_str(\"2017-01-01\").unwrap(),\n ]\n .into_iter(),\n )\n .and(\n Reference::new(\"col2\").is_in(\n vec![\n Datum::timestamp_micros(1514764799000000),\n Datum::timestamp_micros(1483228800000000),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"FALSE\".to_string());\n }\n \n@@ -2571,51 +2571,51 @@ mod tests {\n .and(\n Reference::new(\"col5\").is_not_in(\n vec![\n Datum::binary(\"abcdefg\".as_bytes().to_vec()),\n Datum::binary(\"abcdehij\".as_bytes().to_vec()),\n ]\n .into_iter(),\n ),\n )\n .and(\n Reference::new(\"col6\").is_not_in(\n vec![\n Datum::uuid(\n Uuid::parse_str(\"00000000-0000-007b-0000-0000000001c8\").unwrap(),\n ),\n Datum::uuid(\n Uuid::parse_str(\"00000000-0000-01c8-0000-00000000007b\").unwrap(),\n ),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"(((((pcol1 NOT IN (8, 7, 6)) AND (pcol2 NOT IN (8, 7, 6))) AND (pcol3 NOT IN (6, 2))) AND (pcol4 NOT IN (9, 4))) AND (pcol5 NOT IN (4, 6))) AND (pcol6 NOT IN (4, 6))\".to_string());\n+ assert_eq!(result.to_string(), \"(((((pcol1 NOT IN (6, 7, 8)) AND (pcol2 NOT IN (6, 7, 8))) AND (pcol3 NOT IN (2, 6))) AND (pcol4 NOT IN (4, 9))) AND (pcol5 NOT IN (4, 6))) AND (pcol6 NOT IN (4, 6))\".to_string());\n }\n \n #[tokio::test]\n async fn test_strict_projection_identity() {\n let schema = Arc::new(\n Schema::builder()\n .with_fields(vec![Arc::new(NestedField::optional(\n 1,\n \"col1\",\n Type::Primitive(PrimitiveType::Long),\n ))])\n .build()\n .unwrap(),\n );\n \n let partition_spec = Arc::new(\n PartitionSpec::builder(schema.clone())\n .with_spec_id(1)\n .add_partition_field(\"col1\", \"pcol1\", Transform::Identity)\n .unwrap()\n .build()\n .unwrap(),\n );\n \n let mut strict_projection = StrictProjection::new(partition_spec.clone());\n@@ -2668,59 +2668,59 @@ mod tests {\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"pcol1 >= 100\".to_string());\n \n // test eq\n let predicate = Reference::new(\"col1\")\n .equal_to(Datum::long(100))\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"pcol1 = 100\".to_string());\n \n // test not eq\n let predicate = Reference::new(\"col1\")\n .not_equal_to(Datum::long(100))\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(result.to_string(), \"pcol1 != 100\".to_string());\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(vec![Datum::long(100), Datum::long(101)].into_iter())\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"pcol1 IN (101, 100)\".to_string());\n+ assert_eq!(result.to_string(), \"pcol1 IN (100, 101)\".to_string());\n \n // test not in\n let predicate = Reference::new(\"col1\")\n .is_not_in(vec![Datum::long(100), Datum::long(101)].into_iter())\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n- assert_eq!(result.to_string(), \"pcol1 NOT IN (101, 100)\".to_string());\n+ assert_eq!(result.to_string(), \"pcol1 NOT IN (100, 101)\".to_string());\n }\n \n #[tokio::test]\n async fn test_strict_projection_truncate_lower_bound() {\n // int, long, decimal\n let schema = Arc::new(\n Schema::builder()\n .with_fields(vec![\n Arc::new(NestedField::required(\n 1,\n \"col1\",\n Type::Primitive(PrimitiveType::Int),\n )),\n Arc::new(NestedField::required(\n 2,\n \"col2\",\n Type::Primitive(PrimitiveType::Long),\n )),\n Arc::new(NestedField::required(\n 3,\n \"col3\",\n Type::Primitive(PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n }),\n@@ -2858,51 +2858,51 @@ mod tests {\n PrimitiveLiteral::Int128(9900),\n ),\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n PrimitiveLiteral::Int128(10000),\n ),\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n PrimitiveLiteral::Int128(10100),\n ),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(\n result.to_string(),\n- \"((pcol1 NOT IN (100, 90)) AND (pcol2 NOT IN (100, 90))) AND (pcol3 NOT IN (10000, 10100, 9900))\"\n+ \"((pcol1 NOT IN (90, 100)) AND (pcol2 NOT IN (90, 100))) AND (pcol3 NOT IN (9900, 10000, 10100))\"\n .to_string()\n );\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(vec![Datum::int(99), Datum::int(100), Datum::int(101)].into_iter())\n .and(\n Reference::new(\"col2\")\n .is_in(vec![Datum::long(99), Datum::long(100), Datum::long(101)].into_iter()),\n )\n .and(\n Reference::new(\"col3\").is_in(\n vec![\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n PrimitiveLiteral::Int128(9900),\n ),\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n@@ -3081,51 +3081,51 @@ mod tests {\n PrimitiveLiteral::Int128(9999),\n ),\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n PrimitiveLiteral::Int128(9899),\n ),\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n PrimitiveLiteral::Int128(10099),\n ),\n ]\n .into_iter(),\n ),\n )\n .bind(schema.clone(), false)\n .unwrap();\n let result = strict_projection.strict_project(&predicate).unwrap();\n assert_eq!(\n result.to_string(),\n- \"((pcol1 NOT IN (100, 90)) AND (pcol2 NOT IN (100, 90))) AND (pcol3 NOT IN (9890, 9990, 10090))\"\n+ \"((pcol1 NOT IN (90, 100)) AND (pcol2 NOT IN (90, 100))) AND (pcol3 NOT IN (9890, 9990, 10090))\"\n .to_string()\n );\n \n // test in\n let predicate = Reference::new(\"col1\")\n .is_in(vec![Datum::int(99), Datum::int(100), Datum::int(98)].into_iter())\n .and(\n Reference::new(\"col2\")\n .is_in(vec![Datum::long(99), Datum::long(100), Datum::long(98)].into_iter()),\n )\n .and(\n Reference::new(\"col3\").is_in(\n vec![\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\n PrimitiveLiteral::Int128(9999),\n ),\n Datum::new(\n PrimitiveType::Decimal {\n precision: 9,\n scale: 2,\n },\ndiff --git a/crates/iceberg/src/transform/bucket.rs b/crates/iceberg/src/transform/bucket.rs\nindex 52fb72f1cf838921ceb14565774414921ef3ac1c..befdb019f361806263cab178408e665cde5c0438 100644\n--- a/crates/iceberg/src/transform/bucket.rs\n+++ b/crates/iceberg/src/transform/bucket.rs\n@@ -497,51 +497,51 @@ mod test {\n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::string(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::string(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThan, Datum::string(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::string(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::string(value),\n Datum::string(another),\n ]),\n- Some(\"name IN (9, 4)\"),\n+ Some(\"name IN (4, 9)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::string(value),\n Datum::string(another),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_bucket_decimal() -> Result<()> {\n let prev = \"99.00\";\n let curr = \"100.00\";\n let next = \"101.00\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Bucket(10),\n \"name\",\n NestedField::required(\n 1,\n \"value\",\n@@ -634,51 +634,51 @@ mod test {\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::long(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::long(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThan, Datum::long(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::long(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::long(value - 1),\n Datum::long(value),\n Datum::long(value + 1),\n ]),\n- Some(\"name IN (8, 7, 6)\"),\n+ Some(\"name IN (6, 7, 8)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::long(value),\n Datum::long(value + 1),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_bucket_integer() -> Result<()> {\n let value = 100;\n \n let fixture = TestProjectionFixture::new(\n Transform::Bucket(10),\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Int)),\n );\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::int(value)),\n@@ -694,51 +694,51 @@ mod test {\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::int(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::int(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThan, Datum::int(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::int(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::int(value - 1),\n Datum::int(value),\n Datum::int(value + 1),\n ]),\n- Some(\"name IN (8, 7, 6)\"),\n+ Some(\"name IN (6, 7, 8)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::int(value),\n Datum::int(value + 1),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_hash() {\n // test int\n assert_eq!(Bucket::hash_int(34), 2017239379);\n // test long\n assert_eq!(Bucket::hash_long(34), 2017239379);\n // test decimal\n assert_eq!(Bucket::hash_decimal(1420), -500754589);\n // test date\n let date = NaiveDate::from_ymd_opt(2017, 11, 16).unwrap();\n assert_eq!(\n Bucket::hash_date(\ndiff --git a/crates/iceberg/src/transform/temporal.rs b/crates/iceberg/src/transform/temporal.rs\nindex 1cd4d6a4369f645b2963c979d0b8841b36767f0b..890e011ab1be99bb1d81635d6b63bbf0cbf36838 100644\n--- a/crates/iceberg/src/transform/temporal.rs\n+++ b/crates/iceberg/src/transform/temporal.rs\n@@ -639,51 +639,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 420034\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name = 420034\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (420034, 412007)\"),\n+ Some(\"name IN (412007, 420034)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_hour_lower_bound() -> Result<()> {\n // 420034\n let value = \"2017-12-01T10:00:00.000000\";\n // 411288\n let another = \"2016-12-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Hour,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n@@ -785,51 +785,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name = 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (47, 46)\"),\n+ Some(\"name IN (46, 47)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_year_lower_bound() -> Result<()> {\n let value = \"2017-01-01T00:00:00.000000\";\n let another = \"2016-12-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Year,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n \n fixture.assert_projection(\n@@ -857,51 +857,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name = 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (47, 46)\"),\n+ Some(\"name IN (46, 47)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_month_negative_upper_bound() -> Result<()> {\n let value = \"1969-12-31T23:59:59.999999\";\n let another = \"1970-01-01T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n \n fixture.assert_projection(\n@@ -929,51 +929,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= -1\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name IN (-1, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (0, -1)\"),\n+ Some(\"name IN (-1, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_month_upper_bound() -> Result<()> {\n let value = \"2017-12-01T23:59:59.999999\";\n let another = \"2017-11-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n \n fixture.assert_projection(\n@@ -1001,51 +1001,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 575\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name = 575\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (575, 574)\"),\n+ Some(\"name IN (574, 575)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_month_negative_lower_bound() -> Result<()> {\n let value = \"1969-01-01T00:00:00.000000\";\n let another = \"1969-03-01T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n@@ -1072,51 +1072,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= -12\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name IN (-12, -11)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (-10, -9, -12, -11)\"),\n+ Some(\"name IN (-12, -11, -10, -9)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_month_lower_bound() -> Result<()> {\n let value = \"2017-12-01T00:00:00.000000\";\n let another = \"2017-12-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n \n fixture.assert_projection(\n@@ -1218,51 +1218,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 1969-12-31\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name IN (1969-12-31, 1970-01-01)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (1970-01-01, 1969-12-31)\"),\n+ Some(\"name IN (1969-12-31, 1970-01-01)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_day_upper_bound() -> Result<()> {\n // 17501\n let value = \"2017-12-01T23:59:59.999999\";\n // 17502\n let another = \"2017-12-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Day,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n@@ -1292,51 +1292,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 2017-12-01\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name = 2017-12-01\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (2017-12-02, 2017-12-01)\"),\n+ Some(\"name IN (2017-12-01, 2017-12-02)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_day_negative_lower_bound() -> Result<()> {\n // -365\n let value = \"1969-01-01T00:00:00.000000\";\n // -364\n let another = \"1969-01-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Day,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n@@ -1366,51 +1366,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 1969-01-01\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name IN (1969-01-01, 1969-01-02)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (1969-01-02, 1969-01-01, 1969-01-03)\"),\n+ Some(\"name IN (1969-01-01, 1969-01-02, 1969-01-03)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_day_lower_bound() -> Result<()> {\n // 17501\n let value = \"2017-12-01T00:00:00.000000\";\n // 17502\n let another = \"2017-12-02T00:00:00.000000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Day,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n@@ -1440,51 +1440,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::timestamp_from_str(value)?,\n ),\n Some(\"name >= 2017-12-01\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::timestamp_from_str(value)?),\n Some(\"name = 2017-12-01\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::timestamp_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n- Some(\"name IN (2017-12-02, 2017-12-01)\"),\n+ Some(\"name IN (2017-12-01, 2017-12-02)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::timestamp_from_str(value)?,\n Datum::timestamp_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_timestamp_day_epoch() -> Result<()> {\n // 0\n let value = \"1970-01-01T00:00:00.00000\";\n // 1\n let another = \"1970-01-02T00:00:00.00000\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Day,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Timestamp)),\n );\n@@ -1718,51 +1718,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= -1\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name IN (-1, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (-1, -12, -11, 0)\"),\n+ Some(\"name IN (-12, -11, -1, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_month_upper_bound() -> Result<()> {\n // 575 => 2017-12\n let value = \"2017-12-31\";\n // 564 => 2017-01\n let another = \"2017-01-01\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -1786,51 +1786,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= 575\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name = 575\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (575, 564)\"),\n+ Some(\"name IN (564, 575)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_month_negative_lower_bound() -> Result<()> {\n // -12 => 1969-01\n let value = \"1969-01-01\";\n // -1 => 1969-12\n let another = \"1969-12-31\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -1854,51 +1854,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= -12\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name IN (-12, -11)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (-1, -12, -11, 0)\"),\n+ Some(\"name IN (-12, -11, -1, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_month_lower_bound() -> Result<()> {\n // 575 => 2017-12\n let value = \"2017-12-01\";\n // 564 => 2017-01\n let another = \"2017-01-01\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -1922,51 +1922,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= 575\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name = 575\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (575, 564)\"),\n+ Some(\"name IN (564, 575)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_month_epoch() -> Result<()> {\n // 0 => 1970-01\n let value = \"1970-01-01\";\n // -1 => 1969-12\n let another = \"1969-12-31\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Month,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -1990,51 +1990,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= 0\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name = 0\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (0, -1)\"),\n+ Some(\"name IN (-1, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_year_negative_upper_bound() -> Result<()> {\n // -1 => 1969\n let value = \"1969-12-31\";\n let another = \"1969-01-01\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Year,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n \n@@ -2057,51 +2057,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= -1\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name IN (-1, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (0, -1)\"),\n+ Some(\"name IN (-1, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_year_upper_bound() -> Result<()> {\n // 47 => 2017\n let value = \"2017-12-31\";\n // 46 => 2016\n let another = \"2016-01-01\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Year,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -2125,51 +2125,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name = 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (47, 46)\"),\n+ Some(\"name IN (46, 47)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_year_negative_lower_bound() -> Result<()> {\n // 0 => 1970\n let value = \"1970-01-01\";\n // -1 => 1969\n let another = \"1969-12-31\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Year,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -2193,51 +2193,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= 0\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name = 0\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (0, -1)\"),\n+ Some(\"name IN (-1, 0)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_date_year_lower_bound() -> Result<()> {\n // 47 => 2017\n let value = \"2017-01-01\";\n // 46 => 2016\n let another = \"2016-12-31\";\n \n let fixture = TestProjectionFixture::new(\n Transform::Year,\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Date)),\n );\n@@ -2261,51 +2261,51 @@ mod test {\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::date_from_str(value)?,\n ),\n Some(\"name >= 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::date_from_str(value)?),\n Some(\"name = 47\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::date_from_str(value)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n- Some(\"name IN (47, 46)\"),\n+ Some(\"name IN (46, 47)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::date_from_str(value)?,\n Datum::date_from_str(another)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_transform_years() {\n let year = super::Year;\n \n // Test Date32\n let ori_date = vec![\n NaiveDate::from_ymd_opt(1970, 1, 1).unwrap(),\n NaiveDate::from_ymd_opt(2000, 1, 1).unwrap(),\n NaiveDate::from_ymd_opt(2030, 1, 1).unwrap(),\n NaiveDate::from_ymd_opt(2060, 1, 1).unwrap(),\n NaiveDate::from_ymd_opt(1969, 1, 1).unwrap(),\n ];\ndiff --git a/crates/iceberg/src/transform/truncate.rs b/crates/iceberg/src/transform/truncate.rs\nindex 4fac48f7d593cb21aeee7e559c4098f5d17e88ee..cf7e3485e607d2e912ca92d9f6a704b5162e12fe 100644\n--- a/crates/iceberg/src/transform/truncate.rs\n+++ b/crates/iceberg/src/transform/truncate.rs\n@@ -447,51 +447,51 @@ mod test {\n \n fixture.assert_projection(\n &fixture.binary_predicate(\n PredicateOperator::GreaterThanOrEq,\n Datum::decimal_from_str(curr)?,\n ),\n Some(\"name >= 10000\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::decimal_from_str(curr)?),\n Some(\"name = 10000\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::decimal_from_str(curr)?),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::decimal_from_str(prev)?,\n Datum::decimal_from_str(curr)?,\n Datum::decimal_from_str(next)?,\n ]),\n- Some(\"name IN (10000, 10100, 9900)\"),\n+ Some(\"name IN (9900, 10000, 10100)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::decimal_from_str(curr)?,\n Datum::decimal_from_str(next)?,\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_truncate_upper_bound_long() -> Result<()> {\n let value = 99i64;\n \n let fixture = TestProjectionFixture::new(\n Transform::Truncate(10),\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Long)),\n );\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::long(value)),\n@@ -502,51 +502,51 @@ mod test {\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::long(value)),\n Some(\"name <= 90\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::long(value)),\n Some(\"name >= 90\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::long(value)),\n Some(\"name = 90\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::long(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::long(value - 1),\n Datum::long(value),\n Datum::long(value + 1),\n ]),\n- Some(\"name IN (100, 90)\"),\n+ Some(\"name IN (90, 100)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::long(value),\n Datum::long(value + 1),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_truncate_lower_bound_long() -> Result<()> {\n let value = 100i64;\n \n let fixture = TestProjectionFixture::new(\n Transform::Truncate(10),\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Long)),\n );\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::long(value)),\n@@ -557,51 +557,51 @@ mod test {\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::long(value)),\n Some(\"name <= 100\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::long(value)),\n Some(\"name >= 100\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::long(value)),\n Some(\"name = 100\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::long(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::long(value - 1),\n Datum::long(value),\n Datum::long(value + 1),\n ]),\n- Some(\"name IN (100, 90)\"),\n+ Some(\"name IN (90, 100)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::long(value),\n Datum::long(value + 1),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_truncate_upper_bound_integer() -> Result<()> {\n let value = 99;\n \n let fixture = TestProjectionFixture::new(\n Transform::Truncate(10),\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Int)),\n );\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::int(value)),\n@@ -612,51 +612,51 @@ mod test {\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::int(value)),\n Some(\"name <= 90\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::int(value)),\n Some(\"name >= 90\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::int(value)),\n Some(\"name = 90\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::int(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::int(value - 1),\n Datum::int(value),\n Datum::int(value + 1),\n ]),\n- Some(\"name IN (100, 90)\"),\n+ Some(\"name IN (90, 100)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::int(value),\n Datum::int(value + 1),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n #[test]\n fn test_projection_truncate_lower_bound_integer() -> Result<()> {\n let value = 100;\n \n let fixture = TestProjectionFixture::new(\n Transform::Truncate(10),\n \"name\",\n NestedField::required(1, \"value\", Type::Primitive(PrimitiveType::Int)),\n );\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::LessThan, Datum::int(value)),\n@@ -667,51 +667,51 @@ mod test {\n &fixture.binary_predicate(PredicateOperator::LessThanOrEq, Datum::int(value)),\n Some(\"name <= 100\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::GreaterThanOrEq, Datum::int(value)),\n Some(\"name >= 100\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::Eq, Datum::int(value)),\n Some(\"name = 100\"),\n )?;\n \n fixture.assert_projection(\n &fixture.binary_predicate(PredicateOperator::NotEq, Datum::int(value)),\n None,\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::In, vec![\n Datum::int(value - 1),\n Datum::int(value),\n Datum::int(value + 1),\n ]),\n- Some(\"name IN (100, 90)\"),\n+ Some(\"name IN (90, 100)\"),\n )?;\n \n fixture.assert_projection(\n &fixture.set_predicate(PredicateOperator::NotIn, vec![\n Datum::int(value),\n Datum::int(value + 1),\n ]),\n None,\n )?;\n \n Ok(())\n }\n \n // Test case ref from: https://iceberg.apache.org/spec/#truncate-transform-details\n #[test]\n fn test_truncate_simple() {\n // test truncate int\n let input = Arc::new(Int32Array::from(vec![1, -1]));\n let res = super::Truncate::new(10).transform(input).unwrap();\n assert_eq!(\n res.as_any().downcast_ref::().unwrap().value(0),\n 0\n );\n assert_eq!(\n res.as_any().downcast_ref::().unwrap().value(1),\n",{"_403":6139,"_405":-5},5,51,44,[],"file_00000000c54071f78ae47038e332d32e",[],[6142],{"_295":49,"_49":6143},"**Summary**\n* Stabilized `SetExpression` formatting by sorting set literals before joining them for `IN` / `NOT IN` display output, avoiding nondeterministic `FnvHashSet` iteration order in tests and diagnostics. \n* Updated predicate binding expectations to assert the new deterministic set literal order. \n* Updated strict projection expectations for deterministic `IN` / `NOT IN` output across temporal, bucket, and truncate projections. \n* Updated transform projection test expectations to match deterministic set ordering for bucket, temporal, and truncate projections. \n\nCommitted the changes as `32be246` and created a follow-up PR titled `fix(tests): stabilize set predicate formatting`.\n\n**Testing**\n* ✅ `cargo test -p iceberg --lib test_unknown_type -- --nocapture`\n* ✅ `cargo fmt --check`\n* ✅ `cargo test -p iceberg --lib`\n* ✅ `git diff --check`",{"_112":284,"_45":88,"_116":284,"_285":6146,"_287":6147,"_288":289,"_150":-5,"_138":6148},[90],[6168,6169,6170,6171,6172],{"_6149":6150,"_231":163,"_6151":420,"_242":-5,"_388":224,"_6152":18,"_6153":-5,"_6154":-5,"_6155":6156,"_6157":6158,"_6159":-5,"_6160":-5,"_6161":6162,"_6163":18,"_6164":62,"_6165":57,"_6166":18,"_6167":-5},1778137147.220827,"installation_id",116688194,"pr_number","enable_internal_github_app_routing","gitlab_service_account_project_id","review_trigger","comment_id",4394177383,"comment_type","issue","pr_write_guard_token","pending_pr_reaction_id","pending_comment_reaction_id",354469930,"comment_if_no_findings","comment_on_error","share_url","is_parallel_review","review_summary_id",{"_112":280,"_116":284,"_292":6182},{"_352":6118,"_354":6119,"_6179":6120,"_6180":309,"_362":-5,"_112":6181},{"_112":6173,"_354":6178,"_412":-5,"_6175":-5,"_6176":-5},{"_112":6173,"_354":6177,"_412":-5,"_6175":-5,"_6176":-5},{"_112":6173,"_354":6174,"_412":-5,"_6175":-5,"_6176":-5},"pull_request_comment","**Summary**\n* Switched `NestedField` deserialization from lossy `From` conversion to fallible `TryFrom`, preserving `Literal::try_from_json` errors for `initial-default` and `write-default` instead of converting invalid defaults to `None`. \n* Added regression tests that reject a non-null JSON default on an `unknown` field and accept explicit `null` defaults. \n\n**Testing**\n* ✅ `cargo fmt --check`\n* ✅ `cargo test -p iceberg --lib test_unknown_type`\n\nCommitted the changes with commit `038908d` and created a PR titled `fix(spec): reject invalid nested field defaults`.\n\n [View task →](https://chatgpt.com/s/cd_69fc100ebc7c81918915938e4517d84a)","side","line","@codex fix test failure","\n### 💡 Codex Review\n\nhttps://github.com/manuzhang/iceberg-rust/blob/d56cd19186e5ebcb0739b28ddbad4b83bc257bc5/crates/iceberg/src/spec/schema/mod.rs#L199-L200\n**_{_{![P2 Badge](https://img.shields.io/badge/P2-yellow?style=flat)}} Reject non-null defaults during unknown-field deserialization**\n\nWhen table metadata JSON contains an `unknown` field with `initial-default` or `write-default` set to a non-null value, this check still lets it through: `SerdeNestedField::from` parses defaults with `Literal::try_from_json(...).ok().and_then(identity)`, so the parse error for an unknown/non-null default is converted to `None` before `SchemaBuilder::build` reaches this validation. That means invalid metadata is silently accepted despite the new rule; the validation needs to inspect/preserve the raw non-null default during deserialization or make default parsing errors fail the schema build.\n \n\n

ℹ️ About Codex in GitHub
\n
\n\n[Your team has set up Codex to review pull requests in this repo](https://chatgpt.com/codex/cloud/settings/general). Reviews are triggered when you\n- Open a pull request for review\n- Mark a draft as ready\n- Comment \"@codex review\".\n\nIf Codex has suggestions, it will comment; otherwise it will react with 👍.\n\n\n\n\nCodex can also answer questions or update the PR. Try commenting \"@codex address that feedback\".\n \n
","base_ref","head_ref","pull_request_info",[6183],{"_295":49,"_49":6184},"@codex check review comments and fix test failure",[6215,6216,6217,6218],[],{"_276":6214},{"_273":6213},{"_273":6212},{"_344":345,"_264":346,"_347":348,"_349":18,"_350":18,"_351":18,"_352":353,"_354":355,"_356":146,"_357":310,"_358":359,"_360":361,"_362":-5,"_363":-5,"_364":-5,"_284":6211,"_366":345,"_367":368,"_369":370,"_371":372},{"_45":142,"_160":161,"_162":163,"_164":18,"_165":166,"_167":168,"_169":6200,"_171":-5,"_172":173,"_174":18,"_175":6201,"_177":166,"_178":166,"_179":6202,"_181":6203,"_183":6204,"_185":-5,"_186":336,"_188":189,"_190":191,"_192":6205,"_58":-5,"_138":194,"_195":6206,"_197":6207,"_199":340,"_201":18,"_202":18},{"_151":6193},[6194,6195,6196],{"_316":6199,"_318":328},{"_316":6198,"_318":324},{"_316":6197,"_318":319},{"_227":320,"_112":321,"_138":322},{"_227":325,"_112":321,"_138":326},{"_227":329,"_112":321,"_138":330},{"_266":267,"_268":-5,"_269":-5,"_270":-5,"_271":-5,"_272":-5},[224],{"_224":6208},{"_206":207,"_208":209,"_210":211,"_212":213,"_214":215,"_216":217,"_218":219,"_220":221,"_222":223},{},[],{"_205":62},{"_203":62,"_204":166},{"_45":226,"_227":228,"_229":6209,"_231":163,"_232":233,"_234":235,"_236":237,"_238":239,"_240":241,"_242":67,"_243":18,"_244":18,"_245":62,"_246":62,"_247":62,"_248":18,"_249":-5,"_250":251,"_252":-5,"_58":6210},{"_258":259,"_45":260,"_112":261,"_262":263,"_264":265},{"_254":62,"_255":18,"_256":62,"_257":62},{"_258":259,"_227":259,"_373":-5,"_262":263,"_45":260},[],[],[],{"_112":4408,"_385":6248},{"_112":280,"_116":113,"_292":6235},{"_112":406,"_407":6222},{"_112":381,"_382":353,"_383":384,"_385":6219,"_387":-5},{"_112":385,"_388":163,"_147":309,"_389":-5,"_364":390,"_391":6220,"_393":394,"_395":396,"_397":398,"_399":400,"_401":6221},{"_403":404,"_405":-5},[],[6223,6224,6225],{"_412":3697,"_414":-5,"_415":6232,"_417":-5},{"_412":2039,"_414":-5,"_415":6229,"_417":-5},{"_412":413,"_414":-5,"_415":6226,"_417":-5},[6227],{"_419":420,"_421":422,"_292":6228,"_424":62},[425,426,427,428,429,430,431,432,433,432,434,435,436,437,438,439,166,440,441,166,442,166,443,444,445,446,447,448,449,450,451,452,166,453,166,454,455,456,457,458,459,460,455,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,166,476,477,478,479,480,481,482,483,484,475,166,485,486,487,166,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,166,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,166,545,546,547,548,549,550,551,166,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,541,542,538,570,551,166,571,572,573,574,575,576,577,578,579,580,581,166,582,583,584,585,586,587,588,589,590,591,166,592,576,577,593,575,580,579,594,551,166,595,596,597,598,599,570,166,600,551,166,601,489,602,603,604,605,606,584,607,608,609,610,611,570,166,612,613,614,615,616,617,618,619,620,616,621,618,622,623,619,620,616,624,570,166,625,551,166,626,489,627,628,629,489,602,630,631,632,633,634,635,636,637,166,638,606,584,607,639,640,610,611,570,166,641,642,570,166,643,644,645,591,166,625,551,166,646,647,489,602,648,649,650,651,166,652,633,653,635,636,637,166,638,606,584,607,654,640,610,611,570,166,655,656,570,166,657,658,659,660,570,166,625,551,166,661,662,663,664,665,666,660,667,570,166,600,551,166,668,489,602,669,670,671,672,673,674,675,676,677,678,679,606,584,680,611,570,166,681,682,683,679,606,584,607,684,685,686,610,611,570,166,687,688,689,690,691,692,693,694,695,696,697,698,624,570,166,699,700,701,702,703,606,584,607,704,705,706,610,611,570,166,707,708,709,710,711,712,713,714,715,716,717,616,166,718,719,691,692,693,720,697,698,624,570,166,721,722,723,724,725,726,727,712,728,729,730,570,166,731,732,733,591,166,734,735,736,677,737,166,625,551,166,738,739,489,602,740,741,742,166,743,744,691,692,745,698,624,166,746,747,748,749,750,751,752,753,754,755,624,544,166,756,551,166,757,758,759,760,761,166,762,763,764,765,719,766,624,591,166,767,768,769,660,570,166,770,736,771,772,166,600,551,166,773,489,602,774,775,675,676,771,776,777,679,642,570,166,778,606,584,607,779,780,610,611,544,166,781,782,783,591,784,785,570,166,786,787,788,789,790,719,791,792,790,793,166,794,750,795,660,570,166,796,797,798,591,799,166,625,551,166,800,489,801,802,787,803,570,166,804,805,806,660,570,166,600,551,166,807,808,736,809,810,811,812,591,600,551,166,813,814,815,816,817,818,570,600,551,166,819,820,821,822,561,823,824,825,826,827,828,591,600,551,166,829,830,831,816,817,832,570,600,551,166,833,489,834,489,835,836,837,838,839,840,166,841,842,166,843,844,845,846,847,848,624,166,642,570,166,849,850,851,852,166,853,854,855,856,544,166,736,857,858,166,859,166,860,166,625,551,166,861,489,862,489,863,864,865,866,867,868,869,692,870,871,872,544,873,166,874,642,570,166,875,583,584,876,586,587,166,877,878,879,880,166,881,166,882,883,884,660,748,817,885,570,166,625,551,166,886,887,888,889,551,166,890,489,891,892,893,489,602,894,895,896,897,570,166,898,899,900,166,901,691,692,693,902,903,697,698,624,570,166,904,551,166,905,906,606,584,607,907,908,610,611,570,166,904,551,166,909,489,910,911,912,489,602,913,914,915,896,897,570,166,916,917,918,723,919,166,920,921,922,624,166,923,924,925,926,927,166,928,711,712,713,929,930,716,717,616,166,931,711,712,713,932,933,934,716,717,616,624,570,166,904,551,166,935,489,936,937,489,938,489,602,939,940,941,942,166,943,944,166,945,946,166,947,948,949,166,950,951,952,953,166,954,955,956,957,958,624,166,642,570,166,959,606,584,960,611,570,166,961,962,963,736,964,965,966,967,166,968,969,970,166,625,551,166,971,489,972,973,974,975,976,977,978,979,676,964,980,981,982,983,166,984,985,986,987,988,989,990,991,992,993,616,994,995,983,166,996,997,998,999,551,166,1000,489,602,1001,1002,1003,1004,1005,869,692,1006,871,872,570,166,1007,642,570,166,1008,606,584,1009,611,570,166,1010,676,964,1011,1012,869,692,693,1013,697,871,1014,1015,1016,1017,1018,1019,166,1020,1021,1022,660,748,1023,570,166,625,551,166,1024,1025,1026,1027,551,166,1028,1029,1030,489,602,1031,1032,1033,606,584,1034,611,570,166,1035,1036,1037,1038,624,591,166,1039,1040,1041,660,570,166,625,551,166,1042,489,1043,937,489,1044,489,602,1045,1046,1047,1048,1049,166,1050,1051,1052,1053,847,1054,624,166,642,570,166,1055,1056,1057,1058,1059,1060,869,692,1061,871,1062,872,166,1063,736,1064,1065,1066,166,625,551,166,1067,489,602,1068,1069,1070,1071,1072,869,692,1073,871,872,570,166,1074,642,570,166,1075,606,584,607,1076,610,611,570,166,1077,166,1078,1079,1080,660,748,817,1081,570,166,625,551,166,1082,1083,1084,1085,551,166,1086,1087,1088,1089,1090,1091,570,166,1092,1093,1094,591,600,551,166,1095,1096,1097,1098,1099,660,570,600,551,166,1100,1101,1102,700,1103,166,1104,1105,1106,942,1107,166,1108,1109,1110,1111,826,1112,1113,1114,1058,1115,166,1116,1117,166,1118,1119,570,1120,166,1121,1122,1123,1124,999,551,166,1125,1126,676,1127,1128,1129,1130,1131,166,1132,1133,1134,1135,1136,748,1137,570,551,166,1138,1139,1140,1141,653,1142,166,1143,897,570,166,1144,1145,1146,1147,1148,1149,616,1150,1151,1152,1153,1154,1155,1156,624,570,166,1157,1158,1159,691,692,1160,698,624,544,166,1161,904,551,166,1162,489,1163,1164,1165,1166,1167,1168,1169,1170,1171,1141,653,1172,1173,1174,995,1175,166,966,653,1172,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,616,1174,995,1192,551,166,1193,493,1194,495,1195,1196,1197,1198,1199,1200,1201,949,166,1202,1203,1204,1205,869,692,693,1206,1207,697,871,872,1208,1209,570,1210,166,1211,1212,1213,1205,869,692,693,1214,1215,697,871,872,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,570,1228,166,1229,551,166,1230,736,857,653,1231,1232,551,166,1233,1234,676,857,634,1235,1236,551,166,1237,736,857,1238,1012,869,692,693,1239,1240,697,871,995,551,166,1241,736,1064,1242,1243,1012,869,692,693,1244,1245,697,871,995,551,166,1246,1247,736,964,653,1248,1249,1250,1251,1252,995,551,166,1253,1254,551,166,1255,1256,1257,1258,570,166,736,1064,653,1259,1260,995,1249,1261,1262,1263,995,551,166,1264,1265,551,166,1266,1267,1268,1269,606,584,1270,611,570,166,1271,642,570,166,1272,1273,1274,1275,765,719,766,624,591,166,1276,1277,591,166,625,551,475,166,1278,1279,1280,551,475,166,1281,1282,1283,1284,1285,166,1286,1287,1288,1289,1290,1291,1292,1293,1294,166,1295,1296,166,1297,1298,1299,1300,1301,1302,1303,1304,1305,551,166,1306,1298,1299,1300,1307,1303,1304,1305,551,166,1308,1309,1114,1310,1311,1312,1313,1314,1315,995,1059,1305,551,166,1316,1317,1318,1319,1305,1304,551,166,1320,1321,1322,1323,1324,1325,580,1326,594,1327,1328,1327,1329,1330,1331,1332,551,166,1333,1334,1335,1336,1337,1338,1325,1339,1326,594,1340,1341,1342,1343,1344,1345,826,166,1346,1336,1337,1338,1325,1347,1326,594,1327,1328,1327,1348,1349,551,166,1333,1350,1351,1322,1323,1324,1325,1352,1326,594,1327,1328,1327,1348,166,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,166,1367,1368,166,1369,1370,1371,1372,1373,1374,1305,1304,1305,1375,166,1376,1368,551,166,1333,1377,1378,1351,1379,1380,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1376,1354,1355,1356,1381,1382,1383,1360,1361,1362,1363,1364,1365,551,166,1333,1384,1385,1386,1299,1387,1388,1389,1390,1391,1392,1393,1394,1395,871,1396,1397,1303,1304,1398,1399,1400,1401,1305,1402,1305,1304,1398,1056,1403,1404,1405,1406,1315,1407,1408,1059,1398,166,501,1409,166,1410,1299,1411,1412,1389,1413,1391,1392,1414,1394,1395,871,1396,1415,1303,1304,1398,166,1416,1318,1401,1305,1402,1305,1304,1398,166,1417,1403,1418,1405,1406,1315,1407,1310,1419,1398,166,1420,1421,1422,551,166,1333,1423,1424,166,1351,576,1323,1324,1325,1352,1326,594,1327,1328,1327,1348,166,1355,1425,551,166,1333,1426,1427,1322,1323,1324,1325,1352,1428,594,1327,1328,1327,1429,166,1430,1431,1432,537,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1446,1448,537,1449,1450,1451,537,1452,1453,1454,1455,1456,1457,624,1458,551,166,1333,1459,1378,1427,1379,1460,1338,1325,1352,1326,594,1327,1328,1327,1429,166,1430,1431,1432,537,1461,1462,537,1434,1435,1436,1437,1463,1439,1447,1446,1448,537,1449,1450,1464,537,1452,1458,551,166,1333,1465,1466,166,1467,1468,1469,1470,1471,1472,1473,1474,1475,755,1470,1476,1477,1473,1478,1479,755,1303,1305,1480,166,1481,1482,1305,1304,1398,166,1483,1484,1485,1486,1487,1488,1405,1489,1490,995,1305,1487,1491,1405,1312,1492,995,1305,1304,1398,166,1493,1494,1495,1496,826,1497,1498,1499,1500,591,166,1501,1502,676,1371,1372,1373,1503,1305,1304,1398,166,1493,1504,1505,551,166,1333,1506,1466,1507,1467,1468,1508,1305,1480,166,1481,1482,1305,1509,1305,1304,1398,166,1510,1486,1487,1511,1512,1418,1492,995,1305,1304,1398,166,1513,1514,1515,1435,1516,1517,537,1518,1458,551,166,1333,1519,1466,1520,1521,1481,1522,1305,1509,1305,1304,1398,166,1513,1523,1524,591,1525,1526,591,1494,1527,1528,1529,1530,1446,586,826,166,1531,1502,676,1371,1372,1373,1532,1305,1304,1398,166,1493,1533,1534,591,1494,1527,1528,1535,1530,1446,586,826,551,166,1333,1536,1466,166,1537,1408,1403,1418,1405,1406,1315,1407,1538,1398,166,1481,1539,1305,1304,1398,166,1540,166,1493,1541,1542,1543,1544,826,1545,1546,591,551,166,1333,1547,1466,166,1548,1549,1299,1300,1301,1302,1550,1303,1304,1398,166,1481,1551,1305,1304,1398,166,1513,1552,1542,1553,1554,826,1555,1556,591,1557,1558,591,551,166,1333,1559,1466,166,1548,1549,1299,1300,1301,1302,1550,1303,1304,1398,166,1481,1560,1305,1561,1305,1304,1398,166,1513,1557,1558,591,551,166,1333,1562,1563,1322,1323,1324,1325,1339,1326,594,1327,1328,1564,166,1565,551,166,1333,1566,1567,1568,1304,1305,1375,1569,166,1570,1571,1572,1573,1574,1575,1305,1304,1398,166,1576,551,166,1333,1577,1578,1579,1322,1323,1324,1325,1339,1326,594,1327,1328,1327,1329,1580,166,1581,1582,1398,166,1583,166,1576,1494,1584,1585,826,551,166,1333,1586,1466,166,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,697,1599,1600,1601,1602,995,1480,166,1603,166,1341,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,826,166,1481,1617,1618,751,1619,753,754,755,995,1305,1304,1398,1620,1494,1621,1622,826,1623,1624,1625,1626,551,166,1333,1627,1466,166,1628,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,697,1599,1600,1601,1602,995,1480,166,1629,1630,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,697,1599,1600,1601,1602,995,1480,166,1631,1632,1305,1617,1618,751,1619,753,754,755,995,1305,1633,1305,1304,1398,166,1634,1635,1636,1637,1638,551,166,1333,1639,1466,166,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,697,1599,1600,1601,1602,995,1480,166,1631,1640,1305,1617,1618,751,1619,753,754,755,995,1305,1304,1398,166,1641,1642,1643,1644,166,1645,1646,676,1371,1647,1373,1648,1304,1398,166,1649,1650,1651,1652,1653,1494,1654,1655,1656,624,826,551,166,1333,1657,1466,166,1587,1630,1589,1590,1591,1592,1593,1594,1658,995,1480,166,1481,1659,1305,1304,1398,166,1660,1635,1661,1662,1663,1664,537,544,166,1665,1494,1666,1667,826,1515,1668,1669,1670,1671,624,1458,551,166,1333,1672,1466,166,1587,1630,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,697,1599,1600,1601,1602,995,1480,166,1603,1673,551,166,1333,1674,1466,166,1548,1549,1675,1304,1398,166,1676,1677,1305,1304,1678,166,1341,1679,1680,826,551,166,1333,1681,1682,166,1467,1468,1469,1470,1472,1473,1474,1475,755,1470,1477,1473,1478,1683,755,1303,1305,1480,166,1684,1685,1686,1687,551,166,1333,1688,1466,1689,1572,1690,1691,1575,1305,1304,1398,1692,1693,166,1370,676,1694,1572,1695,1696,1575,1305,1304,1398,166,1697,1693,166,1370,676,1694,1572,1695,1691,1575,1305,1304,1398,1697,1698,551,166,1333,1699,1466,166,1587,1588,1589,1700,1591,1701,1593,1594,1658,995,1480,166,1581,1640,1305,1617,1618,751,1619,753,754,755,995,1398,166,1587,1630,1589,1590,1591,1702,1703,1593,1594,1658,995,1480,166,1676,1704,1678,1341,1679,1705,826,551,166,1333,1706,1466,166,1707,551,166,1333,1708,1466,166,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,525,1720,544,1721,166,1494,1722,1723,826,1724,1725,1637,166,1726,1727,1481,1728,1304,1398,166,1729,1730,1731,1637,166,1732,1727,1481,1728,1304,1398,1729,1733,551,166,1333,1734,1466,166,1735,1710,1736,1737,544,166,1481,1738,1304,1398,1494,1739,1723,826,1515,1740,1741,624,1458,166,1726,1727,1481,1742,1304,1398,1743,1515,1744,1745,624,1458,166,1732,1727,1481,1742,1304,1398,1743,1733,551,166,1333,1746,1466,166,1747,1748,1749,166,1570,1371,1372,1373,1572,1573,1574,1575,1305,1304,1398,166,1341,1750,1751,1752,1753,826,551,166,1333,1754,1755,1756,1757,1758,1759,1332,1564,1760,1761,166,1762,1763,1764,1765,1766,1304,1398,166,1494,1767,1768,826,551,166,1333,1769,1466,1770,551,166,1333,1771,1756,1757,1758,1759,1332,1564,1760,1761,166,1762,1763,1764,1765,1766,1304,1398,166,1772,166,679,1773,1774,1775,570,166,1776,1777,1778,1779,1780,1781,1782,166,1783,1784,1785,719,1786,793,1787,551,166,1333,1788,1789,1299,1790,1303,1304,1398,166,1791,1318,1792,1305,1480,166,1351,1793,1794,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1795,1796,1797,653,1798,983,1799,166,1800,1299,1790,1801,1802,1303,1304,1398,166,1803,1331,1687,166,1804,1805,166,1806,1807,1808,1809,1810,551,166,1333,1811,1789,1299,1790,1303,1304,1398,166,1812,1318,1813,1305,1480,166,1351,1793,577,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1814,1299,1790,1815,1303,1304,1398,166,1816,1817,1818,1819,1820,1305,1480,166,1821,551,166,1333,1822,1789,1299,1790,1823,1824,1303,1304,1398,166,1812,1318,1825,1305,1480,166,1351,1793,577,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1803,1331,1687,166,1826,1486,1827,1305,1480,166,1828,166,1806,1807,1808,1829,1830,1831,1687,1832,551,166,1333,1833,1834,1789,1299,1790,1823,1824,1303,1304,1398,166,1812,1318,1792,1305,1480,166,1351,1793,577,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1835,1836,1299,1790,1837,1824,1303,1304,1398,166,1370,1819,1838,1305,1304,1305,1375,166,1839,1840,1841,1842,1299,1790,1837,1824,1843,1824,1303,1304,1398,166,1844,1818,1845,166,1846,1847,1821,166,1848,1849,1850,1299,1790,1837,1824,1843,1824,1851,1852,1303,1304,1398,166,1853,1854,166,1855,1856,1857,1858,1859,551,166,1333,1860,1861,1789,1299,1790,1862,1824,1303,1304,1398,166,1812,1318,1863,1305,1480,166,1351,1793,577,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1864,1800,1299,1790,1862,1824,1837,1824,1303,1304,1398,166,1865,1817,1819,1866,166,1821,551,166,1333,1867,1868,1789,1299,1790,1303,1304,1398,166,1812,1318,1792,1305,1480,166,1351,1793,577,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1869,1850,1299,1790,1870,1802,1303,1304,1398,166,1871,1872,166,1855,1856,1806,1807,1859,551,166,1333,1873,1789,1299,1790,1823,1824,1303,1304,1398,166,1812,1318,1825,1305,1480,166,1351,1793,577,1338,1325,1339,1326,594,1327,1328,1327,1348,166,1803,1331,1687,166,1874,1875,1486,1876,1305,1480,166,1877,166,1821,551,166,1333,1878,1879,1880,1304,1305,1375,1881,1882,1883,1590,1591,1884,1885,1593,1594,1658,995,1886,1480,166,1887,1571,1888,1305,1304,1305,1375,166,1889,166,1890,1588,1891,1700,1591,1884,1892,1593,1594,1658,995,1893,1480,166,1894,1571,1895,1305,1304,1305,1375,1896,551,166,1333,1897,1879,1880,1304,1305,1375,166,1898,1881,1882,1883,1590,1591,1884,1885,1593,1594,1658,995,1886,1480,166,1899,1571,1900,1305,1304,1305,1375,166,1901,1588,1902,1700,1591,1884,1892,1593,1594,1658,995,1903,1904,1480,166,1905,1571,1906,1678,1341,1907,1908,586,826,551,166,1333,1909,1910,1911,166,1912,166,1913,1880,1304,1305,1375,166,1914,1915,166,1916,1917,1588,1883,1590,1591,1884,1885,1593,1594,1658,995,1918,1480,166,1919,1571,1920,1305,1304,1305,1375,166,1921,1922,166,1923,1924,1925,677,1926,1398,1927,166,1928,1929,166,1930,1931,1630,1932,1700,1591,1933,1885,1593,1594,1658,995,1934,1480,166,1935,1571,1936,1305,1617,1937,751,752,753,754,755,995,1305,1304,1305,1375,166,1938,1939,1940,166,1941,1942,166,1943,1944,1945,1946,1947,1591,1948,1949,1593,1594,1658,995,1950,1480,166,1951,1571,1952,1305,1304,1305,1375,166,1953,1954,1955,677,1956,1398,1957,166,1958,1959,551,166,1333,1960,1466,166,1961,1962,1963,1964,1965,1966,1967,1968,1575,1480,166,1969,1970,1971,1972,1973,1480,166,1974,1481,1975,1304,1398,166,1493,1976,1494,1977,1978,826,1979,1980,591,166,1981,1502,676,1371,1372,1373,1982,1304,1398,166,1493,1983,1494,1977,1978,826,1494,1984,1985,826,1979,1986,591,166,1987,1502,676,1371,1647,1373,1975,1304,1398,166,1733,1983,166,1988,1502,676,1371,1989,1373,1990,1304,1398,166,1493,1976,1991,1494,1984,1985,826,1992,1993,591,166,1994,1502,676,1371,1995,1373,1996,1304,1398,166,1733,1976,166,1997,1998,676,1999,637,2000,2001,166,2002,1502,676,1371,2003,1373,2004,1304,1398,166,1493,2005,2006,1992,2007,591,166,2008,2009,2010,551,166,1333,2011,1385,1299,2012,2013,2014,1824,1303,1304,1398,166,2015,2016,2017,1305,1480,166,2018,576,2019,1338,2020,1339,1326,594,1327,1328,1327,1348,166,2021,2022,2023,1305,1480,2024,2025,2026,166,2027,2028,2029,2030,1305,2031,1305,2032,1305,1480,2033,2034,166,2035,2036,2037,2038,551,475],[6230],{"_419":420,"_421":2042,"_292":6231,"_424":62},[425,426,427,428,429,430,431,432,433,432,434,435,436,437,438,439,166,2044,2045,166,2046,2047,2048,2049,441,166,2050,2051,2052,2053,442,166,2054,2055,443,2056,2057,2058,449,2059,2060,2061,2062,2063,2064,166,2065,2066,166,2067,2068,2069,2070,2071,166,2072,2073,2074,2075,2076,2077,166,2078,2079,2080,455,2081,2082,2083,2084,2085,2086,2087,2088,2089,2090,2091,2092,2093,2094,2095,2096,2097,2098,2099,2100,2101,2102,2103,2104,2105,2106,2107,2108,2109,2110,2111,2112,2113,2114,2115,2116,2117,2118,2119,2120,2121,2122,2123,2124,2125,2126,166,2127,2128,2129,2130,2131,2132,2133,166,2134,2135,2136,2137,2138,2139,2140,2141,2142,2143,2144,2145,2146,2147,2148,2149,2150,2151,2152,475,166,2153,2154,489,553,554,555,556,557,2155,2156,551,166,2157,2158,2159,2160,980,2161,551,166,2162,2158,2163,2164,980,2165,551,166,2166,2158,2167,2168,551,166,2169,2158,2170,2171,551,166,2172,2158,2173,2174,551,166,2175,2158,2176,2177,551,166,2178,489,2179,2180,2158,2181,2182,2183,2184,570,551,166,2185,2158,2186,2187,551,166,2188,2158,2189,2190,551,166,2191,2158,2192,2193,551,166,2194,2158,2195,2196,551,166,2197,2158,2198,2199,551,166,2200,2158,2201,2202,551,166,2203,2158,2204,2205,2206,551,166,2207,2158,2208,2209,551,166,2210,2158,2211,2212,551,166,2213,2158,2214,2215,551,166,2216,2158,2217,2218,551,166,2219,2158,2220,2221,551,166,2158,2222,2223,2224,551,166,2225,2158,2226,2227,551,166,2228,2158,2229,2230,551,166,2231,2158,2232,2233,551,166,2234,2158,2235,2236,551,166,2237,2158,2238,2239,2240,2241,999,551,166,2242,2158,2243,2244,551,166,2245,2246,2158,2247,2248,2249,2250,999,551,166,2251,2158,2252,2253,551,166,2254,2158,2255,2256,551,166,2257,2158,2258,2259,2260,2261,551,166,2257,2158,2262,2263,551,166,2264,2158,2265,2266,551,166,2267,489,2268,2269,489,602,489,2270,2271,2272,551,166,2273,2274,2275,2276,999,551,166,2277,2158,2278,2279,551,166,2280,2158,2281,975,2282,2283,551,166,2284,2158,2285,2286,551,166,2287,2158,2288,975,2289,2290,2291,551,166,2292,2293,2294,679,2295,2296,2297,1608,2298,1610,1611,1612,847,570,551,166,2299,2158,2300,2301,551,166,2302,2158,2303,2304,551,166,2305,2158,2306,2307,551,166,2308,2309,2310,2311,2312,2313,2314,2315,166,2316,2317,2318,2319,679,2320,2321,2322,727,712,2323,729,2324,2325,730,2326,748,2327,544,166,2328,551,166,2329,2330,975,2310,2331,2332,2333,166,2334,2335,166,2336,606,584,607,2337,2338,2339,610,611,570,166,2340,2341,2342,2343,2344,691,692,2345,698,624,544,166,2346,2347,2348,2349,551,166,2350,489,2351,2352,2353,2354,2355,2356,2357,2358,2359,2360,2361,2362,2363,2364,2365,2366,2367,2368,625,551,166,2369,2370,2371,2372,2373,2374,679,606,584,607,2375,610,611,570,166,904,551,166,2376,2377,675,2378,2379,679,2380,2381,2382,2383,570,166,904,551,166,2384,2385,2386,2387,2388,679,606,2389,607,2390,2391,610,611,570,166,2392,897,570,166,2393,606,584,607,2394,2395,610,611,570,166,2396,2259,2397,904,551,166,2398,2399,2400,606,584,607,2401,2402,610,611,570,904,551,166,2403,2404,2405,2406,2407,2408,691,692,693,2409,697,698,624,570,904,551,166,2410,2411,2412,2413,691,692,693,2414,697,698,624,570,166,2415,2416,2417,2418,2419,691,692,693,2420,2421,2422,697,698,624,2423,606,584,2424,611,570,166,904,551,166,2425,2426,2427,606,584,607,2428,2429,610,611,570,166,2430,2431,2432,2433,2434,679,606,584,607,2435,2436,685,2429,610,611,570,166,904,551,166,2437,2438,2439,2440,688,689,2441,691,692,2442,698,624,570,166,2443,688,689,2444,691,692,693,2445,2446,697,698,624,570,904,551,166,2447,2448,2440,688,689,2441,691,692,2449,698,624,570,166,2450,688,689,2444,691,692,693,2451,2446,697,698,624,570,166,904,551,475,166,2452,2453,2454,2455,2456,2457,2458,2454,2455,2456,2457,2459,166,2460,2461,166,2462,2463,2464,1293,2465,2466,1289,2467,2468,2469,1293,2470,166,2471,2472,2473,2474,2475,2476,551,166,2471,2477,2478,2479,2480,2481,2482,2483,2484,2485,2484,2486,551,166,2471,2477,2478,2487,2488,2489,2490,2491,2492,2493,2494,2495,2496,2497,2484,2498,2484,2499,2484,2500,2484,2501,2502,2503,2484,2504,2505,2506,2505,2507,551,166,2471,2477,2478,2508,2509,2481,2482,2484,2510,551,166,2471,2477,2511,2512,2513,2484,2514,2489,2491,2492,2515,2516,2484,2517,2484,2518,2519,2520,2484,2521,2484,2522,2484,2523,2484,2498,2484,2499,2484,2524,2484,2500,2484,2501,2525,2526,2505,2506,2505,2507,551,166,2527,2528,2529,166,2530,2531,2532,2533,2534,2535,166,2536,570,551,166,2537,2531,2532,2538,570,551,166,2539,2540,2541,2542,2543,2544,719,2545,624,570,551,166,2546,2547,2548,2549,2550,2551,2552,624,570,551,166,2553,2547,2554,2555,2556,2557,2558,995,570,551,166,2559,2547,2560,2561,2562,2563,2564,2565,2566,2567,2568,2569,719,2570,793,2571,2572,2573,2574,2575,2576,2383,166,2577,2578,727,712,713,2579,2580,716,729,730,2581,2572,2582,2574,2583,2383,2584,2585,2586,2587,2588,2589,2590,1613,726,727,712,2591,729,2592,2593,2594,166,2595,2596,2597,2598,2599,2600,2601,2602,2603,2604,2605,2606,2607,2608,2609,2610,2611,2612,2613,2614,2615,2616,1445,2617,2618,2619,2620,2621,2622,2623,2624,610,2625,2626,2627,2628,2629,2630,2631,2632,2633,2634,2635,1189,2636,1191,2637,2638,2639,2640,2641,2642,1445,2617,2564,793,166,2643,2644,570,551,166,2645,2547,2646,2647,2648,2568,2569,719,2570,793,2571,2572,2573,2574,2575,2576,2383,166,2577,2578,727,712,713,2579,2580,716,729,730,2581,2572,2582,2574,2583,2383,2584,2585,2586,2587,2588,2589,2590,1613,726,727,712,2591,729,2592,2593,2594,166,2595,2649,2597,2598,2599,2600,2601,2602,2603,2604,2605,2606,2607,2608,2609,2610,2611,2612,2613,2614,2615,2616,1445,2617,2618,2619,2620,2621,2622,2623,2624,610,2625,2626,2627,2628,2629,2630,2631,2632,2633,2634,2635,1189,2636,1191,2637,2638,2639,535,536,793,166,2643,2644,570,551,166,2650,2547,2651,2568,2569,719,2570,793,166,2652,2653,2654,992,2655,2656,2657,2658,2659,2660,2661,2662,2663,2664,2665,166,2666,2667,2668,2669,2670,2671,2672,2673,2674,2675,2676,2677,2678,2679,2680,2681,2682,2683,2684,711,712,2685,717,2686,166,2687,2688,2689,2690,2574,2691,2692,2693,2694,2695,2696,2697,2698,166,2699,719,2700,2695,2696,2698,166,2699,793,166,2701,2702,2703,2704,166,2705,2585,2706,2707,726,727,712,2591,729,2592,2593,2708,166,2595,2709,2710,2598,509,2600,2601,2711,2606,2605,2712,2713,2714,2604,2603,2608,2609,2715,2716,2611,2717,2613,2614,2718,2719,2720,1445,2721,2617,2618,2619,2722,2723,2724,697,2725,755,2726,2727,2728,2729,2730,2731,2732,2733,2734,2735,2736,2737,2683,2738,755,2638,2639,535,2739,793,166,2643,2644,570,551,166,2740,2547,166,2741,2742,2743,2744,2745,166,2746,2747,2748,2564,2749,2750,2683,2751,755,2752,2750,2683,2753,2754,2755,2756,2757,729,755,995,570,551,166,2758,2759,2744,2745,166,2760,2761,2748,2752,2750,2683,2753,2754,2755,2762,2763,729,755,624,570,551,166,2764,2765,2766,2767,2768,2769,2770,2771,2772,2573,2773,2774,2775,2776,2777,1445,2778,2779,2780,2582,2773,2781,2778,2782,2783,2784,2750,2683,2785,755,2786,2787,2750,2683,2788,755,2789,2750,2683,2790,755,2791,2792,2773,2781,2778,2793,2794,2795,2796,624,570,551,166,2797,2547,2798,2799,2800,2801,2768,2770,2771,2802,2803,2804,2805,2806,2807,2808,2809,2810,2811,610,2812,2803,2813,2814,2815,2816,2817,2818,2819,610,2820,2821,2822,2823,2813,2824,2819,610,2825,2826,2784,2750,2683,2785,755,2786,2827,2750,2683,2753,2828,2755,2829,2763,729,755,2787,2750,2683,2788,755,2789,2750,2683,2790,755,2830,2831,2813,2832,2819,610,2833,2795,2796,995,570,551,166,2834,2835,987,2836,2837,1192,551,166,2838,2839,2840,2835,987,2836,2837,1192,551,475,166,2841,2842,2843,2844,2845,2846,2847,2848,2849,2850,475,166,2851,2852,2853,551,475,166,2854,2855,2856,551,475,166,2857,2858,2859,2860,2861,2862,570,551,475,166,2863,2864,2865,2866,2867,2868,2869,2870,475,166,2863,2864,2871,2872,2873,2874,2875,2870,475,166,2876,2877,2878,2879,551,166,2880,2158,2881,2882,551,475,166,1281,1282,2458,2883,2459,166,2884,2885,2886,2887,2461,166,2888,2889,2890,1288,2891,1289,2892,2893,2894,2895,1293,2896,166,2897,2898,2899,166,2900,2901,166,2902,551,166,2903,2904,2905,166,2906,551,166,1333,2907,2908,2419,2909,2910,2911,2912,2913,2914,2915,1187,2916,2917,2918,2919,2920,2921,2922,2923,2634,2919,2924,2925,2922,2926,2927,2928,1191,2929,2930,2931,1187,2932,2933,2919,2934,2935,2936,2937,2927,2928,1191,2929,2938,2939,2940,2941,755,2942,1187,2943,2944,1191,2929,2945,2946,1187,2947,2948,1191,2929,2949,624,2950,166,1385,1549,1299,2951,2952,2953,2954,2955,2951,2956,2957,2958,2955,1303,1304,1398,166,2959,1318,1487,2960,2961,2962,1490,995,1305,1304,1398,166,2963,2964,2965,2966,2967,2968,2969,2970,2971,2972,2973,2974,2975,2976,2977,2978,2979,2980,2981,2982,1696,2983,2984,2985,2986,2987,1720,2988,2989,2990,2991,2992,544,166,2993,2994,166,2995,2996,551,166,1333,2997,2908,2419,2998,2910,2911,2912,2913,2914,2999,2915,1187,2916,2917,2918,2919,2924,2925,2922,2926,2927,2928,1191,2929,2930,2931,1187,2932,2933,2919,2934,2935,2936,2937,2927,2928,1191,2929,2938,2939,2940,2941,755,2942,1187,2943,2944,1191,2929,2945,3000,3001,3002,3003,3004,3005,3006,3007,3008,1612,3009,3010,1191,2929,3011,1187,3012,3013,3014,3015,3016,3017,1191,2929,2946,1187,2947,2948,1191,2929,2949,624,2950,166,1385,1549,3018,3019,3020,3021,3022,1304,1398,166,2959,1318,1487,2960,2961,2962,1490,995,1305,1304,1398,166,1587,1588,3023,1590,3024,3025,1593,1594,1658,995,3026,1591,1480,166,3027,3028,3029,3030,3031,3032,3033,586,1966,3034,3035,1575,1480,166,2963,2964,3036,2966,2967,2968,2969,2970,2971,2972,2973,2974,2975,2976,2977,3037,2979,2980,2981,2982,1696,2983,2984,2985,2986,2987,1720,2988,2989,2990,3038,3039,544,166,2993,2994,166,2995,2996,551,166,1333,3040,2908,679,3041,3042,3043,3044,3045,3046,3047,3048,3049,3050,3051,3052,3053,3054,3055,3056,3052,3053,3054,3057,3058,3052,3059,3054,3060,3061,3052,3062,3054,3063,3064,3052,3065,3066,537,3067,3068,3069,3070,3071,3072,3073,3074,3075,3076,3077,3072,3078,3079,537,3080,3081,3082,3083,3084,3085,537,3086,3087,3088,3089,3090,3091,3092,3093,3094,3095,3096,3097,3098,3072,3099,3088,3100,3072,3101,3102,3103,3104,3105,2950,166,1385,1299,3106,2952,3107,3108,2955,3106,3109,3110,3108,2955,3106,1413,3111,3112,2955,3106,2956,3113,3114,2955,3106,3115,3116,3117,2955,1303,1304,1398,166,3118,2959,1318,3119,1305,1304,1398,166,1056,3120,3121,1398,166,1587,3122,3023,1590,1591,3123,3124,1480,166,2963,2964,3125,3126,3127,3128,3129,3130,3131,2972,2973,3132,2975,2976,3133,3134,3135,3136,3137,3138,3139,3140,1720,3141,3142,2989,2990,2991,2992,544,166,2994,551,166,1333,3143,2908,679,3144,3145,3146,3147,3148,3149,3150,992,3151,3152,3153,3154,3155,3156,3157,3158,3017,3159,616,3160,3161,3162,992,3163,2948,616,3160,3164,3165,3166,3167,992,3168,3169,616,3160,3170,992,3171,3172,616,3160,3173,570,2950,166,1385,1549,3018,3174,3175,3176,3022,1304,1398,166,2959,1318,1304,1398,166,2963,2964,2965,2966,2967,2968,2969,2970,2971,2972,2973,2974,2975,2976,2977,2978,2979,2980,3177,2984,2985,2986,2987,1720,2988,2989,2990,2991,2992,544,166,2993,2994,166,2995,2996,551,166,1333,3178,2908,679,3144,3145,3146,3147,3148,3149,3150,992,3151,3152,3153,3154,3155,3156,3157,3158,2736,3154,3179,3180,3157,3181,3017,3159,616,3160,3161,3162,992,3163,3182,3154,3183,3184,3185,3186,3017,3159,616,3160,3165,3166,3187,3188,537,3167,992,3168,3169,616,3160,3170,992,3171,3172,616,3160,3189,3190,3081,3082,3191,3084,3085,537,3086,3192,3088,3089,3090,3091,3092,3093,3094,3095,3096,3097,3098,537,2419,3193,3194,3089,3090,3091,3092,3093,3094,3095,3096,3097,3098,3104,570,3195,166,3196,1341,1679,3197,826,551,166,1333,3198,2908,679,3144,3145,3146,3147,3148,3149,3150,992,3151,3152,3153,3154,3155,3156,3157,3158,2736,3154,3179,3180,3157,3181,3017,3159,616,3160,3161,3162,992,3163,3182,3154,3183,3184,3185,3186,3017,3159,616,3160,3165,3166,3187,3188,537,3167,992,3168,3169,616,3160,3170,992,3171,3172,616,3160,3189,3081,3082,3199,3084,3085,537,3086,3192,3088,3089,3090,3091,3092,3093,3094,3095,3096,3097,3098,3104,570,3195,166,3196,1341,1679,3200,826,551,166,1333,3201,2908,679,3144,3145,3146,3147,3148,3149,3150,992,3151,3152,3153,3154,3155,3156,3157,3158,2736,3154,3179,3180,3157,3181,3017,3159,616,3160,3161,3162,992,3163,3182,3154,3183,3184,3185,3186,3017,3159,616,3160,3165,3166,3187,3188,537,3167,992,3168,3169,616,3160,3170,992,3171,3172,616,3160,3189,3081,3082,3199,3084,3096,3202,3191,3084,3085,537,3086,3192,3088,3089,3090,3091,3092,3093,3094,3095,3096,3097,3098,3104,570,3195,166,3196,1341,1907,3203,586,826,551,166,1333,3204,2908,679,3205,3206,3207,3208,3209,3210,3211,3150,992,3212,3213,3182,3154,3155,3214,3157,3215,3017,3159,616,3160,3165,3162,992,3163,2948,616,3160,3166,3189,3170,992,2947,2948,616,3160,3216,3217,3218,992,3219,3220,3221,3222,3223,1612,3224,3225,616,3160,3226,3227,3228,570,3195,166,3196,1685,3229,1687,166,3230,3231,3232,3233,826,3234,3235,166,3236,3231,3233,3237,826,3234,3238,551,166,1333,3239,2908,679,3205,3206,3207,3240,3209,3210,3211,3150,992,3212,3213,3182,3154,3155,3214,3157,3215,3017,3159,616,3160,3165,3162,992,3163,2948,616,3160,3166,3189,3170,992,2947,2948,616,3160,3216,3217,3218,992,3219,3220,3241,3222,3223,1612,3224,3225,616,3160,3242,992,3219,3243,3244,3245,3246,3154,3247,3248,3249,3250,3251,3252,3017,3159,616,3160,3227,3228,570,3195,166,1385,1591,3018,3174,3253,3254,3022,1304,1398,2959,1318,1304,1398,1587,3255,3256,1700,3257,1591,1593,1594,1658,995,1480,166,2963,2964,2965,3258,3259,3260,3261,3262,3131,2972,2973,3132,2975,2976,2977,3263,3264,3265,3177,2984,3266,3267,1716,3268,3269,3270,3271,3272,3273,3274,3275,3276,3277,3278,3279,2990,3280,1716,751,752,753,754,755,3279,2991,2992,544,166,2994,551,166,1333,3281,2908,679,3205,3206,3207,3240,3209,3210,3211,3150,992,3212,3213,3182,3154,3155,3214,3157,3215,3017,3159,616,3160,3165,3162,992,3163,2948,616,3160,3166,3189,3170,992,2947,2948,616,3160,3216,3217,3218,992,3219,3220,3241,3222,3223,1612,3224,3225,616,3160,3282,992,3219,3283,3284,616,3160,3227,3228,570,2950,166,1385,1591,3018,3174,3253,3254,3022,1304,1398,2959,1318,1304,1398,1587,3255,3256,1700,3257,1591,1593,1594,1658,995,1480,166,2963,2964,2965,3258,3259,3260,3261,3262,3131,2972,3132,2973,2975,2976,2977,3263,3264,3265,3177,2984,3266,2989,3285,3286,3287,3273,3288,3289,755,2983,3280,1716,751,752,753,754,755,3279,2991,2992,544,166,2994,551,166,1333,3290,2908,2419,2909,3291,624,2950,3292,904,551,166,1333,3293,2908,2419,3294,624,2950,3292,904,551,166,1333,3295,3296,3297,166,3298,3299,166,1385,1591,1299,3300,3301,3302,3303,610,3300,3304,3305,610,2951,1413,3306,3108,2955,1303,1304,1398,166,2959,1318,1487,3307,1405,1418,1490,995,1305,1304,1398,166,1056,3308,1311,1489,1405,1406,1315,995,1311,1312,1313,1314,3309,995,3121,1398,166,2963,2964,3036,3258,3259,3260,3261,3262,3131,2972,3132,2973,2975,3310,3311,2978,2979,3265,3177,2984,3266,2988,2989,2990,2991,3312,544,166,3313,551,166,1333,3314,3315,3316,166,3317,1591,3018,3174,3253,3254,3022,1304,1398,166,3318,1549,1299,2951,2952,3319,3108,2955,3300,3304,3305,610,2951,1413,3306,3108,2955,1303,3320,1304,1398,166,3321,1318,1487,3307,1405,1418,1490,995,1305,1304,1398,166,1056,3308,1311,1489,1405,1406,1315,995,1311,1312,1313,1314,3309,995,3121,1398,166,3322,3323,3324,1590,3325,1593,1594,1658,995,1480,166,3326,3255,3327,3256,1700,1549,3257,1593,1594,1658,995,1480,166,3328,2964,2965,3258,3259,3260,3261,3329,2971,2972,3132,2973,2975,3310,3311,3330,3331,3332,3333,3264,3265,3177,3334,3335,3336,3337,755,3335,3273,3338,755,3160,3266,3280,1716,751,752,753,754,755,3279,2989,2990,2991,2992,544,166,3339,551,166,1333,3340,3315,3341,166,1385,1591,1299,2951,2952,3319,3108,2955,3300,3304,3305,610,2951,1413,3306,3108,2955,1303,1304,1398,166,2959,1318,1487,3307,1405,1418,1490,995,1305,1304,1398,166,1056,3308,1311,1489,1405,1406,1315,995,1311,1312,1313,1314,3309,995,3121,1398,166,2963,2964,2965,3258,3259,3260,3261,3262,3131,2972,2973,3132,2975,3310,3311,2978,2979,3265,3177,3342,3266,2988,2989,2990,2991,2992,544,166,3339,551,166,1333,3343,3315,3344,166,1385,1591,1299,2951,2952,3319,3108,2955,3300,3304,3305,610,2951,1413,3306,3108,2955,1303,1304,1398,166,2959,1318,1487,3307,1405,1418,1490,995,1305,1304,1398,166,2963,2964,3125,3345,3259,3346,3261,3262,3131,2972,3132,2973,3347,2976,3348,2977,3349,2979,3136,3177,3342,3266,2988,2989,2990,2991,2992,544,166,3339,551,166,1333,3350,3315,3344,3351,1494,3352,3353,3354,826,551,166,1333,3355,3315,3356,166,3357,3358,3359,166,3360,3361,1494,3362,3363,826,1494,3364,3365,826,3366,3367,551,166,1333,3368,3369,3370,594,1564,166,3371,3358,3372,166,3373,3361,1494,3362,3374,826,166,3375,3376,3377,3378,3379,3380,551,166,1333,3381,3315,3382,3383,166,3384,3385,166,3386,3387,1341,3388,3389,826,551,166,1333,3390,3369,3391,594,1564,166,3392,3358,3393,166,3394,3361,1494,3362,3374,826,166,3395,3396,3397,166,3398,3399,3400,3401,3402,3403,3404,551,166,1333,3405,3315,3406,3383,166,3385,166,1494,3407,3408,594,551,166,1333,3409,3315,3410,3383,166,3385,166,1494,3407,3411,594,551,166,1333,3412,3315,3413,3383,166,3385,166,1494,3407,3411,594,551,166,1333,3414,3369,3415,594,1564,166,3385,166,1494,3407,3411,594,551,166,1333,3416,3315,3417,3383,166,3385,166,1494,3407,3411,594,551,166,1333,3418,3315,3419,3383,166,3385,166,1494,3407,3411,594,551,166,1333,3420,3421,3422,3423,551,166,1333,3424,3425,3426,3427,3428,3429,964,3430,166,1494,3431,3432,3433,3434,3435,1818,826,551,1333,3436,3437,3426,3438,3429,1064,3439,166,1494,3440,3441,3442,3443,3434,594,551,166,1333,3444,3445,3446,3447,1973,3448,1480,3449,1305,1304,1305,1375,3450,3451,1494,3452,2372,3453,3434,3454,3455,3456,3457,826,3458,1494,3459,3460,3461,3300,3462,3463,3464,3465,871,3466,826,1494,3467,3460,3461,3468,3469,3470,1613,3466,826,551,166,3471,3472,3473,3474,3475,166,3476,3477,166,3478,3479,166,3480,3481,3482,166,3483,3484,3485,2349,1398,166,3486,3487,166,3488,3489,2349,1398,166,3490,3491,551,166,3471,3492,3474,3493,166,3479,3494,166,3495,3496,3497,3498,166,3488,3477,3499,3500,2349,1398,166,3490,3491,551,166,3471,3501,3476,3477,166,3502,3503,166,3504,1806,551,166,3471,3505,3474,3475,3477,166,3506,3479,166,3507,3508,3509,3510,3511,826,3512,3513,3514,3515,3516,3434,3517,3434,3518,166,3519,3520,3521,3482,166,3522,3523,166,3524,3525,3485,2349,1398,166,3526,3527,166,3528,3529,3530,3531,3532,166,3533,3489,2349,1398,166,3534,3535,551,166,1333,3536,1385,1299,1790,3537,1824,1303,1304,1398,166,3538,1486,3539,1305,1304,1398,166,3540,3541,3542,1305,1304,1398,166,3543,1351,576,3544,1338,3545,1339,1326,594,1327,3546,1327,1328,1327,1348,166,3547,3548,166,3549,3550,3551,551,166,1333,3552,3553,1385,1299,1790,1303,1304,1398,166,1351,576,1460,1338,3545,1339,1326,594,1327,1328,1327,1348,166,3554,3555,551,166,1333,3556,3557,3317,1549,1299,3558,3559,1303,1304,1398,166,3318,3560,1299,3558,3561,1303,1304,1398,166,1351,3562,1460,1338,3545,1339,1326,594,1327,3563,1327,1328,1327,1348,166,3564,3565,3566,166,3567,3568,3569,551,166,1333,3570,3571,166,1351,576,1460,1338,3545,1339,1326,594,1327,1328,1327,1348,166,3572,551,166,1333,3573,3574,1789,1299,2012,3575,1389,1413,3576,3117,871,1396,1303,1304,1398,166,1351,1793,1460,1338,3545,1339,1326,594,1564,166,1800,1299,2012,3575,1389,1413,3576,3117,871,1396,3577,1824,1303,1304,1398,166,3578,3579,1299,2012,3575,3577,1824,3580,1824,1303,1304,1398,166,3581,3582,1305,1304,1305,1375,166,3583,166,3584,3585,3586,3587,3588,551,166,1333,3589,3590,679,3205,3206,3207,3591,3592,3210,3593,3150,992,3212,3594,3182,3595,3596,3159,616,3160,3165,3597,3598,3189,3170,992,2947,3182,3154,3599,3600,3601,3602,3017,3159,616,3160,3216,3603,3604,570,2950,166,3605,166,3606,1341,3607,3608,826,551,166,1333,3609,3610,166,1385,1299,2012,1303,1304,1398,166,1351,576,1460,1338,3545,1339,1326,594,1327,1328,1327,1348,166,3611,166,1494,3612,3613,826,1494,3614,3615,826,551,166,1333,3616,3610,166,1385,1299,2012,1303,1304,1398,166,3617,3618,3619,3620,3621,3618,3622,3623,3621,1458,166,1351,576,1460,1338,3545,1339,579,594,1327,1328,1327,1348,166,3611,166,3624,3625,551,166,1333,3626,1385,1299,2012,1303,1304,1398,166,3627,3628,3629,3630,166,1351,576,1460,1338,3545,1339,579,594,1327,1328,1327,1348,166,3631,3632,3633,551,166,1333,3634,3635,1385,1299,2012,1303,1304,1398,166,3636,576,1460,1338,3637,1339,1326,594,1327,1328,1327,1348,166,3638,1587,1588,3639,1700,1591,3640,1593,1594,3641,3642,3643,1457,995,1480,166,3644,3645,3646,1305,3647,1618,751,752,753,754,755,995,1305,1304,1305,1375,166,3648,3649,3650,166,3651,3652,3653,3654,1305,1304,1305,1375,166,3655,3656,3657,166,3658,3659,1341,3660,3661,826,166,3662,3663,1341,3664,3665,826,166,3666,3667,3668,3669,166,3670,3671,1341,3672,3673,826,551,166,1333,3674,3675,1385,1299,2012,1303,1304,1398,166,1346,576,1460,1338,3637,1347,1326,594,1327,1328,1327,1348,166,3676,1587,1588,3677,1700,1591,3640,1593,1594,3641,3642,3643,1457,995,3678,1480,166,3679,3645,3646,1305,3647,1618,751,752,753,754,755,995,1305,1304,1305,1375,166,3680,3681,1341,3682,3683,826,3684,3685,3686,166,3687,3688,1341,3664,3689,826,166,3666,3667,3668,3669,166,3690,3671,1341,3691,3692,826,3693,3694,3695,3696,551,475],[6233],{"_419":420,"_421":3700,"_292":6234,"_424":62},[425,426,427,428,429,430,431,432,433,432,434,435,436,437,438,439,166,3702,166,440,2048,441,166,3703,3704,3705,3706,3707,3708,3709,3710,3711,2052,166,3712,3713,3714,3715,3716,3717,3718,3719,3720,3721,449,3722,166,3723,3724,3725,3726,3727,3728,166,3729,3730,3731,3732,3733,3734,3735,3736,166,3737,3738,166,3739,3740,3741,166,3742,475,166,3743,3744,3745,3746,3747,551,475,166,3748,166,3749,3750,3751,3752,3753,3737,3736,3754,475,166,3755,3756,3757,3758,600,551,166,3759,3760,489,3761,3762,3763,600,551,166,3764,3765,3766,600,551,166,3767,3768,3769,600,551,166,3770,3771,3772,600,551,166,3773,3774,3775,3776,570,166,3777,166,3778,3779,166,3780,3781,3782,3783,3784,166,3785,3786,3787,3788,544,166,3789,653,3790,983,166,3791,166,3792,3793,3794,3795,3796,3797,3798,166,3799,3800,3801,166,3802,544,166,3803,3804,3805,3806,3807,3808,166,3809,3810,3811,3812,3813,3814,570,166,3815,551,166,3816,3817,3818,3819,3820,3821,3822,3823,3819,3824,3825,3822,3823,624,3826,3827,3828,616,624,3829,3830,624,3831,3832,3833,624,3834,570,166,904,551,166,3835,3836,166,3837,3838,3839,3840,3841,3842,616,166,3843,3844,3845,3846,3847,1191,616,3848,3849,616,624,570,166,3850,551,166,3851,3852,3853,3838,3839,3854,3855,616,3843,3856,166,3857,3858,3859,3860,3861,166,3862,616,3848,3849,616,624,570,166,3863,551,166,3864,3865,3866,3867,3868,3869,3870,3871,3872,2332,3873,3874,3875,869,692,693,3876,697,871,872,3877,3878,3879,3880,2383,3881,3819,3882,3883,3822,3823,719,691,692,693,3884,3885,697,698,624,166,3886,3887,3888,3889,3890,3819,3891,3892,3893,3894,3823,3819,3895,3896,3893,3894,3823,3897,624,570,166,904,551,475,166,3898,3899,3900,3901,3902,590,3903,3904,3905,570,551,166,3906,3907,3901,3794,3908,3797,3796,3905,570,551,166,3909,3910,3911,551,166,3912,489,3913,3914,3915,3916,3917,551,166,3918,489,3913,3919,3920,3921,3917,551,166,3922,3923,3924,3925,3917,551,166,3926,2158,3927,3928,551,166,3929,2158,3930,3931,551,166,3932,2158,3933,3934,551,166,3935,3936,3937,1797,653,3938,551,166,3939,2158,3940,3941,551,166,3942,3943,3944,551,166,3945,3946,3947,551,166,3948,3949,3950,551,166,3951,3952,3953,3954,551,166,3955,3956,3957,3958,3959,551,166,3960,3961,3962,551,166,3963,3964,3965,551,475,166,3966,3967,3968,3969,3970,3971,3972,3973,570,3974,551,475,166,3975,2858,3976,3977,3978,570,3979,551,475,166,1281,1282,2458,166,3980,166,3981,3982,3983,1293,3984,3985,3986,166,1333,3987,3988,3989,3990,3991,166,1385,3992,3993,3994,1304,1398,166,3995,3996,3997,3998,3999,551,166,4000,1385,1549,4001,1299,4002,4003,4004,1303,1304,1398,4005,4006,4007,4008,992,4009,4010,4011,4012,755,992,4013,4014,4015,4016,755,992,4017,4018,4011,4019,616,3160,4020,4021,4022,551,166,4023,1298,1549,4001,1299,4002,4003,4004,1389,2956,4024,4025,4026,4027,4028,4029,2616,2811,4030,871,1396,1389,4031,4032,4033,4034,4035,4028,2616,2811,4036,4037,4038,4039,4040,4041,4042,4043,4044,4045,4046,4047,4042,4043,4048,4029,2616,2811,4030,871,1396,1389,4049,4050,4025,4026,4051,4052,4053,4054,4055,4056,4042,4043,4053,4057,4058,4056,4042,4043,4059,4029,2616,2811,4030,871,1396,4060,4061,4062,1392,4063,1394,4064,1394,1395,871,1396,1303,1304,1305,551,166,1333,4065,4066,4067,4068,4069,4070,475,4071,166,4072,551,166,1333,4073,4074,1549,4075,1299,4076,4077,4078,4079,1303,1480,166,1341,4080,1343,4081,826,551,166,1333,4082,4083,4084,4085,166,4086,551,166,1333,4087,4088,4089,4090,4091,4092,4093,4094,4095,4096,4097,4098,4099,4100,4101,4102,4103,4104,4105,4106,4107,4108,4109,4110,826,166,4111,4112,551,166,1333,4113,4088,4089,4114,4115,4116,4117,4118,4119,4120,4121,4122,4123,4124,4125,4126,4127,4128,4129,4130,4131,4132,4109,4110,826,166,4111,4133,4134,4135,4136,2383,570,551,166,1333,4137,4138,4139,4140,4141,4142,4143,4144,4145,4146,4147,4148,4149,4150,4151,4152,1458,166,4111,4153,4134,4154,4155,4156,2383,570,551,166,1333,4157,4111,166,4158,551,166,1333,4159,4160,166,4161,166,4162,4134,4154,4155,4156,2383,570,551,166,1333,4163,4161,166,1494,4164,4165,826,1494,4166,4167,826,1494,4168,4169,826,166,4170,4171,551,166,1333,4172,4173,3618,3174,4174,3621,3618,4175,4176,3621,3618,4177,4178,3621,3618,3019,1389,2956,4024,4025,4026,4027,4028,4029,2616,2811,4030,610,3621,3618,4179,4180,3621,3618,4181,1389,4031,4032,4182,4034,4035,4183,2616,2811,4036,4037,4184,4039,4040,4185,4042,4043,4044,4045,4186,4047,4042,4043,4048,4029,2616,2811,4030,610,3621,3618,4187,4188,3621,3618,4189,1389,4190,4191,4182,4034,4192,4183,2616,2811,4036,4193,4194,4029,2616,2811,4030,610,3621,3618,4195,4196,3621,3618,4197,4198,3621,3618,4199,1389,4049,4050,4200,4026,4051,4201,4053,4054,4055,4202,4042,4043,4053,4057,4058,4202,4042,4043,4059,4029,2616,2811,4030,610,3621,3618,4203,4204,4205,4206,4207,1394,4208,1394,1395,4209,610,3621,3618,4210,4211,3621,3618,4212,4213,3621,3618,4214,4060,4061,4062,1392,4063,1394,4064,1394,1395,610,3621,3618,4215,4216,3621,3618,4217,4218,3621,1458,166,4111,4219,4134,4220,4221,4222,2383,570,551,166,1333,4223,4111,166,4224,4225,4226,4227,4228,4229,4230,4231,4232,4233,4234,4235,4236,4237,4238,4239,4240,4241,4242,1602,4243,4244,4245,4246,4247,1458,166,1494,4248,4249,3434,4250,4251,4252,826,1494,4248,4253,3434,4250,4251,4254,826,1494,4248,4255,3434,4250,4251,4256,826,1494,4248,4257,3434,4250,4251,4258,826,1494,4248,4259,3434,4250,4251,4260,826,551,166,1333,4261,4111,4262,166,4161,4263,551,166,1333,4264,4265,4266,551,166,1333,4267,4268,1549,4269,4270,1299,4271,4272,4004,1303,1304,1678,166,4273,551,166,1333,4274,4265,4275,1818,1199,4276,1304,1398,166,4277,4278,551,166,1333,4279,4280,1341,4281,4282,4283,4284,4285,4286,4287,4288,4289,4043,4290,4291,4292,4293,2672,1394,4294,729,4295,4296,3517,4297,826,1341,4281,4282,4298,4284,4285,4286,4287,4288,4289,4043,4290,4291,4292,4293,2672,1394,4294,729,4295,4296,3517,4297,826,166,4299,1341,4281,4282,4283,4284,4285,4286,4300,4301,4302,4303,4304,4305,2672,1394,4294,729,4295,4296,3517,4297,826,166,4306,1341,4281,4282,4283,4284,4307,4286,4308,4309,4310,4303,4311,4312,2672,1394,4313,4043,4314,729,4295,4296,3517,4297,826,166,4315,1341,4281,4282,4316,4284,4317,4318,4296,3517,4297,826,1341,4281,4282,4316,4284,4319,4318,4296,3517,4297,826,166,4320,1341,4281,4282,4316,4284,4321,4318,4296,3517,4322,826,1341,4281,4282,4316,4284,4323,4318,4296,3517,4297,826,551,166,1333,4324,4325,4326,4327,4328,4329,4330,4331,660,166,4332,4333,4334,4335,4336,4337,2383,166,4338,4339,4340,4341,1187,4342,4343,4344,4345,4346,1191,4347,660,166,4348,4333,4349,4335,4350,4351,2383,570,551,166,1333,4352,4353,4354,4355,4356,992,4357,4358,4359,4360,4361,4362,616,4109,591,166,4363,551,166,1333,4364,1341,4281,4282,4284,4365,4296,3517,4322,826,166,4366,1549,1299,4367,1303,1304,1678,1341,4368,1343,4369,826,166,4370,1549,1299,4371,4372,1824,1303,1304,1678,1341,4373,1343,4374,826,551,475],[6236,6237,6238,6239,6240,6241,6242,6243,6244,6245,6246,6247],{"_295":49,"_49":4407},{"_295":4389,"_412":3697,"_419":4405,"_421":4406},{"_295":4389,"_412":3697,"_419":4403,"_421":4404},{"_295":49,"_49":4402},{"_295":4389,"_412":2039,"_419":4400,"_421":4401},{"_295":49,"_49":4399},{"_295":4389,"_412":413,"_419":4397,"_421":4398},{"_295":4389,"_412":413,"_419":4395,"_421":4396},{"_295":49,"_49":4394},{"_295":4389,"_412":413,"_419":4392,"_421":4393},{"_295":4389,"_412":413,"_419":4390,"_421":4391},{"_295":49,"_49":4388},{"_112":385,"_388":4410,"_147":4411,"_389":-5,"_364":4412,"_391":6249,"_393":345,"_395":4414,"_397":35,"_399":400,"_401":6250},{"_403":4416,"_405":-5},[],[],[],{"_278":279,"_280":281},{"_276":6273},{"_273":6272},{"_273":6271},{"_45":142,"_160":161,"_162":163,"_164":18,"_165":166,"_167":168,"_169":6260,"_171":-5,"_172":173,"_174":18,"_175":6261,"_177":166,"_178":166,"_179":6262,"_181":6263,"_183":6264,"_185":-5,"_186":187,"_188":189,"_190":191,"_192":6265,"_58":-5,"_138":194,"_195":6266,"_197":6267,"_199":200,"_201":18,"_202":18},{"_151":6259},[],{"_266":267,"_268":-5,"_269":-5,"_270":-5,"_271":-5,"_272":-5},[224],{"_224":6268},{"_206":207,"_208":209,"_210":211,"_212":213,"_214":215,"_216":217,"_218":219,"_220":221,"_222":223},{},[],{"_205":62},{"_203":62,"_204":166},{"_45":226,"_227":228,"_229":6269,"_231":163,"_232":233,"_234":235,"_236":237,"_238":239,"_240":241,"_242":67,"_243":18,"_244":18,"_245":62,"_246":62,"_247":62,"_248":18,"_249":-5,"_250":251,"_252":-5,"_58":6270},{"_258":259,"_45":260,"_112":261,"_262":263,"_264":265},{"_254":62,"_255":18,"_256":62,"_257":62},[],[],[],[6275],{"_112":280,"_116":284,"_292":6276},[6277],{"_295":49,"_49":296},"task_e_69fc383a26d08330884ce8c58eaec061",1778137146.151768,"Github Mention: feat(spec): add unknown datatype support","has_generated_title","has_unread_turn","denormalized_metadata",{"_6313":35,"_6314":6315,"_6316":-5,"_6317":-5,"_6307":6318,"_6319":-5,"_6320":-5,"_6321":-5,"_6322":-5},"task_status_display",{"_6301":6302,"_6303":163,"_148":146,"_6304":-5,"_6305":381},"creator_workspace","external_pull_requests",[6290,6291],{"_45":6298,"_6293":90,"_6294":6299,"_6296":309},{"_45":6292,"_6293":102,"_6294":6295,"_6296":361},"github-725189608-3","assistant_turn_id","pull_request",{"_344":345,"_264":346,"_347":348,"_349":18,"_350":18,"_351":18,"_352":353,"_354":355,"_356":146,"_357":310,"_358":359,"_360":361,"_362":-5,"_363":-5,"_364":-5,"_284":6297,"_366":345,"_367":368,"_369":370,"_371":372},"codex_updated_sha",{"_258":259,"_227":259,"_373":-5,"_262":263,"_45":260},"github-725189608-1",{"_344":420,"_264":6117,"_347":348,"_349":18,"_350":62,"_351":18,"_352":6118,"_354":6119,"_356":235,"_357":146,"_358":6120,"_360":309,"_362":6121,"_363":-5,"_364":-5,"_284":6300,"_366":4474,"_367":336,"_369":6123,"_371":372},{"_258":259,"_227":259,"_373":-5,"_262":263,"_45":260},"latest_turn_status_display",{"_6306":87,"_132":133,"_6307":6308,"_114":6309,"_6310":-5,"_6311":-5,"_6312":381,"_134":-5},"environment_label","fix_task_id","initial_intent","turn_id","diff_stats",{"_393":394,"_395":396,"_397":398},[],"image_asset_pointer_citations","issue_counts","intent","num_follow_ups","repo_name_map",{},"last_user_turn_created_at","last_turn_status",{"_393":-5,"_395":-5,"_397":-5},"last_pushed_turn_id","start_branch_name","pushed_branch_name","cached_pull_request_data","dd",{"_6337":6338,"_6339":6340},"disablePrefetch","shouldPrefetchAccount","shouldPrefetchUser","shouldPrefetchSystemHints","manageRootRouteStylesheet","mobileWebHandoffEnabled","promoteCss","disableSSR","stripModulepreloadImports","paidCampaignAppRedirect","statsigGateEvaluationsPromise",["P",6336],"traceId","13465581343530122194","traceTime",1787895282212]