You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iceberg.apache.org by li...@apache.org on 2026/03/31 09:58:17 UTC

(iceberg-rust) branch main updated: feat!: Enhance compression codec enum. (#2288)

This is an automated email from the ASF dual-hosted git repository.

liurenjie1024 pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/iceberg-rust.git


The following commit(s) were added to refs/heads/main by this push:
     new d8011a0c7 feat!: Enhance compression codec enum. (#2288)
d8011a0c7 is described below

commit d8011a0c75e84711f54608c7f13cc79e8ec2fa65
Author: emkornfield <em...@gmail.com>
AuthorDate: Tue Mar 31 02:58:13 2026 -0700

    feat!: Enhance compression codec enum. (#2288)
    
    ## Which issue does this PR close?
    
    This is an intermediate PR for #1731
    
    I'm splitting out changes from
    https://github.com/apache/iceberg-rust/pull/1851 to the compression
    codec to make it easier to review. Once we decide on approach here and
    merge it I'll update https://github.com/apache/iceberg-rust/pull/1851
    accordingly.
    
    ## What changes are included in this PR?
    
    - Add optional compression level to gzip and zstd (needed for when avro
    compression usage).
    - Add Snappy as a compression codec (also will be used for Avro)
    - Manually code up some previously auto-generated methods as a result.
    
    AI helped with an initial version of this PR.
    
    ## Are these changes tested?
    
    Additional unit tests
---
 crates/iceberg/src/catalog/metadata_location.rs |  21 +++-
 crates/iceberg/src/compression.rs               | 150 ++++++++++++++++++++----
 crates/iceberg/src/puffin/metadata.rs           |   5 +-
 crates/iceberg/src/puffin/mod.rs                |  39 +++---
 crates/iceberg/src/puffin/reader.rs             |   4 +-
 crates/iceberg/src/puffin/test_utils.rs         |   4 +-
 crates/iceberg/src/puffin/writer.rs             |  11 +-
 crates/iceberg/src/spec/table_metadata.rs       |   6 +-
 crates/iceberg/src/spec/table_properties.rs     |  24 ++--
 9 files changed, 191 insertions(+), 73 deletions(-)

diff --git a/crates/iceberg/src/catalog/metadata_location.rs b/crates/iceberg/src/catalog/metadata_location.rs
index ed2811887..acd041d5e 100644
--- a/crates/iceberg/src/catalog/metadata_location.rs
+++ b/crates/iceberg/src/catalog/metadata_location.rs
@@ -114,9 +114,9 @@ impl MetadataLocation {
         ))?;
 
         // Check for compression suffix (e.g., .gz)
-        let gzip_suffix = CompressionCodec::Gzip.suffix()?;
+        let gzip_suffix = CompressionCodec::gzip_default().suffix()?;
         let (stripped, compression_codec) = if let Some(s) = stripped.strip_suffix(gzip_suffix) {
-            (s, CompressionCodec::Gzip)
+            (s, CompressionCodec::gzip_default())
         } else {
             (stripped, CompressionCodec::None)
         };
@@ -261,7 +261,7 @@ mod test {
                     table_location: "/abc".to_string(),
                     version: 1234567,
                     id: Uuid::from_str("2cd22b57-5127-4198-92ba-e4e67c79821b").unwrap(),
-                    compression_codec: CompressionCodec::Gzip,
+                    compression_codec: CompressionCodec::gzip_default(),
                 }),
             ),
             // Negative version
@@ -345,10 +345,16 @@ mod test {
             "/test/table/metadata/00005-81056704-ce5b-41c4-bb83-eb6408081af6.gz.metadata.json",
         )
         .unwrap();
-        assert_eq!(location_gzip.compression_codec, CompressionCodec::Gzip);
+        assert_eq!(
+            location_gzip.compression_codec,
+            CompressionCodec::gzip_default()
+        );
 
         let next_gzip = location_gzip.with_next_version();
