Function can_skip_integer

nodedb-columnar/src/predicate.rs:277–297

Block-skip logic for integer predicates (lossless i64 comparison). When `BlockStats` carries `min_i64`/`max_i64` (written by minor v1+), the comparison is done entirely in i64 — no f64 rounding. When the exact fields are absent (segments written at minor v0), we fall through to the f64 path via `f64_to_exact_i64`: if the predicate value itself converts losslessly we can still do an exact comparis

(op: PredicateOp, value: i64, stats: &BlockStats)

/// we can still do an exact comparison against the (possibly rounded) f64
/// stats, which is conservative (may fail to skip) but never incorrect.
fn can_skip_integer(op: PredicateOp, value: i64, stats: &BlockStats) -> bool {
    // Prefer lossless i64 stats when available.
    if let (Some(smin), Some(smax)) = (stats.min_i64, stats.max_i64) {
        return match op {
            PredicateOp::Gt => smax <= value,
            PredicateOp::Gte => smax < value,
            PredicateOp::Lt => smin >= value,
            PredicateOp::Lte => smin > value,
            PredicateOp::Eq => value < smin || value > smax,
            PredicateOp::Ne => smin == value && smax == value,
        };
    }

    // Fallback: convert the predicate value to f64 if it is exactly
    // representable, then use the f64 stats path.  If the conversion is lossy
    // we cannot safely skip — return false (conservative).
    match f64_to_exact_i64(value as f64).and(Some(value as f64)) {
        Some(fv) => can_skip_numeric(op, fv, stats),
        None => false,
    }
}

/// Convert an f64 to i64 only if the conversion is exact.
///