rename

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

dbms/CMakeLists.txt

@@ -104,7 +104,7 @@ check_then_add_sources_compile_flag (
  src/Columns/ColumnVector.cpp
  src/DataTypes/DataTypeString.cpp
  src/Interpreters/Join.cpp
- src/IO/Compression/CompressionCodecDelta.cpp
+ src/IO/Compression/CompressionCodecDeltaPFor.cpp
  src/Storages/DeltaMerge/BitmapFilter/BitmapFilter.cpp
  src/Storages/DeltaMerge/DMVersionFilterBlockInputStream.cpp
 )

dbms/src/IO/Compression/CompressionCodecDelta.cpp → dbms/src/IO/Compression/CompressionCodecDeltaPFor.cpp

@@ -15,7 +15,7 @@
 #include <Common/BitpackingPrimitives.h>
 #include <Common/Exception.h>
 #include <DataTypes/IDataType.h>
-#include <IO/Compression/CompressionCodecDelta.h>
+#include <IO/Compression/CompressionCodecDeltaPFor.h>
 #include <IO/Compression/CompressionInfo.h>
 #include <common/likely.h>
 #include <common/unaligned.h>
@@ -33,20 +33,20 @@ extern const int CANNOT_COMPRESS;
 extern const int CANNOT_DECOMPRESS;
 } // namespace ErrorCodes
 
-CompressionCodecDelta::CompressionCodecDelta(UInt8 delta_bytes_size_)
- : delta_bytes_size(delta_bytes_size_)
+CompressionCodecDeltaPFor::CompressionCodecDeltaPFor(UInt8 bytes_size_)
+ : bytes_size(bytes_size_)
 {}
 
-UInt8 CompressionCodecDelta::getMethodByte() const
+UInt8 CompressionCodecDeltaPFor::getMethodByte() const
 {
- return static_cast<UInt8>(CompressionMethodByte::Delta);
+ return static_cast<UInt8>(CompressionMethodByte::DeltaPFor);
 }
 
-UInt32 CompressionCodecDelta::getMaxCompressedDataSize(UInt32 uncompressed_size) const
+UInt32 CompressionCodecDeltaPFor::getMaxCompressedDataSize(UInt32 uncompressed_size) const
 {
- // 1 byte for delta_bytes_size, x bytes for frame of reference, 1 byte for width.
- return 1 + delta_bytes_size + sizeof(UInt8)
- + BitpackingPrimitives::getRequiredSize(uncompressed_size / delta_bytes_size, delta_bytes_size * 8);
+ // 1 byte for bytes_size, x bytes for frame of reference, 1 byte for width.
+ return 1 + bytes_size + sizeof(UInt8)
+ + BitpackingPrimitives::getRequiredSize(uncompressed_size / bytes_size, bytes_size * 8);
 }
 
 namespace
@@ -85,7 +85,12 @@ UInt32 compressData(const char * source, UInt32 source_size, char * dest)
  if (width == 0)
  return sizeof(ST) + sizeof(UInt8);
  auto required_size = BitpackingPrimitives::getRequiredSize(count, width);
- BitpackingPrimitives::packBuffer(reinterpret_cast<unsigned char *>(dest), deltas.data(), count, width);
+ // after applying frame of reference, all deltas are bigger than 0.
+ BitpackingPrimitives::packBuffer(
+ reinterpret_cast<unsigned char *>(dest),
+ reinterpret_cast<const T *>(deltas.data()),
+ count,
+ width);
  return sizeof(ST) + sizeof(UInt8) + required_size;
 }
 
@@ -226,7 +231,7 @@ void PForDecode(const char * source, UInt32 source_size, unsigned char * dest, U
  source += sizeof(UInt8);
  const auto required_size = source_size - sizeof(ST) - sizeof(UInt8);
  RUNTIME_CHECK(BitpackingPrimitives::getRequiredSize(count, width) == required_size);
- BitpackingPrimitives::unPackBuffer<ST>(dest, reinterpret_cast<const unsigned char *>(source), count, width);
+ BitpackingPrimitives::unPackBuffer<T>(dest, reinterpret_cast<const unsigned char *>(source), count, width);
  ApplyFrameOfReference(reinterpret_cast<ST *>(dest), frame_of_reference, count);
 }
 
@@ -268,17 +273,13 @@ void decompressData<UInt64>(const char * source, UInt32 source_size, char * dest
 
 } // namespace
 
