fix

Signed-off-by: Lloyd-Pottiger <yan1579196623@gmail.com>

dbms/src/IO/Compression/CompressionCodecFactory.cpp

@@ -141,7 +141,7 @@ CompressionCodecPtr CompressionCodecFactory::create(const CompressionSetting & s
     if constexpr (!IS_DECOMPRESS)
     {
         if (setting.data_type == CompressionDataType::String || setting.data_type == CompressionDataType::Float32
-            || setting.data_type == CompressionDataType::Float64)
+            || setting.data_type == CompressionDataType::Float64 || setting.data_type == CompressionDataType::Unknown)
             return getStaticCodec<CompressionCodecLZ4>(setting);
     }
 

dbms/src/IO/Compression/CompressionCodecLightweight.cpp

@@ -69,6 +69,7 @@ UInt32 CompressionCodecLightweight::doCompressData(const char * source, UInt32 s
     case CompressionDataType::Float32:
     case CompressionDataType::Float64:
     case CompressionDataType::String:
+    case CompressionDataType::Unknown:
         return 1 + compressDataForNonInteger(source, source_size, dest);
     default:
         throw Exception(
@@ -118,6 +119,7 @@ void CompressionCodecLightweight::doDecompressData(
     case CompressionDataType::Float32:
     case CompressionDataType::Float64:
     case CompressionDataType::String:
+    case CompressionDataType::Unknown:
         decompressDataForNonInteger(&source[1], source_size_no_header, dest, uncompressed_size);
         break;
     default:

dbms/src/IO/Compression/CompressionCodecLightweight_Integer.cpp

@@ -141,8 +141,8 @@ void CompressionCodecLightweight::IntegerCompressContext::analyze(std::span<cons
     {
         // Check CONSTANT_DELTA
 
-        // If values.size() == 1, mode will be CONSTANT_DELTA
-        // so values.size() must be greater than 1 here.
+        // If values.size() == 1, mode will be CONSTANT
+        // so values.size() must be greater than 1 here and deltas must be non empty.
         deltas.reserve(values.size() - 1);
         for (size_t i = 1; i < values.size(); ++i)
         {

dbms/src/IO/Compression/CompressionCodecRunLength.cpp

@@ -73,8 +73,8 @@ UInt32 CompressionCodecRunLength::compressDataForInteger(const char * source, UI
 
     if (DB::Compression::runLengthPairsByteSize<T>(rle_vec) >= source_size)
     {
-        // treat as string
-        dest[0] = magic_enum::enum_integer(CompressionDataType::String);
+        // treat as unknown data type, and compress as LZ4
+        dest[0] = magic_enum::enum_integer(CompressionDataType::Unknown);
         dest += 1;
         auto success = LZ4_compress_fast(
             source,
@@ -141,10 +141,15 @@ void CompressionCodecRunLength::doDecompressData(
     case CompressionDataType::Int64:
         DB::Compression::runLengthDecoding<UInt64>(&source[1], source_size - 1, dest, uncompressed_size);
         break;
-    default:
+    case CompressionDataType::Unknown:
         if (unlikely(LZ4_decompress_safe(&source[1], dest, source_size - 1, uncompressed_size) < 0))
             throw Exception("Cannot LZ4_decompress_safe", ErrorCodes::CANNOT_DECOMPRESS);
         break;
+    default:
+        throw Exception(
+            ErrorCodes::CANNOT_DECOMPRESS,
+            "Cannot decompress RunLength-encoded data. Unknown data type {}",
+            bytes_size);
     }
 }
 

dbms/src/IO/Compression/CompressionInfo.h

@@ -68,6 +68,7 @@ enum class CompressionMethodByte : UInt8
 
 enum class CompressionDataType : UInt8
 {
+    Unknown = 0,
     // These enum values are used to represent the number of bytes of the type
     Int8 = 1, // Int8/UInt8
     Int16 = 2, // Int16/UInt16

dbms/src/IO/Compression/CompressionSettings.cpp

@@ -66,14 +66,14 @@ CompressionSetting CompressionSetting::create(T method, int level, const IDataTy
         if (data_type.has_value())
             setting.data_type = data_type.value();
         else
-            setting.data_type = CompressionDataType::String;
+            setting.data_type = CompressionDataType::Unknown;
     }
     else if (type.isFloatingPoint() && type.getSizeOfValueInMemory() == 4)
         setting.data_type = CompressionDataType::Float32;
     else if (type.isFloatingPoint() && type.getSizeOfValueInMemory() == 8)
         setting.data_type = CompressionDataType::Float64;
     else
-        setting.data_type = CompressionDataType::String;
+        setting.data_type = CompressionDataType::Unknown;
     setting.level = level;
     return setting;
 }

dbms/src/IO/Compression/CompressionSettings.h

@@ -49,32 +49,33 @@ const std::unordered_map<CompressionMethodByte, CompressionMethod> method_map =
 struct CompressionSetting
 {
     CompressionMethod method;
-    CompressionMethodByte method_byte;
     int level;
     // The type of data to be compressed.
-    // I
-    CompressionDataType data_type = CompressionDataType::String;
+    // It may be used to determine the codec to use.
+    CompressionDataType data_type = CompressionDataType::Unknown;
+    // Always use method_byte to determine the codec to use except for LZ4HC codec
+    CompressionMethodByte method_byte;
 
     CompressionSetting()
         : CompressionSetting(CompressionMethod::LZ4)
     {}
 
     explicit CompressionSetting(CompressionMethod method_)
         : method(method_)
-        , method_byte(method_byte_map[static_cast<size_t>(method_)])
         , level(getDefaultLevel(method))
+        , method_byte(method_byte_map[static_cast<size_t>(method_)])
     {}
 
     explicit CompressionSetting(CompressionMethodByte method_byte_)
         : method(method_map.at(method_byte_))
-        , method_byte(method_byte_)
         , level(getDefaultLevel(method))
+        , method_byte(method_byte_)
     {}
 
     CompressionSetting(CompressionMethod method_, int level_)
         : method(method_)
-        , method_byte(method_byte_map[static_cast<size_t>(method_)])
         , level(level_)
+        , method_byte(method_byte_map[static_cast<size_t>(method_)])
     {}
 
     explicit CompressionSetting(const Settings & settings);