Merge pull request #203 from JanKaul/snapshot-partition-bounds

JanKaul · web-flow · commit fe8b47db7034 · 2025-07-07T13:11:27.000+02:00
Add function to obtain partition bounds of snapshot
diff --git a/catalogs/iceberg-file-catalog/src/lib.rs b/catalogs/iceberg-file-catalog/src/lib.rs
@@ -716,7 +716,7 @@ pub mod tests {
             .with_config("aws_secret_access_key".parse().unwrap(), "password")
             .with_config(
                 "endpoint".parse().unwrap(),
-                format!("http://{}:{}", localstack_host, localstack_port),
+                format!("http://{localstack_host}:{localstack_port}"),
             )
             .with_config("region".parse().unwrap(), "us-east-1")
             .with_config("allow_http".parse().unwrap(), "true");
diff --git a/catalogs/iceberg-glue-catalog/src/lib.rs b/catalogs/iceberg-glue-catalog/src/lib.rs
@@ -1067,7 +1067,7 @@ pub mod tests {
             .with_config("aws_secret_access_key".parse().unwrap(), "password")
             .with_config(
                 "endpoint".parse().unwrap(),
-                format!("http://{}:{}", localstack_host, localstack_port),
+                format!("http://{localstack_host}:{localstack_port}"),
             )
             .with_config("region".parse().unwrap(), "us-east-1")
             .with_config("allow_http".parse().unwrap(), "true");
diff --git a/catalogs/iceberg-glue-catalog/src/schema.rs b/catalogs/iceberg-glue-catalog/src/schema.rs
@@ -31,13 +31,11 @@ pub(crate) fn type_to_glue(datatype: &Type) -> Result<String, Error> {
             PrimitiveType::String | PrimitiveType::Uuid => Ok("string".to_owned()),
             PrimitiveType::Binary | PrimitiveType::Fixed(_) => Ok("binary".to_owned()),
             x => Err(Error::InvalidFormat(format!(
-                "Type {} cannot be converted to glue type",
-                x
+                "Type {x} cannot be converted to glue type"
             ))),
         },
         x => Err(Error::InvalidFormat(format!(
-            "Type {} cannot be converted to glue type",
-            x
+            "Type {x} cannot be converted to glue type"
         ))),
     }
 }