-UInt32 CompressionCodecDelta::doCompressData(const char * source, UInt32 source_size, char * dest) const
+UInt32 CompressionCodecDeltaPFor::doCompressData(const char * source, UInt32 source_size, char * dest) const
 {
- if unlikely (source_size % delta_bytes_size != 0)
- throw Exception(
- ErrorCodes::CANNOT_DECOMPRESS,
- "source size {} is not aligned to {}",
- source_size,
- delta_bytes_size);
- dest[0] = delta_bytes_size;
+ if unlikely (source_size % bytes_size != 0)
+ throw Exception(ErrorCodes::CANNOT_DECOMPRESS, "source size {} is not aligned to {}", source_size, bytes_size);
+ dest[0] = bytes_size;
  size_t start_pos = 1;
- switch (delta_bytes_size)
+ switch (bytes_size)
  {
  case 1:
  return 1 + compressData<UInt8>(source, source_size, &dest[start_pos]);
@@ -293,7 +294,7 @@ UInt32 CompressionCodecDelta::doCompressData(const char * source, UInt32 source_
  }
 }
 
-void CompressionCodecDelta::doDecompressData(
+void CompressionCodecDeltaPFor::doDecompressData(
  const char * source,
  UInt32 source_size,
  char * dest,
@@ -333,7 +334,11 @@ void CompressionCodecDelta::doDecompressData(
  }
 }
 
-void CompressionCodecDelta::ordinaryDecompress(const char * source, UInt32 source_size, char * dest, UInt32 dest_size)
+void CompressionCodecDeltaPFor::ordinaryDecompress(
+ const char * source,
+ UInt32 source_size,
+ char * dest,
+ UInt32 dest_size)
 {
  if unlikely (source_size < 2)
  throw Exception(ErrorCodes::CANNOT_DECOMPRESS, "Cannot decompress delta-encoded data. File has wrong header");

dbms/src/IO/Compression/CompressionCodecDelta.h → dbms/src/IO/Compression/CompressionCodecDeltaPFor.h

@@ -19,10 +19,10 @@
 namespace DB
 {
 
-class CompressionCodecDelta : public ICompressionCodec
+class CompressionCodecDeltaPFor : public ICompressionCodec
 {
 public:
- explicit CompressionCodecDelta(UInt8 delta_bytes_size_);
+ explicit CompressionCodecDeltaPFor(UInt8 bytes_size_);
 
  UInt8 getMethodByte() const override;
 
@@ -42,7 +42,7 @@ class CompressionCodecDelta : public ICompressionCodec
  bool isGenericCompression() const override { return false; }
 
 private:
- const UInt8 delta_bytes_size;
+ const UInt8 bytes_size;
 };
 
 } // namespace DB

dbms/src/IO/Compression/CompressionFactory.h

@@ -15,7 +15,7 @@
 #pragma once
 
 #include <Common/config.h>
-#include <IO/Compression/CompressionCodecDelta.h>
+#include <IO/Compression/CompressionCodecDeltaPFor.h>
 #include <IO/Compression/CompressionCodecLZ4.h>
 #include <IO/Compression/CompressionCodecMultiple.h>
 #include <IO/Compression/CompressionCodecNone.h>
@@ -57,8 +57,8 @@ class CompressionFactory
  }
  switch (setting.method_byte)
  {
- case CompressionMethodByte::Delta:
- return std::make_unique<CompressionCodecDelta>(setting.type_bytes_size);
+ case CompressionMethodByte::DeltaPFor:
+ return std::make_unique<CompressionCodecDeltaPFor>(setting.type_bytes_size);
  case CompressionMethodByte::RLE:
  return std::make_unique<CompressionCodecRLE>(setting.type_bytes_size);
  case CompressionMethodByte::NONE:

dbms/src/IO/Compression/CompressionInfo.h

@@ -57,7 +57,7 @@ enum class CompressionMethodByte : UInt8
  QPL = 0x88,
  ZSTD = 0x90,
  Multiple = 0x91,
- Delta  = 0x92,
+ DeltaPFor = 0x92,
  RLE = 0x93,
  // COL_END is not a compreesion method, but a flag of column end used in compact file.
  COL_END = 0x66,

dbms/src/IO/Compression/CompressionSettings.h

@@ -38,7 +38,7 @@ const std::unordered_map<CompressionMethodByte, CompressionMethod> method_map =
  {CompressionMethodByte::ZSTD, CompressionMethod::ZSTD},
  {CompressionMethodByte::QPL, CompressionMethod::QPL},
  {CompressionMethodByte::NONE, CompressionMethod::NONE},
- {CompressionMethodByte::Delta, CompressionMethod::NONE},
+ {CompressionMethodByte::DeltaPFor, CompressionMethod::NONE},
  {CompressionMethodByte::RLE, CompressionMethod::NONE},
 };
 

dbms/src/IO/Compression/tests/bench_codec_delta.cpp

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 #include <Core/Defines.h>
-#include <IO/Compression/CompressionCodecDelta.h>
+#include <IO/Compression/CompressionCodecDeltaPFor.h>
 #include <benchmark/benchmark.h>
 
 #include <vector>
@@ -27,7 +27,7 @@ static void codecDeltaOrdinaryBM(benchmark::State & state)
  std::vector<T> v(DEFAULT_MERGE_BLOCK_SIZE);
  for (auto & i : v)
  i = random();
- CompressionCodecDelta codec(sizeof(T));
+ CompressionCodecDeltaPFor codec(sizeof(T));
  char dest[sizeof(T) * DEFAULT_MERGE_BLOCK_SIZE + 1];
  for (auto _ : state)
  {
@@ -52,7 +52,7 @@ static void codecDeltaSpecializedUInt64BM(benchmark::State & state)
  std::vector<UInt64> v(DEFAULT_MERGE_BLOCK_SIZE);
  for (auto & i : v)
  i = random();
- CompressionCodecDelta codec(sizeof(UInt64));
+ CompressionCodecDeltaPFor codec(sizeof(UInt64));
  char dest[sizeof(UInt64) * DEFAULT_MERGE_BLOCK_SIZE + 1];
  for (auto _ : state)
  {
@@ -67,7 +67,7 @@ static void codecDeltaSpecializedUInt32BM(benchmark::State & state)
  std::vector<UInt32> v(DEFAULT_MERGE_BLOCK_SIZE);
  for (auto & i : v)
  i = random();
- CompressionCodecDelta codec(sizeof(UInt32));
+ CompressionCodecDeltaPFor codec(sizeof(UInt32));
  char dest[sizeof(UInt32) * DEFAULT_MERGE_BLOCK_SIZE + 1];
  for (auto _ : state)
  {

dbms/src/IO/Compression/tests/gtest_codec_compression.cpp

@@ -523,7 +523,7 @@ std::vector<CodecTestSequence> generatePyramidOfSequences(
 #define G(generator) generator, #generator
 
 const auto IntegerCodecsToTest = ::testing::Values(
- CompressionMethodByte::Delta,
+ CompressionMethodByte::DeltaPFor,
  CompressionMethodByte::RLE
 #if USE_QPL
  ,