-        assert_eq!(next_gzip.compression_codec, CompressionCodec::Gzip);
+        assert_eq!(
+            next_gzip.compression_codec,
+            CompressionCodec::gzip_default()
+        );
         assert_eq!(next_gzip.version, 6);
     }
 
@@ -369,7 +375,10 @@ mod test {
         );
         let metadata_gzip = create_test_metadata(props_gzip);
         let updated_gzip = location.with_new_metadata(&metadata_gzip);
-        assert_eq!(updated_gzip.compression_codec, CompressionCodec::Gzip);
+        assert_eq!(
+            updated_gzip.compression_codec,
+            CompressionCodec::gzip_default()
+        );
         assert_eq!(updated_gzip.version, 0);
         assert_eq!(
             updated_gzip.to_string(),
diff --git a/crates/iceberg/src/compression.rs b/crates/iceberg/src/compression.rs
index 42f529843..929d9226e 100644
--- a/crates/iceberg/src/compression.rs
+++ b/crates/iceberg/src/compression.rs
@@ -17,28 +17,101 @@
 
 //! Compression codec support for data compression and decompression.
 
+use std::fmt;
 use std::io::{Read, Write};
 
 use flate2::Compression;
 use flate2::read::GzDecoder;
 use flate2::write::GzEncoder;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use crate::{Error, ErrorKind, Result};
 
+/// Default compression level for Zstandard (zstd).
+const ZSTD_DEFAULT_LEVEL: u8 = 3;
+/// Default compression level for Gzip.
+const GZIP_DEFAULT_LEVEL: u8 = 6;
+/// Maximum compression level for Gzip.
+const GZIP_MAX_LEVEL: u8 = 9;
+
 /// Data compression formats
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Default, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Default)]
 pub enum CompressionCodec {
     #[default]
     /// No compression
     None,
     /// LZ4 single compression frame with content size present
     Lz4,
-    /// Zstandard single compression frame with content size present
-    Zstd,
-    /// Gzip compression
-    Gzip,
+    /// Zstandard single compression frame with content size present.
+    /// Level range is 0–22, where 0 means default compression level (not no compression).
+    /// Use [`CompressionCodec::zstd_default`] to construct with the default level.
+    Zstd(u8),
+    /// Gzip compression. Level range is 0–9, where 0 means no compression.
+    /// Use [`CompressionCodec::gzip_default`] to construct with the default level.
+    Gzip(u8),
+    /// Snappy compression
+    Snappy,
+}
+
+impl CompressionCodec {
+    /// Returns a Zstd codec with the default compression level.
+    pub const fn zstd_default() -> Self {
+        CompressionCodec::Zstd(ZSTD_DEFAULT_LEVEL)
+    }
+
+    /// Returns a Gzip codec with the default compression level.
+    pub const fn gzip_default() -> Self {
+        CompressionCodec::Gzip(GZIP_DEFAULT_LEVEL)
+    }
+
+    /// Returns the codec name as used in serialization and error messages.
+    pub fn name(&self) -> &'static str {
+        match self {
+            CompressionCodec::None => "none",
+            CompressionCodec::Lz4 => "lz4",
+            CompressionCodec::Zstd(_) => "zstd",
+            CompressionCodec::Gzip(_) => "gzip",
+            CompressionCodec::Snappy => "snappy",
+        }
+    }
+}
+
+// Note: serialize/deserialize do not round-trip the compression level. Iceberg configuration
+// only the codec name (e.g. "zstd"), not the level, so deserialization always produces the
+// default level. A `Zstd(5)` written to metadata will be read back as `Zstd(3)`. Some
+// compression configuration (e.g. Avro metadata) has a separate level field alongside the codec name.
+impl Serialize for CompressionCodec {
+    fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
+        serializer.serialize_str(self.name())
+    }
+}
+
+impl<'de> Deserialize<'de> for CompressionCodec {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> std::result::Result<Self, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        match s.to_lowercase().as_str() {
+            "none" => Ok(CompressionCodec::None),
+            "lz4" => Ok(CompressionCodec::Lz4),
+            "zstd" => Ok(CompressionCodec::zstd_default()),
+            "gzip" => Ok(CompressionCodec::gzip_default()),
+            "snappy" => Ok(CompressionCodec::Snappy),
+            other => Err(serde::de::Error::unknown_variant(other, &[
+                "none", "lz4", "zstd", "gzip", "snappy",
+            ])),
+        }
+    }
+}
+
+impl fmt::Display for CompressionCodec {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            CompressionCodec::None => write!(f, "None"),
+            CompressionCodec::Lz4 => write!(f, "Lz4"),
+            CompressionCodec::Zstd(level) => write!(f, "Zstd(level={level})"),
+            CompressionCodec::Gzip(level) => write!(f, "Gzip(level={level})"),
+            CompressionCodec::Snappy => write!(f, "Snappy"),
+        }
+    }
 }
 
 impl CompressionCodec {
@@ -49,13 +122,17 @@ impl CompressionCodec {
                 ErrorKind::FeatureUnsupported,
                 "LZ4 decompression is not supported currently",
             )),
