Method split

src/storage/table/column_chunk_data.cpp:1055–1088

}

std::vector<std::unique_ptr<ColumnChunkData>> ColumnChunkData::split(bool targetMaxSize) const {
    // FIXME(bmwinger): we either need to split recursively, or detect individual values which bring
    // the size above MAX_SEGMENT_SIZE, since this will still sometimes produce segments larger than
    // MAX_SEGMENT_SIZE
    auto maxSegmentSize = std::max(getMinimumSizeOnDisk(), common::StorageConfig::MAX_SEGMENT_SIZE);
    auto targetSize =
        targetMaxSize ? maxSegmentSize : std::min(getSizeOnDisk() / 2, maxSegmentSize);
    std::vector<std::unique_ptr<ColumnChunkData>> newSegments;
    uint64_t pos = 0;
    const uint64_t chunkSize = 64;
    uint64_t initialCapacity = std::min(chunkSize, numValues);
    while (pos < numValues) {
        std::unique_ptr<ColumnChunkData> newSegment =
            ColumnChunkFactory::createColumnChunkData(getMemoryManager(), getDataType().copy(),
                isCompressionEnabled(), initialCapacity, ResidencyState::IN_MEMORY, hasNullData());

        while (pos < numValues && newSegment->getSizeOnDiskInMemoryStats() <= targetSize) {
            if (newSegment->getNumValues() == newSegment->getCapacity()) {
                newSegment->resize(newSegment->getCapacity() * 2);
            }
            auto numValuesToAppendInChunk = std::min(numValues - pos, chunkSize);
            newSegment->append(this, pos, numValuesToAppendInChunk);
            pos += numValuesToAppendInChunk;
        }
        if (pos < numValues && newSegment->getNumValues() > chunkSize) {
            // Size exceeded target size, so we should drop the last batch added (unless they are
            // the only values)
            pos -= chunkSize;
            newSegment->truncate(newSegment->getNumValues() - chunkSize);
        }
        newSegments.push_back(std::move(newSegment));
    }
    return newSegments;
}

void ColumnChunkData::setNullData(std::unique_ptr<NullChunkData> nullData_) {
    nullData = std::move(nullData_);