column_chunk.h

Go to the documentation of this file.

#pragma once
 
#include "column_chunk_data.h"
#include "update_info.h"
 
namespace kuzu {
namespace storage {
 
struct ChunkCheckpointState {
    std::unique_ptr<ColumnChunkData> chunkData;
    common::row_idx_t startRow;
    common::length_t numRows;
 
    ChunkCheckpointState(std::unique_ptr<ColumnChunkData> chunkData, common::row_idx_t startRow,
        common::length_t numRows)
        : chunkData{std::move(chunkData)}, startRow{startRow}, numRows{numRows} {}
};
 
struct ColumnCheckpointState {
    ColumnChunkData& persistentData;
    std::vector<ChunkCheckpointState> chunkCheckpointStates;
    common::row_idx_t maxRowIdxToWrite;
 
    ColumnCheckpointState(ColumnChunkData& persistentData,
        std::vector<ChunkCheckpointState> chunkCheckpointStates)
        : persistentData{persistentData}, chunkCheckpointStates{std::move(chunkCheckpointStates)},
          maxRowIdxToWrite{0} {
        for (const auto& chunkCheckpointState : this->chunkCheckpointStates) {
            const auto endRowIdx = chunkCheckpointState.startRow + chunkCheckpointState.numRows;
            if (endRowIdx > maxRowIdxToWrite) {
                maxRowIdxToWrite = endRowIdx;
            }
        }
    }
};
 
class ColumnChunk {
public:
    ColumnChunk(const common::LogicalType& dataType, uint64_t capacity, bool enableCompression,
        ResidencyState residencyState);
    ColumnChunk(const common::LogicalType& dataType, bool enableCompression,
        ColumnChunkMetadata metadata);
    ColumnChunk(bool enableCompression, std::unique_ptr<ColumnChunkData> data);
 
    void initializeScanState(ChunkState& state) const;
    void scan(const transaction::Transaction* transaction, const ChunkState& state,
        common::ValueVector& nodeID, common::ValueVector& output, common::offset_t offsetInChunk,
        common::length_t length) const;
    template<ResidencyState SCAN_RESIDENCY_STATE>
    void scanCommitted(transaction::Transaction* transaction, ChunkState& chunkState,
        ColumnChunk& output, common::row_idx_t startRow = 0,
        common::row_idx_t numRows = common::INVALID_ROW_IDX) const;
    void lookup(transaction::Transaction* transaction, const ChunkState& state,
        common::offset_t rowInChunk, common::ValueVector& output,
        common::sel_t posInOutputVector) const;
    void update(const transaction::Transaction* transaction, common::offset_t offsetInChunk,
        const common::ValueVector& values);
 
    uint64_t getEstimatedMemoryUsage() const {
        return getResidencyState() == ResidencyState::ON_DISK ? 0 : data->getEstimatedMemoryUsage();
    }
    void serialize(common::Serializer& serializer) const;
    static std::unique_ptr<ColumnChunk> deserialize(common::Deserializer& deSer);
 
    uint64_t getNumValues() const { return data->getNumValues(); }
    void setNumValues(const uint64_t numValues) const { data->setNumValues(numValues); }
 
    common::row_idx_t getNumUpdatedRows(const transaction::Transaction* transaction) const;
 
    std::pair<std::unique_ptr<ColumnChunk>, std::unique_ptr<ColumnChunk>> scanUpdates(
        const transaction::Transaction* transaction) const;
 
    void setData(std::unique_ptr<ColumnChunkData> data) { this->data = std::move(data); }
    // Functions to access the in memory data.
    ColumnChunkData& getData() const { return *data; }
    const ColumnChunkData& getConstData() const { return *data; }
    std::unique_ptr<ColumnChunkData> moveData() { return std::move(data); }
 
    common::LogicalType& getDataType() { return data->getDataType(); }
    const common::LogicalType& getDataType() const { return data->getDataType(); }
    bool isCompressionEnabled() const { return enableCompression; }
 
    ResidencyState getResidencyState() const { return data->getResidencyState(); }
    bool hasUpdates() const { return updateInfo != nullptr; }
    bool hasUpdates(const transaction::Transaction* transaction, common::row_idx_t startRow,
        common::length_t numRows) const;
    // These functions should only work on in-memory and temporary column chunks.
    void resetToEmpty() const { data->resetToEmpty(); }
    void resetToAllNull() const { data->resetToAllNull(); }
    void resize(uint64_t newSize) const { data->resize(newSize); }
    void resetUpdateInfo() {
        if (updateInfo) {
            updateInfo.reset();
        }
    }
 
private:
    void scanCommittedUpdates(const transaction::Transaction* transaction, ColumnChunkData& output,
        common::offset_t startOffsetInOutput, common::row_idx_t startRowScanned,
        common::row_idx_t numRows) const;
 
private:
    // TODO(Guodong): This field should be removed. Ideally it shouldn't be cached anywhere in
    // storage structures, instead should be fed into functions needed from ClientContext dbConfig.
    bool enableCompression;
    std::unique_ptr<ColumnChunkData> data;
    // Update versions.
    std::unique_ptr<UpdateInfo> updateInfo;
};
 
} // namespace storage
} // namespace kuzu