-            CompressionCodec::Zstd => Ok(zstd::stream::decode_all(&bytes[..])?),
-            CompressionCodec::Gzip => {
+            CompressionCodec::Zstd(_) => Ok(zstd::stream::decode_all(&bytes[..])?),
+            CompressionCodec::Gzip(_) => {
                 let mut decoder = GzDecoder::new(&bytes[..]);
                 let mut decompressed = Vec::new();
                 decoder.read_to_end(&mut decompressed)?;
                 Ok(decompressed)
             }
+            CompressionCodec::Snappy => Err(Error::new(
+                ErrorKind::FeatureUnsupported,
+                "Snappy decompression is not supported currently",
+            )),
         }
     }
 
@@ -66,19 +143,24 @@ impl CompressionCodec {
                 ErrorKind::FeatureUnsupported,
                 "LZ4 compression is not supported currently",
             )),
-            CompressionCodec::Zstd => {
+            CompressionCodec::Zstd(level) => {
                 let writer = Vec::<u8>::new();
-                let mut encoder = zstd::stream::Encoder::new(writer, 3)?;
+                let mut encoder = zstd::stream::Encoder::new(writer, *level as i32)?;
                 encoder.include_checksum(true)?;
                 encoder.set_pledged_src_size(Some(bytes.len().try_into()?))?;
                 std::io::copy(&mut &bytes[..], &mut encoder)?;
                 Ok(encoder.finish()?)
             }
-            CompressionCodec::Gzip => {
-                let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
+            CompressionCodec::Gzip(level) => {
+                let compression = Compression::new((*level).min(GZIP_MAX_LEVEL) as u32);
+                let mut encoder = GzEncoder::new(Vec::new(), compression);
                 encoder.write_all(&bytes)?;
                 Ok(encoder.finish()?)
             }
+            CompressionCodec::Snappy => Err(Error::new(
+                ErrorKind::FeatureUnsupported,
+                "Snappy compression is not supported currently",
+            )),
         }
     }
 
