use gread instead of streaming api

Author: xiao.dong

src/iceberg/table_metadata.cc

@@ -154,68 +154,40 @@ Result<MetadataFileCodecType> TableMetadataUtil::CodecFromFileName(
   return MetadataFileCodecType::kNone;
 }
 
-class GZipDecompressor {
- public:
-  GZipDecompressor() : initialized_(false) {}
-
-  ~GZipDecompressor() {
-    if (initialized_) {
-      inflateEnd(&stream_);
-    }
+Result<std::string> DecompressGZIPFile(const std::string& filepath) {
+  gzFile file = gzopen(filepath.c_str(), "rb");
+  if (!file) {
+    return IOError("Failed to open gzip file:{} ", filepath);
   }
 
-  Status Init() {
-    int ret = inflateInit2(&stream_, 15 + 32);
-    if (ret != Z_OK) {
-      return IOError("inflateInit2 failed, result:{}", ret);
-    }
-    initialized_ = true;
-    return {};
+  const int CHUNK_SIZE = 32768;  // 32KB chunks
+  char buffer[CHUNK_SIZE];
+  std::string result;
+  int bytes_read;
+
+  while ((bytes_read = gzread(file, buffer, CHUNK_SIZE)) > 0) {
+    result.append(buffer, bytes_read);
   }
 
-  Result<std::string> Decompress(const std::string& compressed_data) {
-    if (compressed_data.empty()) {
-      return {};
-    }
-    if (!initialized_) {
-      ICEBERG_RETURN_UNEXPECTED(Init());
-    }
-    stream_.avail_in = static_cast<uInt>(compressed_data.size());
-    stream_.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(compressed_data.data()));
-
-    // TODO(xiao.dong) magic buffer 16k, can we get a estimated size from compressed data?
-    std::vector<char> outBuffer(32 * 1024);
-    std::string result;
-    int ret = 0;
-    do {
-      outBuffer.resize(outBuffer.size());
-      stream_.avail_out = static_cast<uInt>(outBuffer.size());
-      stream_.next_out = reinterpret_cast<Bytef*>(outBuffer.data());
-      ret = inflate(&stream_, Z_NO_FLUSH);
-      if (ret != Z_OK && ret != Z_STREAM_END) {
-        return IOError("inflate failed, result:{}", ret);
-      }
-      result.append(outBuffer.data(), outBuffer.size() - stream_.avail_out);
-    } while (ret != Z_STREAM_END);
-    return result;
+  int err;
+  const char* error_msg = gzerror(file, &err);
+  if (err != Z_OK) {
+    gzclose(file);
+    return IOError("Error during gzip decompression:{} ", std::string(error_msg));
   }
 
- private:
-  bool initialized_ = false;
-  z_stream stream_;
-};
+  gzclose(file);
+  return result;
+}
 
 Result<std::unique_ptr<TableMetadata>> TableMetadataUtil::Read(
     FileIO& io, const std::string& location, std::optional<size_t> length) {
   ICEBERG_ASSIGN_OR_RAISE(auto codec_type, CodecFromFileName(location));
-
-  ICEBERG_ASSIGN_OR_RAISE(auto content, io.ReadFile(location, length));
+  std::string content;
   if (codec_type == MetadataFileCodecType::kGzip) {
-    auto gzip_decompressor = std::make_unique<GZipDecompressor>();
-    ICEBERG_RETURN_UNEXPECTED(gzip_decompressor->Init());
-    auto result = gzip_decompressor->Decompress(content);
-    ICEBERG_RETURN_UNEXPECTED(result);
-    content = result.value();
+    ICEBERG_ASSIGN_OR_RAISE(content, DecompressGZIPFile(location));
+  } else {
+    ICEBERG_ASSIGN_OR_RAISE(content, io.ReadFile(location, length));
   }
 
   ICEBERG_ASSIGN_OR_RAISE(auto json, FromJsonString(content));