Function integerPackingMultiPage

test/storage/compression_test.cpp:440–475

template<typename T>
void integerPackingMultiPage(const std::vector<T>& src) {
    auto alg = IntegerBitpacking<T>();
    auto pageSize = 4096;
    const auto& [min, max] = std::minmax_element(src.begin(), src.end());
    auto metadata =
        CompressionMetadata(StorageValue(*min), StorageValue(*max), alg.getCompressionType());
    auto numValuesPerPage = metadata.numValues(pageSize, LogicalType(LogicalTypeID::INT64));
    int64_t numValuesRemaining = src.size();
    const uint8_t* srcCursor = (uint8_t*)src.data();
    auto pages = src.size() / numValuesPerPage + 1;
    std::vector<std::vector<uint8_t>> dest(pages, std::vector<uint8_t>(pageSize));
    size_t pageNum = 0;
    while (numValuesRemaining > 0) {
        ASSERT_LT(pageNum, pages);
        alg.compressNextPage(srcCursor, numValuesRemaining, dest[pageNum++].data(), pageSize,
            metadata);
        numValuesRemaining -= numValuesPerPage;
    }
    ASSERT_EQ(srcCursor, (uint8_t*)(src.data() + src.size()));
    for (auto i = 0u; i < src.size(); i++) {
        auto page = i / numValuesPerPage;
        auto indexInPage = i % numValuesPerPage;
        T value;
        alg.decompressFromPage(dest[page].data(), indexInPage, (uint8_t*)&value, 0, 1 /*numValues*/,
            metadata);
        EXPECT_EQ(src[i] - value, 0);
        EXPECT_EQ(src[i], value);
    }
    std::vector<T> decompressed(src.size());
    for (auto i = 0u; i < src.size(); i += numValuesPerPage) {
        auto page = i / numValuesPerPage;
        alg.decompressFromPage(dest[page].data(), 0, (uint8_t*)decompressed.data(), i,
            std::min(numValuesPerPage, (uint64_t)src.size() - i), metadata);
    }
    ASSERT_EQ(decompressed, src);
}

TEST(CompressionTests, IntegerPackingMultiPage64) {
    int64_t numValues = 10000;