refactor: unexpected compression algo

Author: Devdutt Shenoi

server/src/cli.rs

@@ -423,7 +423,7 @@ impl Cli {
              .arg(
                  // RowGroupSize controls the number of rows present in one row group
                  // More rows = better compression but HIGHER Memory consumption during read/write
-                 // 1048576 is the default value for DataFusion 
+                 // 1048576 is the default value for DataFusion
                  Arg::new(Self::ROW_GROUP_SIZE)
                      .long(Self::ROW_GROUP_SIZE)
                      .env("P_PARQUET_ROW_GROUP_SIZE")
@@ -591,20 +591,12 @@ impl FromArgMatches for Cli {
             .get_one::<usize>(Self::ROW_GROUP_SIZE)
             .cloned()
             .expect("default for row_group size");
-        self.parquet_compression = match m
+        self.parquet_compression = m
             .get_one::<String>(Self::PARQUET_COMPRESSION_ALGO)
             .expect("default for compression algo")
             .as_str()
-        {
-            "uncompressed" => Compression::UNCOMPRESSED,
-            "snappy" => Compression::SNAPPY,
-            "gzip" => Compression::GZIP,
-            "lzo" => Compression::LZO,
-            "brotli" => Compression::BROTLI,
-            "lz4" => Compression::LZ4,
-            "zstd" => Compression::ZSTD,
-            _ => unreachable!(),
-        };
+            .try_into()
+            .expect("valid compression algorithm");
 
         let openid_client_id = m.get_one::<String>(Self::OPENID_CLIENT_ID).cloned();
         let openid_client_secret = m.get_one::<String>(Self::OPENID_CLIENT_SECRET).cloned();

server/src/option.rs

@@ -254,28 +254,49 @@ pub enum Mode {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-#[allow(non_camel_case_types, clippy::upper_case_acronyms)]
 pub enum Compression {
-    UNCOMPRESSED,
-    SNAPPY,
-    GZIP,
-    LZO,
-    BROTLI,
+    Uncompressed,
+    Snappy,
+    Gzip,
+    Lzo,
+    Brotli,
     #[default]
-    LZ4,
-    ZSTD,
+    Lz4,
+    Zstd,
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("Unexpected compression algorithm: {0:?}")]
+pub struct UnexpectedAlgo<'a>(&'a str);
+
+impl<'a> TryFrom<&'a str> for Compression {
+    type Error = UnexpectedAlgo<'a>;
+    fn try_from(value: &'a str) -> Result<Self, Self::Error> {
+        let algo = match value {
+            "uncompressed" => Self::Uncompressed,
+            "snappy" => Self::Snappy,
+            "gzip" => Self::Gzip,
+            "lzo" => Self::Lzo,
+            "brotli" => Self::Brotli,
+            "lz4" => Self::Lz4,
+            "zstd" => Self::Zstd,
+            s => return Err(UnexpectedAlgo(s)),
+        };
+
+        Ok(algo)
+    }
 }
 
 impl From<Compression> for parquet::basic::Compression {
     fn from(value: Compression) -> Self {
         match value {
-            Compression::UNCOMPRESSED => parquet::basic::Compression::UNCOMPRESSED,
-            Compression::SNAPPY => parquet::basic::Compression::SNAPPY,
-            Compression::GZIP => parquet::basic::Compression::GZIP(GzipLevel::default()),
-            Compression::LZO => parquet::basic::Compression::LZO,
-            Compression::BROTLI => parquet::basic::Compression::BROTLI(BrotliLevel::default()),
-            Compression::LZ4 => parquet::basic::Compression::LZ4,
-            Compression::ZSTD => parquet::basic::Compression::ZSTD(ZstdLevel::default()),
+            Compression::Uncompressed => parquet::basic::Compression::UNCOMPRESSED,
+            Compression::Snappy => parquet::basic::Compression::SNAPPY,
+            Compression::Gzip => parquet::basic::Compression::GZIP(GzipLevel::default()),
+            Compression::Lzo => parquet::basic::Compression::LZO,
+            Compression::Brotli => parquet::basic::Compression::BROTLI(BrotliLevel::default()),
+            Compression::Lz4 => parquet::basic::Compression::LZ4,
+            Compression::Zstd => parquet::basic::Compression::ZSTD(ZstdLevel::default()),
         }
     }
 }