Function getMinMaxStorageValue

src/storage/compression/compression.cpp:1166–1228

}

std::pair<std::optional<StorageValue>, std::optional<StorageValue>> getMinMaxStorageValue(
    const uint8_t* data, uint64_t offset, uint64_t numValues, PhysicalTypeID physicalType,
    const NullMask* nullMask, bool valueRequiredIfUnsupported) {
    std::pair<std::optional<StorageValue>, std::optional<StorageValue>> returnValue;

    TypeUtils::visit(
        physicalType,
        [&](bool) {
            if (numValues > 0) {
                const auto boolData = reinterpret_cast<const uint64_t*>(data);
                if (!nullMask || nullMask->hasNoNullsGuarantee()) {
                    auto [minRaw, maxRaw] = NullMask::getMinMax(boolData, offset, numValues);
                    returnValue = std::make_pair(std::optional(StorageValue(minRaw)),
                        std::optional(StorageValue(maxRaw)));
                } else {
                    std::optional<StorageValue> min, max;
                    for (size_t i = offset; i < offset + numValues; i++) {
                        if (!nullMask || !nullMask->isNull(i)) {
                            auto boolValue = NullMask::isNull(boolData, i);
                            if (!max || boolValue > max->get<bool>()) {
                                max = boolValue;
                            }
                            if (!min || boolValue < min->get<bool>()) {
                                min = boolValue;
                            }
                        }
                    }
                    returnValue = std::make_pair(min, max);
                }
            }
        },
        [&]<typename T>(T)
            requires(numeric_utils::IsIntegral<T> || std::floating_point<T>)
        {
            if (numValues > 0) {
                auto typedData = std::span(reinterpret_cast<const T*>(data) + offset, numValues);
                returnValue = getTypedMinMax(typedData, nullMask ? &*nullMask : nullptr, offset);
            }
        },
        [&]<typename T>(T)
            requires(std::same_as<T, internalID_t>)
        {
            if (numValues > 0) {
                const auto typedData =
                    std::span(reinterpret_cast<const uint64_t*>(data) + offset, numValues);
                returnValue = getTypedMinMax(typedData, nullMask ? &*nullMask : nullptr, offset);
            }
        },
        [&]<typename T>(T)
            requires(std::same_as<T, interval_t> || std::same_as<T, struct_entry_t> ||
                     std::same_as<T, string_t> || std::same_as<T, list_entry_t> ||
                     std::same_as<T, uint128_t>)
        {
            if (valueRequiredIfUnsupported) {
                // For unsupported types on the first copy,
                // they need a non-optional value to distinguish them
                // from supported types where every value is null
                returnValue.first = std::numeric_limits<uint64_t>::min();