@@ -95,8 +177,10 @@ impl CompressionCodec {
     pub fn suffix(&self) -> Result<&'static str> {
         match self {
             CompressionCodec::None => Ok(""),
-            CompressionCodec::Gzip => Ok(".gz"),
-            codec @ (CompressionCodec::Lz4 | CompressionCodec::Zstd) => Err(Error::new(
+            CompressionCodec::Gzip(_) => Ok(".gz"),
+            codec @ (CompressionCodec::Lz4
+            | CompressionCodec::Zstd(_)
+            | CompressionCodec::Snappy) => Err(Error::new(
                 ErrorKind::FeatureUnsupported,
                 format!("suffix not defined for {codec:?}"),
             )),
@@ -123,7 +207,10 @@ mod tests {
     async fn test_compression_codec_compress() {
         let bytes_vec = [0_u8; 100].to_vec();
 
-        let compression_codecs = [CompressionCodec::Zstd, CompressionCodec::Gzip];
+        let compression_codecs = [
+            CompressionCodec::zstd_default(),
+            CompressionCodec::gzip_default(),
+        ];
 
         for codec in compression_codecs {
             let compressed = codec.compress(bytes_vec.clone()).unwrap();
@@ -135,7 +222,10 @@ mod tests {
 
     #[tokio::test]
     async fn test_compression_codec_unsupported() {
-        let unsupported_codecs = [(CompressionCodec::Lz4, "LZ4")];
+        let unsupported_codecs = [
+            (CompressionCodec::Lz4, "LZ4"),
+            (CompressionCodec::Snappy, "Snappy"),
+        ];
         let bytes_vec = [0_u8; 100].to_vec();
 
         for (codec, name) in unsupported_codecs {
@@ -153,18 +243,34 @@ mod tests {
 
     #[test]
     fn test_suffix() {
-        // Test supported codecs
         assert_eq!(CompressionCodec::None.suffix().unwrap(), "");
-        assert_eq!(CompressionCodec::Gzip.suffix().unwrap(), ".gz");
+        assert_eq!(CompressionCodec::gzip_default().suffix().unwrap(), ".gz");
 
-        // Test unsupported codecs return errors
         assert!(CompressionCodec::Lz4.suffix().is_err());
-        assert!(CompressionCodec::Zstd.suffix().is_err());
+        assert!(CompressionCodec::zstd_default().suffix().is_err());
+        assert!(CompressionCodec::Snappy.suffix().is_err());
 
         let lz4_err = CompressionCodec::Lz4.suffix().unwrap_err();
         assert!(lz4_err.to_string().contains("suffix not defined for Lz4"));
 
-        let zstd_err = CompressionCodec::Zstd.suffix().unwrap_err();
+        let zstd_err = CompressionCodec::zstd_default().suffix().unwrap_err();
         assert!(zstd_err.to_string().contains("suffix not defined for Zstd"));
     }
+
+    #[test]
+    fn test_display() {
+        assert_eq!(CompressionCodec::None.to_string(), "None");
+        assert_eq!(CompressionCodec::Lz4.to_string(), "Lz4");
+        assert_eq!(
+            CompressionCodec::zstd_default().to_string(),
+            "Zstd(level=3)"
+        );
+        assert_eq!(CompressionCodec::Zstd(5).to_string(), "Zstd(level=5)");
+        assert_eq!(
+            CompressionCodec::gzip_default().to_string(),
+            "Gzip(level=6)"
+        );
+        assert_eq!(CompressionCodec::Gzip(9).to_string(), "Gzip(level=9)");
+        assert_eq!(CompressionCodec::Snappy.to_string(), "Snappy");
+    }
 }
diff --git a/crates/iceberg/src/puffin/metadata.rs b/crates/iceberg/src/puffin/metadata.rs
index 1d39cf249..e2dfc10c2 100644
--- a/crates/iceberg/src/puffin/metadata.rs
+++ b/crates/iceberg/src/puffin/metadata.rs
@@ -985,6 +985,9 @@ mod tests {
         assert!(result.is_ok());
         let metadata = result.unwrap();
         assert_eq!(metadata.blobs.len(), 1);
-        assert_eq!(metadata.blobs[0].compression_codec, CompressionCodec::Gzip);
+        assert_eq!(
+            metadata.blobs[0].compression_codec,
+            CompressionCodec::gzip_default()
+        );
     }
 }
diff --git a/crates/iceberg/src/puffin/mod.rs b/crates/iceberg/src/puffin/mod.rs
index 854d4070f..0e054cac5 100644
--- a/crates/iceberg/src/puffin/mod.rs
+++ b/crates/iceberg/src/puffin/mod.rs
@@ -26,30 +26,22 @@ pub use blob::{APACHE_DATASKETCHES_THETA_V1, Blob, DELETION_VECTOR_V1};
 
 pub use crate::compression::CompressionCodec;
 
-/// Compression codecs supported by the Puffin spec.
-const SUPPORTED_PUFFIN_CODECS: &[CompressionCodec] = &[
-    CompressionCodec::None,
-    CompressionCodec::Lz4,
-    CompressionCodec::Zstd,
-];
-
 /// Validates that the compression codec is supported for Puffin files.
 /// Returns an error if the codec is not supported.
 fn validate_puffin_compression(codec: CompressionCodec) -> Result<()> {
-    if !SUPPORTED_PUFFIN_CODECS.contains(&codec) {
-        let supported_names: Vec<String> = SUPPORTED_PUFFIN_CODECS
-            .iter()
-            .map(|c| format!("{c:?}"))
-            .collect();
-        return Err(Error::new(
+    match codec {
+        CompressionCodec::None | CompressionCodec::Lz4 | CompressionCodec::Zstd(_) => Ok(()),
+        other => Err(Error::new(
             ErrorKind::DataInvalid,
             format!(
-                "Compression codec {codec:?} is not supported for Puffin files. Only {} are supported.",
-                supported_names.join(", ")
+                "Compression codec {} is not supported for Puffin files. Only {}, {}, and {} are supported.",
+                other.name(),
+                CompressionCodec::None.name(),
+                CompressionCodec::Lz4.name(),
+                CompressionCodec::zstd_default().name()
             ),
-        ));
+        )),
     }
-    Ok(())
 }
 
 mod metadata;
@@ -70,12 +62,13 @@ mod tests {
 
     #[test]
     fn test_puffin_codec_validation() {
-        // All codecs in SUPPORTED_PUFFIN_CODECS should be valid
-        for codec in SUPPORTED_PUFFIN_CODECS {
-            assert!(validate_puffin_compression(*codec).is_ok());
-        }
+        // Supported codecs
+        assert!(validate_puffin_compression(CompressionCodec::None).is_ok());
+        assert!(validate_puffin_compression(CompressionCodec::Lz4).is_ok());
+        assert!(validate_puffin_compression(CompressionCodec::zstd_default()).is_ok());
+        assert!(validate_puffin_compression(CompressionCodec::Zstd(5)).is_ok());
 
-        // Gzip should not be supported for Puffin files
-        assert!(validate_puffin_compression(CompressionCodec::Gzip).is_err());
+        // Unsupported codecs
+        assert!(validate_puffin_compression(CompressionCodec::gzip_default()).is_err());
     }
 }
diff --git a/crates/iceberg/src/puffin/reader.rs b/crates/iceberg/src/puffin/reader.rs
index d272f02d4..0aced4186 100644
--- a/crates/iceberg/src/puffin/reader.rs
+++ b/crates/iceberg/src/puffin/reader.rs
@@ -144,7 +144,7 @@ mod tests {
             sequence_number: 1,
             offset: 4,
             length: 10,
-            compression_codec: CompressionCodec::Gzip,
+            compression_codec: CompressionCodec::gzip_default(),
             properties: HashMap::new(),
         };
 
@@ -153,7 +153,7 @@ mod tests {
         assert!(result.is_err());
         let err = result.unwrap_err();
         assert_eq!(err.kind(), ErrorKind::DataInvalid);
-        assert!(err.to_string().contains("Gzip"));
+        assert!(err.to_string().contains("gzip"));
         assert!(
             err.to_string()
                 .contains("is not supported for Puffin files")
diff --git a/crates/iceberg/src/puffin/test_utils.rs b/crates/iceberg/src/puffin/test_utils.rs
index 39fecc6f8..e0844e200 100644
--- a/crates/iceberg/src/puffin/test_utils.rs
+++ b/crates/iceberg/src/puffin/test_utils.rs
@@ -77,7 +77,7 @@ pub(crate) fn zstd_compressed_metric_blob_0_metadata() -> BlobMetadata {
         sequence_number: METRIC_BLOB_0_SEQUENCE_NUMBER,
         offset: 4,
         length: 22,
-        compression_codec: CompressionCodec::Zstd,
+        compression_codec: CompressionCodec::zstd_default(),
         properties: HashMap::new(),
     }
 }
@@ -134,7 +134,7 @@ pub(crate) fn zstd_compressed_metric_blob_1_metadata() -> BlobMetadata {
         sequence_number: METRIC_BLOB_1_SEQUENCE_NUMBER,
         offset: 26,
         length: 77,
-        compression_codec: CompressionCodec::Zstd,
+        compression_codec: CompressionCodec::zstd_default(),
         properties: HashMap::new(),
     }
 }
diff --git a/crates/iceberg/src/puffin/writer.rs b/crates/iceberg/src/puffin/writer.rs
index 30b97f09d..4af4970b0 100644
--- a/crates/iceberg/src/puffin/writer.rs
+++ b/crates/iceberg/src/puffin/writer.rs
@@ -251,7 +251,8 @@ mod tests {
     async fn test_write_zstd_compressed_metric_data() {
         let temp_dir = TempDir::new().unwrap();
         let blobs = vec![blob_0(), blob_1()];
-        let blobs_with_compression = blobs_with_compression(blobs.clone(), CompressionCodec::Zstd);
+        let blobs_with_compression =
+            blobs_with_compression(blobs.clone(), CompressionCodec::zstd_default());
 
         let input_file = write_puffin_file(&temp_dir, blobs_with_compression, file_properties())
             .await
@@ -323,7 +324,8 @@ mod tests {
     async fn test_zstd_compressed_metric_data_is_bit_identical_to_java_generated_file() {
         let temp_dir = TempDir::new().unwrap();
         let blobs = vec![blob_0(), blob_1()];
-        let blobs_with_compression = blobs_with_compression(blobs, CompressionCodec::Zstd);
+        let blobs_with_compression =
+            blobs_with_compression(blobs, CompressionCodec::zstd_default());
 
         assert_files_are_bit_identical(
             write_puffin_file(&temp_dir, blobs_with_compression, file_properties())
@@ -338,14 +340,15 @@ mod tests {
     async fn test_gzip_compression_rejected() {
         let temp_dir = TempDir::new().unwrap();
         let blobs = vec![blob_0()];
-        let blobs_with_compression = blobs_with_compression(blobs, CompressionCodec::Gzip);
+        let blobs_with_compression =
+            blobs_with_compression(blobs, CompressionCodec::gzip_default());
 
         let result = write_puffin_file(&temp_dir, blobs_with_compression, file_properties()).await;
 
         assert!(result.is_err());
         let err = result.unwrap_err();
         assert_eq!(err.kind(), ErrorKind::DataInvalid);
-        assert!(err.to_string().contains("Gzip"));
+        assert!(err.to_string().contains("gzip"));
         assert!(
             err.to_string()
                 .contains("is not supported for Puffin files")
diff --git a/crates/iceberg/src/spec/table_metadata.rs b/crates/iceberg/src/spec/table_metadata.rs
index f16ee1a6a..607fd9835 100644
--- a/crates/iceberg/src/spec/table_metadata.rs
+++ b/crates/iceberg/src/spec/table_metadata.rs
@@ -460,7 +460,7 @@ impl TableMetadata {
             && metadata_content[0] == 0x1F
             && metadata_content[1] == 0x8B
         {
-            let decompressed_data = CompressionCodec::Gzip
+            let decompressed_data = CompressionCodec::gzip_default()
                 .decompress(metadata_content.to_vec())
                 .map_err(|e| {
                     Error::new(
@@ -502,7 +502,7 @@ impl TableMetadata {
 
         // Apply compression based on codec
         let data_to_write = match codec {
-            CompressionCodec::Gzip => codec.compress(json_data)?,
+            CompressionCodec::Gzip(_) => codec.compress(json_data)?,
             CompressionCodec::None => json_data,
             _ => {
                 return Err(Error::new(
@@ -3633,7 +3633,7 @@ mod tests {
         let original_metadata: TableMetadata = get_test_table_metadata("TableMetadataV2Valid.json");
         let json = serde_json::to_string(&original_metadata).unwrap();
 
-        let compressed = CompressionCodec::Gzip
+        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");
diff --git a/crates/iceberg/src/spec/table_properties.rs b/crates/iceberg/src/spec/table_properties.rs
index 07c157304..a3d4e7fda 100644
--- a/crates/iceberg/src/spec/table_properties.rs
+++ b/crates/iceberg/src/spec/table_properties.rs
@@ -78,18 +78,22 @@ pub(crate) fn parse_metadata_file_compression(
         Error::new(
             ErrorKind::DataInvalid,
             format!(
-                "Invalid metadata compression codec: {value}. Only 'none' and 'gzip' are supported."
+                "Invalid metadata compression codec: {value}. Only '{}' and '{}' are supported.",
+                CompressionCodec::None.name(),
+                CompressionCodec::gzip_default().name()
             ),
         )
     })?;
 
     // Validate that only None and Gzip are used for metadata
     match codec {
-        CompressionCodec::None | CompressionCodec::Gzip => Ok(codec),
-        CompressionCodec::Lz4 | CompressionCodec::Zstd => Err(Error::new(
+        CompressionCodec::None | CompressionCodec::Gzip(_) => Ok(codec),
+        _ => Err(Error::new(
             ErrorKind::DataInvalid,
             format!(
-                "Invalid metadata compression codec: {value}. Only 'none' and 'gzip' are supported for metadata files."
+                "Invalid metadata compression codec: {value}. Only '{}' and '{}' are supported for metadata files.",
+                CompressionCodec::None.name(),
+                CompressionCodec::gzip_default().name()
             ),
         )),
     }
@@ -324,7 +328,7 @@ mod tests {
         let table_properties = TableProperties::try_from(&props).unwrap();
         assert_eq!(
             table_properties.metadata_compression_codec,
-            CompressionCodec::Gzip
+            CompressionCodec::gzip_default()
         );
     }
 
@@ -351,7 +355,7 @@ mod tests {
         let table_properties = TableProperties::try_from(&props_upper).unwrap();
         assert_eq!(
             table_properties.metadata_compression_codec,
-            CompressionCodec::Gzip
+            CompressionCodec::gzip_default()
         );
 
         // Test mixed case
@@ -362,7 +366,7 @@ mod tests {
         let table_properties = TableProperties::try_from(&props_mixed).unwrap();
         assert_eq!(
             table_properties.metadata_compression_codec,
-            CompressionCodec::Gzip
+            CompressionCodec::gzip_default()
         );
 
         // Test "NONE" should also be case-insensitive
@@ -517,7 +521,7 @@ mod tests {
         )]);
         assert_eq!(
             parse_metadata_file_compression(&props).unwrap(),
-            CompressionCodec::Gzip
+            CompressionCodec::gzip_default()
         );
 
         // Test case insensitivity - "NONE"
@@ -537,7 +541,7 @@ mod tests {
         )]);
         assert_eq!(
             parse_metadata_file_compression(&props).unwrap(),
-            CompressionCodec::Gzip
+            CompressionCodec::gzip_default()
         );
 
         // Test case insensitivity - "GzIp"
@@ -547,7 +551,7 @@ mod tests {
         )]);
         assert_eq!(
             parse_metadata_file_compression(&props).unwrap(),
-            CompressionCodec::Gzip
+            CompressionCodec::gzip_default()
         );
 
         // Test default when property is missing