Rename DeltaColumn{Reader,Writer} to DeltaEncodedInt64Column{Reader,Writer}

Author: gibber9809

components/core/src/clp_s/ArchiveReader.cpp

@@ -189,7 +189,7 @@ BaseColumnReader* ArchiveReader::append_reader_column(SchemaReader& reader, int3
             column_reader = new Int64ColumnReader(column_id);
             break;
         case NodeType::DeltaInteger:
-            column_reader = new DeltaColumnReader(column_id);
+            column_reader = new DeltaEncodedInt64ColumnReader(column_id);
             break;
         case NodeType::Float:
             column_reader = new FloatColumnReader(column_id);
@@ -242,7 +242,7 @@ void ArchiveReader::append_unordered_reader_columns(
                 column_reader = new Int64ColumnReader(column_id);
                 break;
             case NodeType::DeltaInteger:
-                column_reader = new DeltaColumnReader(column_id);
+                column_reader = new DeltaEncodedInt64ColumnReader(column_id);
                 break;
             case NodeType::Float:
                 column_reader = new FloatColumnReader(column_id);

components/core/src/clp_s/ArchiveWriter.cpp

@@ -314,7 +314,7 @@ void ArchiveWriter::initialize_schema_writer(SchemaWriter* writer, Schema const&
                 writer->append_column(new DateStringColumnWriter(id));
                 break;
             case NodeType::DeltaInteger:
-                writer->append_column(new DeltaColumnWriter(id));
+                writer->append_column(new DeltaEncodedInt64ColumnWriter(id));
                 break;
             case NodeType::Metadata:
             case NodeType::NullValue:

components/core/src/clp_s/ColumnReader.cpp

@@ -16,15 +16,15 @@ std::variant<int64_t, double, std::string, uint8_t> Int64ColumnReader::extract_v
     return m_values[cur_message];
 }
 
-void DeltaColumnReader::load(BufferViewReader& reader, uint64_t num_messages) {
+void DeltaEncodedInt64ColumnReader::load(BufferViewReader& reader, uint64_t num_messages) {
     m_values = reader.read_unaligned_span<int64_t>(num_messages);
     if (num_messages > 0) {
         m_cur_idx = 0;
         m_cur_value = m_values[0];
     }
 }
 
-int64_t DeltaColumnReader::get_value_at_idx(size_t idx) {
+int64_t DeltaEncodedInt64ColumnReader::get_value_at_idx(size_t idx) {
     if (m_cur_idx == idx) {
         return m_cur_value;
     }
@@ -40,7 +40,7 @@ int64_t DeltaColumnReader::get_value_at_idx(size_t idx) {
     return m_cur_value;
 }
 
-std::variant<int64_t, double, std::string, uint8_t> DeltaColumnReader::extract_value(
+std::variant<int64_t, double, std::string, uint8_t> DeltaEncodedInt64ColumnReader::extract_value(
         uint64_t cur_message
 ) {
     return get_value_at_idx(cur_message);
@@ -55,8 +55,10 @@ Int64ColumnReader::extract_string_value_into_buffer(uint64_t cur_message, std::s
     buffer.append(std::to_string(m_values[cur_message]));
 }
 
-void
-DeltaColumnReader::extract_string_value_into_buffer(uint64_t cur_message, std::string& buffer) {
+void DeltaEncodedInt64ColumnReader::extract_string_value_into_buffer(
+        uint64_t cur_message,
+        std::string& buffer
+) {
     buffer.append(std::to_string(get_value_at_idx(cur_message)));
 }
 

components/core/src/clp_s/ColumnReader.hpp

@@ -91,13 +91,13 @@ class Int64ColumnReader : public BaseColumnReader {
     UnalignedMemSpan<int64_t> m_values;
 };
 
-class DeltaColumnReader : public BaseColumnReader {
+class DeltaEncodedInt64ColumnReader : public BaseColumnReader {
 public:
     // Constructor
-    explicit DeltaColumnReader(int32_t id) : BaseColumnReader(id) {}
+    explicit DeltaEncodedInt64ColumnReader(int32_t id) : BaseColumnReader(id) {}
 
     // Destructor
-    ~DeltaColumnReader() override = default;
+    ~DeltaEncodedInt64ColumnReader() override = default;
 
     // Methods inherited from BaseColumnReader
     void load(BufferViewReader& reader, uint64_t num_messages) override;

components/core/src/clp_s/ColumnWriter.cpp

@@ -11,7 +11,7 @@ void Int64ColumnWriter::store(ZstdCompressor& compressor) {
     compressor.write(reinterpret_cast<char const*>(m_values.data()), size);
 }
 
-size_t DeltaColumnWriter::add_value(ParsedMessage::variable_t& value) {
+size_t DeltaEncodedInt64ColumnWriter::add_value(ParsedMessage::variable_t& value) {
     if (0 == m_values.size()) {
         m_cur = std::get<int64_t>(value);
         m_values.push_back(m_cur);
@@ -23,7 +23,7 @@ size_t DeltaColumnWriter::add_value(ParsedMessage::variable_t& value) {
     return sizeof(int64_t);
 }
 
-void DeltaColumnWriter::store(ZstdCompressor& compressor) {
+void DeltaEncodedInt64ColumnWriter::store(ZstdCompressor& compressor) {
     size_t size = m_values.size() * sizeof(int64_t);
     compressor.write(reinterpret_cast<char const*>(m_values.data()), size);
 }

components/core/src/clp_s/ColumnWriter.hpp

@@ -63,13 +63,13 @@ class Int64ColumnWriter : public BaseColumnWriter {
     std::vector<int64_t> m_values;
 };
 
-class DeltaColumnWriter : public BaseColumnWriter {
+class DeltaEncodedInt64ColumnWriter : public BaseColumnWriter {
 public:
     // Constructor
-    explicit DeltaColumnWriter(int32_t id) : BaseColumnWriter(id) {}
+    explicit DeltaEncodedInt64ColumnWriter(int32_t id) : BaseColumnWriter(id) {}
 
     // Destructor
-    ~DeltaColumnWriter() override = default;
+    ~DeltaEncodedInt64ColumnWriter() override = default;
 
     // Methods inherited from BaseColumnWriter
     size_t add_value(ParsedMessage::variable_t& value) override;

components/core/src/clp_s/SchemaReader.cpp

@@ -31,7 +31,7 @@ void SchemaReader::mark_column_as_timestamp(BaseColumnReader* column_reader) {
         };
     } else if (m_timestamp_column->get_type() == NodeType::DeltaInteger) {
         m_get_timestamp = [this]() {
-            return std::get<int64_t>(static_cast<DeltaColumnReader*>(m_timestamp_column)
+            return std::get<int64_t>(static_cast<DeltaEncodedInt64ColumnReader*>(m_timestamp_column)
                                              ->extract_value(m_cur_message));
         };
     } else if (m_timestamp_column->get_type() == NodeType::Float) {

components/core/tests/test-clp_s-delta-encode-log-order.cpp

@@ -100,8 +100,8 @@ TEST_CASE("clp-s-delta-encode-log-order", "[clp-s][delta-encode-log-order]") {
     }
     REQUIRE(nullptr != log_event_idx_reader);
     REQUIRE(clp_s::NodeType::DeltaInteger == log_event_idx_reader->get_type());
-    REQUIRE(nullptr != dynamic_cast<clp_s::DeltaColumnReader*>(log_event_idx_reader));
-    // Test forwards and backwards seeks on `DeltaColumnReader`.
+    REQUIRE(nullptr != dynamic_cast<clp_s::DeltaEncodedInt64ColumnReader*>(log_event_idx_reader));
+    // Test forwards and backwards seeks on `DeltaEncodedInt64ColumnReader`.
     size_t i{start_index};
     for (size_t num_iterations{0ULL}; num_iterations < cNumEntries; ++num_iterations) {
         int64_t val{};