ceph/src/arrow/cpp/src/arrow/util/compression.cc

   1 // Licensed to the Apache Software Foundation (ASF) under one
   2 // or more contributor license agreements.  See the NOTICE file
   3 // distributed with this work for additional information
   4 // regarding copyright ownership.  The ASF licenses this file
   5 // to you under the Apache License, Version 2.0 (the
   6 // "License"); you may not use this file except in compliance
   7 // with the License.  You may obtain a copy of the License at
   8 //
   9 //   http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing,
  12 // software distributed under the License is distributed on an
  13 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  14 // KIND, either express or implied.  See the License for the
  15 // specific language governing permissions and limitations
  16 // under the License.
  17
  18 #include "arrow/util/compression.h"
  19
  20 #include <memory>
  21 #include <string>
  22 #include <utility>
  23
  24 #include "arrow/result.h"
  25 #include "arrow/status.h"
  26 #include "arrow/util/compression_internal.h"
  27 #include "arrow/util/logging.h"
  28
  29 namespace arrow {
  30 namespace util {
  31
  32 namespace {
  33
  34 Status CheckSupportsCompressionLevel(Compression::type type) {
  35   if (!Codec::SupportsCompressionLevel(type)) {
  36     return Status::Invalid(
  37         "The specified codec does not support the compression level parameter");
  38   }
  39   return Status::OK();
  40 }
  41
  42 }  // namespace
  43
  44 int Codec::UseDefaultCompressionLevel() { return kUseDefaultCompressionLevel; }
  45
  46 Status Codec::Init() { return Status::OK(); }
  47
  48 const std::string& Codec::GetCodecAsString(Compression::type t) {
  49   static const std::string uncompressed = "uncompressed", snappy = "snappy",
  50                            gzip = "gzip", lzo = "lzo", brotli = "brotli",
  51                            lz4_raw = "lz4_raw", lz4 = "lz4", lz4_hadoop = "lz4_hadoop",
  52                            zstd = "zstd", bz2 = "bz2", unknown = "unknown";
  53
  54   switch (t) {
  55     case Compression::UNCOMPRESSED:
  56       return uncompressed;
  57     case Compression::SNAPPY:
  58       return snappy;
  59     case Compression::GZIP:
  60       return gzip;
  61     case Compression::LZO:
  62       return lzo;
  63     case Compression::BROTLI:
  64       return brotli;
  65     case Compression::LZ4:
  66       return lz4_raw;
  67     case Compression::LZ4_FRAME:
  68       return lz4;
  69     case Compression::LZ4_HADOOP:
  70       return lz4_hadoop;
  71     case Compression::ZSTD:
  72       return zstd;
  73     case Compression::BZ2:
  74       return bz2;
  75     default:
  76       return unknown;
  77   }
  78 }
  79
  80 Result<Compression::type> Codec::GetCompressionType(const std::string& name) {
  81   if (name == "uncompressed") {
  82     return Compression::UNCOMPRESSED;
  83   } else if (name == "gzip") {
  84     return Compression::GZIP;
  85   } else if (name == "snappy") {
  86     return Compression::SNAPPY;
  87   } else if (name == "lzo") {
  88     return Compression::LZO;
  89   } else if (name == "brotli") {
  90     return Compression::BROTLI;
  91   } else if (name == "lz4_raw") {
  92     return Compression::LZ4;
  93   } else if (name == "lz4") {
  94     return Compression::LZ4_FRAME;
  95   } else if (name == "lz4_hadoop") {
  96     return Compression::LZ4_HADOOP;
  97   } else if (name == "zstd") {
  98     return Compression::ZSTD;
  99   } else if (name == "bz2") {
 100     return Compression::BZ2;
 101   } else {
 102     return Status::Invalid("Unrecognized compression type: ", name);
 103   }
 104 }
 105
 106 bool Codec::SupportsCompressionLevel(Compression::type codec) {
 107   switch (codec) {
 108     case Compression::GZIP:
 109     case Compression::BROTLI:
 110     case Compression::ZSTD:
 111     case Compression::BZ2:
 112       return true;
 113     default:
 114       return false;
 115   }
 116 }
 117
 118 Result<int> Codec::MaximumCompressionLevel(Compression::type codec_type) {
 119   RETURN_NOT_OK(CheckSupportsCompressionLevel(codec_type));
 120   ARROW_ASSIGN_OR_RAISE(auto codec, Codec::Create(codec_type));
 121   return codec->maximum_compression_level();
 122 }
 123
 124 Result<int> Codec::MinimumCompressionLevel(Compression::type codec_type) {
 125   RETURN_NOT_OK(CheckSupportsCompressionLevel(codec_type));
 126   ARROW_ASSIGN_OR_RAISE(auto codec, Codec::Create(codec_type));
 127   return codec->minimum_compression_level();
 128 }
 129
 130 Result<int> Codec::DefaultCompressionLevel(Compression::type codec_type) {
 131   RETURN_NOT_OK(CheckSupportsCompressionLevel(codec_type));
 132   ARROW_ASSIGN_OR_RAISE(auto codec, Codec::Create(codec_type));
 133   return codec->default_compression_level();
 134 }
 135
 136 Result<std::unique_ptr<Codec>> Codec::Create(Compression::type codec_type,
 137                                              int compression_level) {
 138   if (!IsAvailable(codec_type)) {
 139     if (codec_type == Compression::LZO) {
 140       return Status::NotImplemented("LZO codec not implemented");
 141     }
 142
 143     auto name = GetCodecAsString(codec_type);
 144     if (name == "unknown") {
 145       return Status::Invalid("Unrecognized codec");
 146     }
 147
 148     return Status::NotImplemented("Support for codec '", GetCodecAsString(codec_type),
 149                                   "' not built");
 150   }
 151
 152   if (compression_level != kUseDefaultCompressionLevel &&
 153       !SupportsCompressionLevel(codec_type)) {
 154     return Status::Invalid("Codec '", GetCodecAsString(codec_type),
 155                            "' doesn't support setting a compression level.");
 156   }
 157
 158   std::unique_ptr<Codec> codec;
 159   switch (codec_type) {
 160     case Compression::UNCOMPRESSED:
 161       return nullptr;
 162     case Compression::SNAPPY:
 163 #ifdef ARROW_WITH_SNAPPY
 164       codec = internal::MakeSnappyCodec();
 165 #endif
 166       break;
 167     case Compression::GZIP:
 168 #ifdef ARROW_WITH_ZLIB
 169       codec = internal::MakeGZipCodec(compression_level);
 170 #endif
 171       break;
 172     case Compression::BROTLI:
 173 #ifdef ARROW_WITH_BROTLI
 174       codec = internal::MakeBrotliCodec(compression_level);
 175 #endif
 176       break;
 177     case Compression::LZ4:
 178 #ifdef ARROW_WITH_LZ4
 179       codec = internal::MakeLz4RawCodec();
 180 #endif
 181       break;
 182     case Compression::LZ4_FRAME:
 183 #ifdef ARROW_WITH_LZ4
 184       codec = internal::MakeLz4FrameCodec();
 185 #endif
 186       break;
 187     case Compression::LZ4_HADOOP:
 188 #ifdef ARROW_WITH_LZ4
 189       codec = internal::MakeLz4HadoopRawCodec();
 190 #endif
 191       break;
 192     case Compression::ZSTD:
 193 #ifdef ARROW_WITH_ZSTD
 194       codec = internal::MakeZSTDCodec(compression_level);
 195 #endif
 196       break;
 197     case Compression::BZ2:
 198 #ifdef ARROW_WITH_BZ2
 199       codec = internal::MakeBZ2Codec(compression_level);
 200 #endif
 201       break;
 202     default:
 203       break;
 204   }
 205
 206   DCHECK_NE(codec, nullptr);
 207   RETURN_NOT_OK(codec->Init());
 208   return std::move(codec);
 209 }
 210
 211 bool Codec::IsAvailable(Compression::type codec_type) {
 212   switch (codec_type) {
 213     case Compression::UNCOMPRESSED:
 214       return true;
 215     case Compression::SNAPPY:
 216 #ifdef ARROW_WITH_SNAPPY
 217       return true;
 218 #else
 219       return false;
 220 #endif
 221     case Compression::GZIP:
 222 #ifdef ARROW_WITH_ZLIB
 223       return true;
 224 #else
 225       return false;
 226 #endif
 227     case Compression::LZO:
 228       return false;
 229     case Compression::BROTLI:
 230 #ifdef ARROW_WITH_BROTLI
 231       return true;
 232 #else
 233       return false;
 234 #endif
 235     case Compression::LZ4:
 236     case Compression::LZ4_FRAME:
 237     case Compression::LZ4_HADOOP:
 238 #ifdef ARROW_WITH_LZ4
 239       return true;
 240 #else
 241       return false;
 242 #endif
 243     case Compression::ZSTD:
 244 #ifdef ARROW_WITH_ZSTD
 245       return true;
 246 #else
 247       return false;
 248 #endif
 249     case Compression::BZ2:
 250 #ifdef ARROW_WITH_BZ2
 251       return true;
 252 #else
 253       return false;
 254 #endif
 255     default:
 256       return false;
 257   }
 258 }
 259
 260 }  // namespace util
 261 }  // namespace arrow