diff --git a/catalogs/iceberg-rest-catalog/src/catalog.rs b/catalogs/iceberg-rest-catalog/src/catalog.rs
@@ -730,7 +730,7 @@ pub mod tests {
             .with_config("aws_secret_access_key".parse().unwrap(), "password")
             .with_config(
                 "endpoint".parse().unwrap(),
-                format!("http://{}:{}", localstack_host, localstack_port),
+                format!("http://{localstack_host}:{localstack_port}"),
             )
             .with_config("region".parse().unwrap(), "us-east-1")
             .with_config("allow_http".parse().unwrap(), "true");
diff --git a/catalogs/iceberg-sql-catalog/src/lib.rs b/catalogs/iceberg-sql-catalog/src/lib.rs
@@ -340,7 +340,7 @@ impl Catalog for SqlCatalog {
             let name = identifier.name().to_string();
             let metadata_location = metadata_location.to_string();
 
-            sqlx::query(&format!("insert into iceberg_tables (catalog_name, table_namespace, table_name, metadata_location) values ('{}', '{}', '{}', '{}');",catalog_name,namespace,name, metadata_location)).execute(&self.pool).await.map_err(Error::from)?;
+            sqlx::query(&format!("insert into iceberg_tables (catalog_name, table_namespace, table_name, metadata_location) values ('{catalog_name}', '{namespace}', '{name}', '{metadata_location}');")).execute(&self.pool).await.map_err(Error::from)?;
         }
         self.cache.write().unwrap().insert(
             identifier.clone(),
@@ -380,7 +380,7 @@ impl Catalog for SqlCatalog {
             let name = identifier.name().to_string();
             let metadata_location = metadata_location.to_string();
 
-            sqlx::query(&format!("insert into iceberg_tables (catalog_name, table_namespace, table_name, metadata_location) values ('{}', '{}', '{}', '{}');",catalog_name,namespace,name, metadata_location)).execute(&self.pool).await.map_err(Error::from)?;
+            sqlx::query(&format!("insert into iceberg_tables (catalog_name, table_namespace, table_name, metadata_location) values ('{catalog_name}', '{namespace}', '{name}', '{metadata_location}');")).execute(&self.pool).await.map_err(Error::from)?;
         }
         self.cache.write().unwrap().insert(
             identifier.clone(),
@@ -423,14 +423,14 @@ impl Catalog for SqlCatalog {
             let name = identifier.name().to_string();
             let metadata_location = metadata_location.to_string();
 
-            sqlx::query(&format!("insert into iceberg_tables (catalog_name, table_namespace, table_name, metadata_location) values ('{}', '{}', '{}', '{}');",catalog_name,namespace,name, metadata_location)).execute(&mut *transaction).await.map_err(Error::from)?;
+            sqlx::query(&format!("insert into iceberg_tables (catalog_name, table_namespace, table_name, metadata_location) values ('{catalog_name}', '{namespace}', '{name}', '{metadata_location}');")).execute(&mut *transaction).await.map_err(Error::from)?;
 
             let table_catalog_name = self.name.clone();
             let table_namespace = table_identifier.namespace().to_string();
             let table_name = table_identifier.name().to_string();
             let table_metadata_location = table_metadata_location.to_string();
 
-            sqlx::query(&format!("insert into iceberg_tables (catalog_name, table_namespace, table_name, metadata_location) values ('{}', '{}', '{}', '{}');",table_catalog_name,table_namespace,table_name, table_metadata_location)).execute(&mut *transaction).await.map_err(Error::from)?;
+            sqlx::query(&format!("insert into iceberg_tables (catalog_name, table_namespace, table_name, metadata_location) values ('{table_catalog_name}', '{table_namespace}', '{table_name}', '{table_metadata_location}');")).execute(&mut *transaction).await.map_err(Error::from)?;
 
             transaction.commit().await.map_err(Error::from)?;
         }
@@ -483,7 +483,7 @@ impl Catalog for SqlCatalog {
         let metadata_file_location = metadata_location.to_string();
         let previous_metadata_file_location = previous_metadata_location.to_string();
 
-        sqlx::query(&format!("update iceberg_tables set metadata_location = '{}', previous_metadata_location = '{}' where catalog_name = '{}' and table_namespace = '{}' and table_name = '{}' and metadata_location = '{}';", metadata_file_location, previous_metadata_file_location,catalog_name,namespace,name, previous_metadata_file_location)).execute(&self.pool).await.map_err(Error::from)?;
+        sqlx::query(&format!("update iceberg_tables set metadata_location = '{metadata_file_location}', previous_metadata_location = '{previous_metadata_file_location}' where catalog_name = '{catalog_name}' and table_namespace = '{namespace}' and table_name = '{name}' and metadata_location = '{previous_metadata_file_location}';")).execute(&self.pool).await.map_err(Error::from)?;
 
         self.cache.write().unwrap().insert(
             identifier.clone(),
@@ -541,7 +541,7 @@ impl Catalog for SqlCatalog {
         let metadata_file_location = metadata_location.to_string();
         let previous_metadata_file_location = previous_metadata_location.to_string();
 
-        sqlx::query(&format!("update iceberg_tables set metadata_location = '{}', previous_metadata_location = '{}' where catalog_name = '{}' and table_namespace = '{}' and table_name = '{}' and metadata_location = '{}';", metadata_file_location, previous_metadata_file_location,catalog_name,namespace,name,previous_metadata_file_location)).execute(&self.pool).await.map_err(Error::from)?;
+        sqlx::query(&format!("update iceberg_tables set metadata_location = '{metadata_file_location}', previous_metadata_location = '{previous_metadata_file_location}' where catalog_name = '{catalog_name}' and table_namespace = '{namespace}' and table_name = '{name}' and metadata_location = '{previous_metadata_file_location}';")).execute(&self.pool).await.map_err(Error::from)?;
         self.cache.write().unwrap().insert(
             identifier.clone(),
             (metadata_location.clone(), metadata.clone()),
@@ -597,7 +597,7 @@ impl Catalog for SqlCatalog {
         let metadata_file_location = metadata_location.to_string();
         let previous_metadata_file_location = previous_metadata_location.to_string();
 
-        sqlx::query(&format!("update iceberg_tables set metadata_location = '{}', previous_metadata_location = '{}' where catalog_name = '{}' and table_namespace = '{}' and table_name = '{}' and metadata_location = '{}';", metadata_file_location, previous_metadata_file_location,catalog_name,namespace,name, previous_metadata_file_location)).execute(&self.pool).await.map_err(Error::from)?;
+        sqlx::query(&format!("update iceberg_tables set metadata_location = '{metadata_file_location}', previous_metadata_location = '{previous_metadata_file_location}' where catalog_name = '{catalog_name}' and table_namespace = '{namespace}' and table_name = '{name}' and metadata_location = '{previous_metadata_file_location}';")).execute(&self.pool).await.map_err(Error::from)?;
         self.cache.write().unwrap().insert(
             identifier.clone(),
             (metadata_location.clone(), metadata.clone()),
@@ -633,7 +633,7 @@ impl Catalog for SqlCatalog {
             let name = identifier.name().to_string();
             let metadata_location = metadata_location.to_string();
 
-            sqlx::query(&format!("insert into iceberg_tables (catalog_name, table_namespace, table_name, metadata_location) values ('{}', '{}', '{}', '{}');",catalog_name,namespace,name, metadata_location)).execute(&self.pool).await.map_err(Error::from)?;
+            sqlx::query(&format!("insert into iceberg_tables (catalog_name, table_namespace, table_name, metadata_location) values ('{catalog_name}', '{namespace}', '{name}', '{metadata_location}');")).execute(&self.pool).await.map_err(Error::from)?;
         }
         self.cache.write().unwrap().insert(
             identifier.clone(),
@@ -810,17 +810,14 @@ pub mod tests {
             .with_config("aws_secret_access_key".parse().unwrap(), "password")
             .with_config(
                 "endpoint".parse().unwrap(),
-                format!("http://{}:{}", localstack_host, localstack_port),
+                format!("http://{localstack_host}:{localstack_port}"),
             )
             .with_config("region".parse().unwrap(), "us-east-1")
             .with_config("allow_http".parse().unwrap(), "true");
 
         let iceberg_catalog = Arc::new(
             SqlCatalog::new(
-                &format!(
-                    "postgres://postgres:postgres@{}:{}/postgres",
-                    postgres_host, postgres_port
-                ),
+                &format!("postgres://postgres:postgres@{postgres_host}:{postgres_port}/postgres"),
                 "warehouse",
                 object_store,
             )
diff --git a/datafusion_iceberg/src/statistics.rs b/datafusion_iceberg/src/statistics.rs
@@ -165,7 +165,7 @@ fn convert_value_to_scalar_value(value: Value) -> Result<ScalarValue, Error> {
         )),
         x => Err(Error::Conversion(
             "Iceberg value".to_string(),
-            format!("{:?}", x),
+            format!("{x:?}"),
         )),
     }
 }
diff --git a/datafusion_iceberg/src/table.rs b/datafusion_iceberg/src/table.rs
@@ -318,7 +318,7 @@ fn fake_object_store_url(table_location_url: &str) -> Option<ObjectStoreUrl> {
         u.path()
             .as_bytes()
             .iter()
-            .map(|b| format!("{:02x}", b))
+            .map(|b| format!("{b:02x}"))
             .collect::<Vec<_>>()
             .join("")
     )))
diff --git a/datafusion_iceberg/tests/empty_insert.rs b/datafusion_iceberg/tests/empty_insert.rs
@@ -48,7 +48,7 @@ pub async fn test_empty_insert() {
         .with_config("aws_secret_access_key".parse().unwrap(), "password")
         .with_config(
             "endpoint".parse().unwrap(),
-            format!("http://{}:{}", localstack_host, localstack_port),
+            format!("http://{localstack_host}:{localstack_port}"),
         )
         .with_config("region".parse().unwrap(), "us-east-1")
         .with_config("allow_http".parse().unwrap(), "true");
diff --git a/datafusion_iceberg/tests/integration_trino.rs b/datafusion_iceberg/tests/integration_trino.rs
@@ -29,7 +29,7 @@ use tokio::time::sleep;
 
 fn configuration(host: &str, port: u16) -> Configuration {
     Configuration {
-        base_path: format!("http://{}:{}", host, port),
+        base_path: format!("http://{host}:{port}"),
         user_agent: None,
         client: reqwest::Client::new(),
         basic_auth: None,
@@ -63,7 +63,7 @@ async fn wait_for_worker(trino_container: &ContainerAsync<GenericImage>, timeout
         }
         tokio::time::sleep(Duration::from_millis(500)).await;
     }
-    panic!("Trino still not queryable after {:?}", timeout);
+    panic!("Trino still not queryable after {timeout:?}");
 }
 
 #[tokio::test]
@@ -130,17 +130,15 @@ async fn integration_trino_rest() {
     writeln!(tmp_file, "iceberg.catalog.type=rest").unwrap();
     writeln!(
         tmp_file,
-        "iceberg.rest-catalog.uri=http://{}:{}",
-        docker_host, rest_port
+        "iceberg.rest-catalog.uri=http://{docker_host}:{rest_port}"
     )
     .unwrap();
     writeln!(tmp_file, "iceberg.rest-catalog.warehouse=s3://warehouse/").unwrap();
     writeln!(tmp_file, "iceberg.file-format=PARQUET").unwrap();
     writeln!(tmp_file, "fs.native-s3.enabled=true").unwrap();
     writeln!(
         tmp_file,
-        "s3.endpoint=http://{}:{}",
-        docker_host, localstack_port
+        "s3.endpoint=http://{docker_host}:{localstack_port}"
     )
     .unwrap();
     writeln!(tmp_file, "s3.path-style-access=true").unwrap();
@@ -179,7 +177,7 @@ async fn integration_trino_rest() {
                 "iceberg",
                 "--file",
                 "/tmp/trino.sql",
-                &format!("http://{}:{}", docker_host, trino_port),
+                &format!("http://{docker_host}:{trino_port}"),
             ])
             .with_cmd_ready_condition(CmdWaitFor::exit_code(0)),
         )
@@ -191,7 +189,7 @@ async fn integration_trino_rest() {
         .with_config("aws_secret_access_key".parse().unwrap(), "password")
         .with_config(
             "endpoint".parse().unwrap(),
-            format!("http://{}:{}", localstack_host, localstack_port),
+            format!("http://{localstack_host}:{localstack_port}"),
         )
         .with_config("region".parse().unwrap(), "us-east-1")
         .with_config("allow_http".parse().unwrap(), "true");
@@ -294,7 +292,7 @@ async fn integration_trino_rest() {
                 "SELECT sum(amount) FROM iceberg.test.test_orders;",
                 "--output-format",
                 "NULL",
-                &format!("http://{}:{}", docker_host, trino_port),
+                &format!("http://{docker_host}:{trino_port}"),
             ])
             .with_cmd_ready_condition(CmdWaitFor::exit_code(0)),
         )
diff --git a/iceberg-rust-spec/src/arrow/schema.rs b/iceberg-rust-spec/src/arrow/schema.rs
@@ -172,8 +172,7 @@ impl TryFrom<&DataType> for Type {
                 element: Box::new(field.data_type().try_into()?),
             })),
             x => Err(Error::NotSupported(format!(
-                "Arrow datatype {} is not supported.",
-                x
+                "Arrow datatype {x} is not supported."
             ))),
         }
     }
diff --git a/iceberg-rust-spec/src/spec/identifier.rs b/iceberg-rust-spec/src/spec/identifier.rs
@@ -34,13 +34,11 @@ impl Identifier {
     pub fn try_new(names: &[String], default_namespace: Option<&[String]>) -> Result<Self, Error> {
         let mut parts = names.iter().rev();
         let table_name = parts.next().ok_or(Error::InvalidFormat(format!(
-            "Identifier {:?} is empty",
-            names
+            "Identifier {names:?} is empty"
         )))?;
         if table_name.is_empty() {
             return Err(Error::InvalidFormat(format!(
-                "Table name {:?} is empty",
-                table_name
+                "Table name {table_name:?} is empty"
             )));
         }
         let namespace: Vec<String> = parts.rev().map(ToOwned::to_owned).collect();
@@ -133,7 +131,7 @@ mod tests {
             None,
         )
         .unwrap();
-        assert_eq!(&format!("{}", identifier), "level1.level2.table");
+        assert_eq!(&format!("{identifier}"), "level1.level2.table");
     }
     #[test]
     #[should_panic]
@@ -152,6 +150,6 @@ mod tests {
     #[test]
     fn test_parse() {
         let identifier = Identifier::parse("level1.level2.table", None).unwrap();
-        assert_eq!(&format!("{}", identifier), "level1.level2.table");
+        assert_eq!(&format!("{identifier}"), "level1.level2.table");
     }
 }
diff --git a/iceberg-rust-spec/src/spec/manifest.rs b/iceberg-rust-spec/src/spec/manifest.rs
@@ -496,7 +496,7 @@ impl AvroMap<ByteBuf> {
                                 .get(k as usize)
                                 .ok_or(Error::ColumnNotInSchema(
                                     k.to_string(),
-                                    format!("{:?}", schema),
+                                    format!("{schema:?}"),
                                 ))?
                                 .field_type,
                         )?,
diff --git a/iceberg-rust-spec/src/spec/namespace.rs b/iceberg-rust-spec/src/spec/namespace.rs
@@ -36,8 +36,7 @@ impl Namespace {
             url::form_urlencoded::parse(namespace.as_bytes())
                 .next()
                 .ok_or(Error::InvalidFormat(format!(
-                    "Namespace {} is empty",
-                    namespace
+                    "Namespace {namespace} is empty"
                 )))?
                 .0
                 .split('\u{1F}')
@@ -78,7 +77,7 @@ mod tests {
             "level3".to_string(),
         ])
         .unwrap();
-        assert_eq!(&format!("{}", namespace), "level1.level2.level3");
+        assert_eq!(&format!("{namespace}"), "level1.level2.level3");
     }
     #[test]
     #[should_panic]
diff --git a/iceberg-rust-spec/src/spec/partition.rs b/iceberg-rust-spec/src/spec/partition.rs
@@ -133,8 +133,8 @@ impl Display for Transform {
             Transform::Month => write!(f, "month"),
             Transform::Day => write!(f, "day"),
             Transform::Hour => write!(f, "hour"),
-            Transform::Bucket(i) => write!(f, "bucket[{}]", i),
-            Transform::Truncate(i) => write!(f, "truncate[{}]", i),
+            Transform::Bucket(i) => write!(f, "bucket[{i}]"),
+            Transform::Truncate(i) => write!(f, "truncate[{i}]"),
             Transform::Void => write!(f, "void"),
         }
     }
diff --git a/iceberg-rust-spec/src/spec/types.rs b/iceberg-rust-spec/src/spec/types.rs
@@ -45,7 +45,7 @@ pub enum Type {
 impl fmt::Display for Type {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Type::Primitive(primitive) => write!(f, "{}", primitive),
+            Type::Primitive(primitive) => write!(f, "{primitive}"),
             Type::Struct(_) => write!(f, "struct"),
             Type::List(_) => write!(f, "list"),
             Type::Map(_) => write!(f, "map"),
diff --git a/iceberg-rust-spec/src/spec/values.rs b/iceberg-rust-spec/src/spec/values.rs
@@ -135,20 +135,20 @@ impl From<Value> for ByteBuf {
 impl fmt::Display for Value {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Value::Boolean(b) => write!(f, "{}", b),
-            Value::Int(i) => write!(f, "{}", i),
-            Value::LongInt(l) => write!(f, "{}", l),
-            Value::Float(fl) => write!(f, "{}", fl),
-            Value::Double(d) => write!(f, "{}", d),
-            Value::Date(d) => write!(f, "{}", d),
-            Value::Time(t) => write!(f, "{}", t),
-            Value::Timestamp(ts) => write!(f, "{}", ts),
-            Value::TimestampTZ(ts) => write!(f, "{}", ts),
-            Value::String(s) => write!(f, "{}", s),
-            Value::UUID(u) => write!(f, "{}", u),
-            Value::Fixed(size, data) => write!(f, "{:?} ({} bytes)", data, size),
+            Value::Boolean(b) => write!(f, "{b}"),
+            Value::Int(i) => write!(f, "{i}"),
+            Value::LongInt(l) => write!(f, "{l}"),
+            Value::Float(fl) => write!(f, "{fl}"),
+            Value::Double(d) => write!(f, "{d}"),
+            Value::Date(d) => write!(f, "{d}"),
+            Value::Time(t) => write!(f, "{t}"),
+            Value::Timestamp(ts) => write!(f, "{ts}"),
+            Value::TimestampTZ(ts) => write!(f, "{ts}"),
+            Value::String(s) => write!(f, "{s}"),
+            Value::UUID(u) => write!(f, "{u}"),
+            Value::Fixed(size, data) => write!(f, "{data:?} ({size} bytes)"),
             Value::Binary(data) => write!(f, "{:?} ({} bytes)", data, data.len()),
-            Value::Decimal(d) => write!(f, "{}", d),
+            Value::Decimal(d) => write!(f, "{d}"),
             _ => panic!("Printing of compound types is not supported"),
         }
     }
@@ -782,13 +782,13 @@ impl From<&Value> for JsonValue {
             Value::UUID(val) => JsonValue::String(val.to_string()),
             Value::Fixed(_, val) => {
                 JsonValue::String(val.iter().fold(String::new(), |mut acc, x| {
-                    acc.push_str(&format!("{:x}", x));
+                    acc.push_str(&format!("{x:x}"));
                     acc
                 }))
             }
             Value::Binary(val) => {
                 JsonValue::String(val.iter().fold(String::new(), |mut acc, x| {
-                    acc.push_str(&format!("{:x}", x));
+                    acc.push_str(&format!("{x:x}"));
                     acc
                 }))
             }
diff --git a/iceberg-rust/src/arrow/write.rs b/iceberg-rust/src/arrow/write.rs
diff --git a/iceberg-rust/src/object_store/mod.rs b/iceberg-rust/src/object_store/mod.rs
diff --git a/iceberg-rust/src/object_store/parse.rs b/iceberg-rust/src/object_store/parse.rs
diff --git a/iceberg-rust/src/table/manifest_list.rs b/iceberg-rust/src/table/manifest_list.rs
diff --git a/iceberg-rust/src/table/transaction/operation.rs b/iceberg-rust/src/table/transaction/operation.rs
diff --git a/iceberg-rust/src/util/mod.rs b/iceberg-rust/src/util/mod.rs
diff --git a/iceberg-rust/tests/overwrite_test.rs b/iceberg-rust/tests/overwrite_test.rs

Original file line number	Diff line number	Diff line change
`@@ -716,7 +716,7 @@ pub mod tests {`
`716`	`716`	`.with_config("aws_secret_access_key".parse().unwrap(), "password")`
`717`	`717`	`.with_config(`
`718`	`718`	`"endpoint".parse().unwrap(),`
`719`		`- format!("http://{}:{}", localstack_host, localstack_port),`
	`719`	`+ format!("http://{localstack_host}:{localstack_port}"),`
`720`	`720`	`)`
`721`	`721`	`.with_config("region".parse().unwrap(), "us-east-1")`
`722`	`722`	`.with_config("allow_http".parse().unwrap(), "true");`
Original file line number	Diff line number	Diff line change
`@@ -1067,7 +1067,7 @@ pub mod tests {`
`1067`	`1067`	`.with_config("aws_secret_access_key".parse().unwrap(), "password")`
`1068`	`1068`	`.with_config(`
`1069`	`1069`	`"endpoint".parse().unwrap(),`
`1070`		`- format!("http://{}:{}", localstack_host, localstack_port),`
	`1070`	`+ format!("http://{localstack_host}:{localstack_port}"),`
`1071`	`1071`	`)`
`1072`	`1072`	`.with_config("region".parse().unwrap(), "us-east-1")`
`1073`	`1073`	`.with_config("allow_http".parse().unwrap(), "true");`
Original file line number	Diff line number	Diff line change
`@@ -730,7 +730,7 @@ pub mod tests {`
`730`	`730`	`.with_config("aws_secret_access_key".parse().unwrap(), "password")`
`731`	`731`	`.with_config(`
`732`	`732`	`"endpoint".parse().unwrap(),`
`733`		`- format!("http://{}:{}", localstack_host, localstack_port),`
	`733`	`+ format!("http://{localstack_host}:{localstack_port}"),`
`734`	`734`	`)`
`735`	`735`	`.with_config("region".parse().unwrap(), "us-east-1")`
`736`	`736`	`.with_config("allow_http".parse().unwrap(), "true");`
Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ fn convert_value_to_scalar_value(value: Value) -> Result<ScalarValue, Error> {`
`165`	`165`	`)),`
`166`	`166`	`x => Err(Error::Conversion(`
`167`	`167`	`"Iceberg value".to_string(),`
`168`		`- format!("{:?}", x),`
	`168`	`+ format!("{x:?}"),`
`169`	`169`	`)),`
`170`	`170`	`}`
`171`	`171`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ pub async fn test_empty_insert() {`
`48`	`48`	`.with_config("aws_secret_access_key".parse().unwrap(), "password")`
`49`	`49`	`.with_config(`
`50`	`50`	`"endpoint".parse().unwrap(),`
`51`		`- format!("http://{}:{}", localstack_host, localstack_port),`
	`51`	`+ format!("http://{localstack_host}:{localstack_port}"),`
`52`	`52`	`)`
`53`	`53`	`.with_config("region".parse().unwrap(), "us-east-1")`
`54`	`54`	`.with_config("allow_http".parse().unwrap(), "true");`
Original file line number	Diff line number	Diff line change
`@@ -172,8 +172,7 @@ impl TryFrom<&DataType> for Type {`
`172`	`172`	`element: Box::new(field.data_type().try_into()?),`
`173`	`173`	`})),`
`174`	`174`	`x => Err(Error::NotSupported(format!(`
`175`		`- "Arrow datatype {} is not supported.",`
`176`		`- x`
	`175`	`+ "Arrow datatype {x} is not supported."`
`177`	`176`	`))),`
`178`	`177`	`}`
`179`	`178`	`}`