pigeonhole-db 1.1.0

data/src/vector.rs

@@ -0,0 +1,262 @@
+//! Vectors (D303): vector families' specs, vectors written from Ruby Arrays (or a packed
+//! String of bits), and vector cells read back as Arrays or a binary String.
+
+use magnus::{Error, Float, Integer, RArray, RString, Ruby, Symbol, TryConvert, Value, prelude::*};
+use pigeonhole::{Element, ErrorCode, Metric};
+
+use crate::classes::VectorSpec;
+use crate::convert::{arg_error, binary, class_name, type_error};
+use crate::error::{OrRb, with_code};
+use crate::gvl::without_gvl;
+
+/// A Symbol's (or a String's) name, for the element and metric arguments.
+pub(crate) fn sym_name(ruby: &Ruby, v: Value, what: &str) -> Result<String, Error> {
+    if let Some(s) = Symbol::from_value(v) {
+        return Ok(s.name()?.into_owned());
+    }
+    if let Some(s) = RString::from_value(v) {
+        return s.to_string();
+    }
+    Err(type_error(
+        ruby,
+        format!("{what} is a Symbol, not {}", class_name(v)),
+    ))
+}
+
+/// `:f32`, `:i8`, `:bit`, `:f16` or `:bf16`.
+pub(crate) fn element(ruby: &Ruby, v: Value) -> Result<Element, Error> {
+    Ok(match sym_name(ruby, v, "a vector element")?.as_str() {
+        "f32" => Element::F32,
+        "i8" => Element::I8,
+        "bit" => Element::Bit,
+        "f16" => Element::F16,
+        "bf16" => Element::BF16,
+        other => {
+            return Err(arg_error(
+                ruby,
+                format!("unknown vector element :{other} (:f32, :i8, :bit, :f16 or :bf16)"),
+            ));
+        }
+    })
+}
+
+/// `:l2`, `:cosine`, `:inner_product` or `:hamming`.
+pub(crate) fn metric(ruby: &Ruby, v: Value) -> Result<Metric, Error> {
+    Ok(match sym_name(ruby, v, "a metric")?.as_str() {
+        "l2" => Metric::L2,
+        "cosine" => Metric::Cosine,
+        "inner_product" => Metric::InnerProduct,
+        "hamming" => Metric::Hamming,
+        other => {
+            return Err(arg_error(
+                ruby,
+                format!("unknown metric :{other} (:l2, :cosine, :inner_product or :hamming)"),
+            ));
+        }
+    })
+}
+
+pub(crate) fn element_name(e: Element) -> &'static str {
+    match e {
+        Element::F32 => "f32",
+        Element::I8 => "i8",
+        Element::Bit => "bit",
+        Element::F16 => "f16",
+        Element::BF16 => "bf16",
+        _ => "unknown",
+    }
+}
+
+fn metric_name(m: Metric) -> &'static str {
+    match m {
+        Metric::L2 => "l2",
+        Metric::Cosine => "cosine",
+        Metric::InnerProduct => "inner_product",
+        Metric::Hamming => "hamming",
+        _ => "unknown",
+    }
+}
+
+/// A spec from Ruby arguments: `dim` elements of `element`, compared by `metric`.
+pub(crate) fn spec(
+    ruby: &Ruby,
+    dim: u32,
+    element: Value,
+    metric: Value,
+) -> Result<pigeonhole::VectorSpec, Error> {
+    pigeonhole::VectorSpec::new(
+        dim,
+        self::element(ruby, element)?,
+        self::metric(ruby, metric)?,
+    )
+    .or_rb(ruby)
+}
+
+impl VectorSpec {
+    /// `VectorSpec.new(dim, element, metric)`.
+    pub(crate) fn new(ruby: &Ruby, dim: u32, element: Value, metric: Value) -> Result<Self, Error> {
+        spec(ruby, dim, element, metric).map(Self)
+    }
+
+    /// The dimension.
+    pub(crate) fn dim(&self) -> u32 {
+        self.0.dim()
+    }
+
+    /// The element type: `:f32`, `:i8`, `:bit`, `:f16` or `:bf16`.
+    pub(crate) fn element(ruby: &Ruby, rb_self: &Self) -> Symbol {
+        ruby.to_symbol(element_name(rb_self.0.element()))
+    }
+
+    /// The metric: `:l2`, `:cosine`, `:inner_product` or `:hamming`.
+    pub(crate) fn metric(ruby: &Ruby, rb_self: &Self) -> Symbol {
+        ruby.to_symbol(metric_name(rb_self.0.metric()))
+    }
+
+    /// Equal dimension, element and metric.
+    pub(crate) fn eq(&self, other: Value) -> bool {
+        <&VectorSpec>::try_convert(other).is_ok_and(|o| o.0 == self.0)
+    }
+
+    /// A hash consistent with `==`.
+    pub(crate) fn hash(&self) -> i64 {
+        use std::hash::{Hash, Hasher};
+        let mut h = std::hash::DefaultHasher::new();
+        (
+            self.0.dim(),
+            element_name(self.0.element()),
+            metric_name(self.0.metric()),
+        )
+            .hash(&mut h);
+        h.finish().cast_signed()
+    }
+
+    /// `#<Pigeonhole::VectorSpec dim=... element=:f32 metric=:l2>`.
+    pub(crate) fn inspect(&self) -> String {
+        format!(
+            "#<Pigeonhole::VectorSpec dim={} element=:{} metric=:{}>",
+            self.0.dim(),
+            element_name(self.0.element()),
+            metric_name(self.0.metric())
+        )
+    }
+}
+
+/// A vector as written: the family's element type decides how a Ruby value is read.
+#[derive(Debug, Clone)]
+pub(crate) enum Vector {
+    F32(Vec<f32>),
+    I8(Vec<i8>),
+    Bits(Vec<u8>),
+}
+
+/// `v` as a vector of `element`:
+/// - `f32`, `f16`, `bf16` (and an element this build doesn't name): an Array of Numerics,
+///   each narrowed to `f32` (a half family rounds each to its element at the write, ties to
+///   even, and refuses an overflow);
+/// - `i8`: an Array of Integers in -128..=127;
+/// - `bit`: the packed bits, a String.
+///
+/// A String is refused for `f32` and `i8`, and an Array for bits: the two forms don't
+/// convert into each other silently. The family checks the dimension at commit.
+pub(crate) fn vector(ruby: &Ruby, v: Value, element: Element) -> Result<Vector, Error> {
+    if element == Element::Bit {
+        return match RString::from_value(v) {
+            Some(s) => Ok(Vector::Bits(s.to_bytes().to_vec())),
+            None => Err(type_error(
+                ruby,
+                format!(
+                    "a bit vector is its packed bits, a String, not {}",
+                    class_name(v)
+                ),
+            )),
+        };
+    }
+    let Some(a) = RArray::from_value(v) else {
+        let want = if element == Element::I8 {
+            "an i8 vector is an Array of Integers"
+        } else {
+            "an f32 vector is an Array of Numerics"
+        };
+        return Err(type_error(ruby, format!("{want}, not {}", class_name(v))));
+    };
+    if element == Element::I8 {
+        let mut out = Vec::with_capacity(a.len());
+        for x in a.into_iter() {
+            let Some(n) = Integer::from_value(x) else {
+                return Err(type_error(
+                    ruby,
+                    format!(
+                        "an i8 vector's elements are Integers, not {}",
+                        class_name(x)
+                    ),
+                ));
+            };
+            out.push(i8::try_from(n.to_i64()?).map_err(|_| {
+                crate::convert::range_error(ruby, "an i8 vector's elements are in -128..=127")
+            })?);
+        }
+        return Ok(Vector::I8(out));
+    }
+    let mut out = Vec::with_capacity(a.len());
+    for x in a.into_iter() {
+        if let Some(f) = Float::from_value(x) {
+            out.push(f.to_f64() as f32);
+        } else if x.is_kind_of(ruby.class_numeric()) {
+            // An Integer, a Rational, or any other real Numeric, as `Float(x)` converts it.
+            out.push(f64::try_convert(x)? as f32);
+        } else {
+            return Err(type_error(
+                ruby,
+                format!(
+                    "an f32 vector's elements are Numerics, not {}",
+                    class_name(x)
+                ),
+            ));
+        }
+    }
+    Ok(Vector::F32(out))
+}
+
+/// The spec of `table`'s vector family `family` (`FamilyNotFound` for no such family, a
+/// `TypeError` naming `what` for a family that isn't a vector family).
+pub(crate) fn family_spec(
+    ruby: &Ruby,
+    table: &crate::table::Handle,
+    family: &str,
+    what: &str,
+) -> Result<pigeonhole::VectorSpec, Error> {
+    let (h, f) = (table.clone(), family.to_owned());
+    let info = without_gvl(ruby, move || {
+        crate::table::either!(&h, |t| t.family_info(&f))
+    })?;
+    let name = crate::table::either!(table, |t| t.name().to_owned());
+    let info = info.ok_or_else(|| {
+        with_code(
+            ruby,
+            ErrorCode::FamilyNotFound,
+            &format!("table {name} has no family {family}"),
+        )
+    })?;
+    info.vector.ok_or_else(|| {
+        type_error(
+            ruby,
+            format!("{what} a vector family, and {family} is not one"),
+        )
+    })
+}
+
+/// A vector cell as Ruby: an Array of Floats (`f32`, and `f16` or `bf16` widened exactly),
+/// an Array of Integers (`i8`), or the packed bits as a binary String.
+pub(crate) fn to_rb(ruby: &Ruby, v: pigeonhole::VectorRef<'_>) -> Value {
+    match v.element() {
+        Element::Bit => binary(ruby, v.as_bytes()).as_value(),
+        Element::I8 => ruby
+            .ary_from_iter(v.as_bytes().iter().map(|b| i64::from(*b as i8)))
+            .as_value(),
+        _ => match v.to_f32_vec() {
+            Some(x) => ruby.ary_from_iter(x.into_iter().map(f64::from)).as_value(),
+            None => binary(ruby, v.as_bytes()).as_value(),
+        },
+    }
+}

data/src/walk.rs

@@ -0,0 +1,406 @@
+//! The 1.1 reads: multi-get (D299), traversal (D304), walking a wide row in pages (D297) and
+//! nearest-neighbour search (D296), with D308's byte budget on nearest.
+//!
+//! Results with no engine object behind them (a traversal, its hops, a nearest search's
+//! neighbours and page) come back as plain Arrays, which `lib/pigeonhole/api.rb` turns into
+//! frozen `Data` objects: no wrapped struct here holds a Ruby value.
+
+use std::collections::HashMap;
+use std::ops::Bound as KeyBound;
+use std::sync::Mutex;
+
+use magnus::{Error, IntoValue, RArray, RString, Ruby, TryConvert, Value, prelude::*};
+use pigeonhole::KeySet;
+
+use crate::classes::{Pages, PagesState, Row, RowPosition, Snapshot, Table};
+use crate::convert::{self, Bytes, Name, arg_error, binary, frozen, lock};
+use crate::error::{OrRb, engine};
+use crate::fork::ForkSafe;
+use crate::read::snapshot_arg;
+use crate::table::either;
+use crate::vector::{self, Vector};
+
+/// An Array of byte Strings (`keys`, `seeds`).
+pub(crate) fn byte_list(a: RArray) -> Result<Vec<Vec<u8>>, Error> {
+    a.into_iter()
+        .map(|v| Bytes::try_convert(v).map(|b| b.0))
+        .collect()
+}
+
+/// Frozen binary Strings for `keys`.
+fn strings(ruby: &Ruby, keys: impl IntoIterator<Item = impl AsRef<[u8]>>) -> RArray {
+    ruby.ary_from_iter(keys.into_iter().map(|k| frozen(ruby, k.as_ref())))
+}
+
+impl Table {
+    /// `multi_get(keys, families, qualifier_prefix, versions, column_limit, snapshot)`: the
+    /// rows of `keys`, aligned with `keys` (one entry per key given, in that order, `nil`
+    /// for a key whose row has no cell the read keeps, a repeated key repeated). The read
+    /// itself is one multi-get in key order.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn multi_get(
+        ruby: &Ruby,
+        rb_self: &Self,
+        keys: RArray,
+        families: Option<RArray>,
+        qualifier_prefix: Option<Bytes>,
+        versions: u32,
+        column_limit: Option<u32>,
+        snapshot: Option<&Snapshot>,
+    ) -> Result<RArray, Error> {
+        let given = byte_list(keys)?;
+        let families = convert::names(families)?;
+        let qp = convert::opt_bytes(qualifier_prefix);
+        let snap = snapshot_arg(ruby, snapshot)?;
+        let h = rb_self.handle(ruby)?.clone();
+        let rows = engine(ruby, move || {
+            let set = KeySet::from_unsorted(&given);
+            let mut found: HashMap<Vec<u8>, pigeonhole::Row> = HashMap::new();
+            either!(&h, |t| {
+                let mut r = t.keys(&set).versions(versions);
+                if let Some(f) = &families {
+                    r = r.families(f.iter().map(String::as_str));
+                }
+                if let Some(q) = &qp {
+                    r = r.qualifier_prefix(q);
+                }
+                if let Some(n) = column_limit {
+                    r = r.column_limit(n);
+                }
+                if let Some(s) = &snap {
+                    r = r.snapshot(s);
+                }
+                let mut rows = r.read()?;
+                while let Some((_, row)) = rows.next()? {
+                    found.insert(row.key().to_vec(), row.to_owned());
+                }
+                Ok::<_, pigeonhole::Error>(())
+            })?;
+            // A key's last occurrence takes its row; only a repeated key's earlier ones copy.
+            let mut left: HashMap<&[u8], usize> = HashMap::new();
+            for k in &given {
+                *left.entry(k.as_slice()).or_default() += 1;
+            }
+            Ok(given
+                .iter()
+                .map(|k| {
+                    let n = left.get_mut(k.as_slice()).expect("counted above");
+                    *n -= 1;
+                    if *n == 0 {
+                        found.remove(k)
+                    } else {
+                        found.get(k).cloned()
+                    }
+                })
+                .collect::<Vec<_>>())
+        })?;
+        let out = ruby.ary_new_capa(rows.len());
+        for r in rows {
+            out.push(r.map(Row))?;
+        }
+        Ok(out)
+    }
+
+    /// `traverse(seeds, family, hops, per_node_limit, hop_limit, max_nodes, byte_budget,
+    /// parents, qualifier_prefix, snapshot, parallel)`: a breadth-first traversal (D304),
+    /// as `[seeds, [[nodes, parents], ...], rows, edges, hops_cut, cut_by_max_nodes,
+    /// cut_by_budget]`. `seeds` are sorted and deduplicated: hop 1's parents index them.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn traverse(
+        ruby: &Ruby,
+        rb_self: &Self,
+        seeds: RArray,
+        family: Name,
+        hops: u32,
+        per_node_limit: Option<u32>,
+        hop_limit: Option<u64>,
+        max_nodes: Option<u64>,
+        byte_budget: Option<u64>,
+        parents: bool,
+        qualifier_prefix: Option<Bytes>,
+        snapshot: Option<&Snapshot>,
+        parallel: Option<usize>,
+    ) -> Result<RArray, Error> {
+        let seeds = KeySet::from_unsorted(byte_list(seeds)?);
+        if byte_budget == Some(0) {
+            return Err(arg_error(
+                ruby,
+                "byte_budget: must be at least 1 (nil sets no budget)",
+            ));
+        }
+        let byte_budget = byte_budget.unwrap_or(0);
+        let qp = convert::opt_bytes(qualifier_prefix);
+        let snap = snapshot_arg(ruby, snapshot)?;
+        let h = rb_self.handle(ruby)?.clone();
+        let family = family.0;
+        let (sorted, t) = engine(ruby, move || {
+            let t = either!(&h, |t| {
+                let mut r = t
+                    .traverse(&seeds)
+                    .family(&family)
+                    .hops(hops)
+                    .byte_budget(byte_budget)
+                    .parents(parents);
+                if let Some(n) = per_node_limit {
+                    r = r.per_node_limit(n);
+                }
+                if let Some(n) = hop_limit {
+                    r = r.hop_limit(n);
+                }
+                if let Some(n) = max_nodes {
+                    r = r.max_nodes(n);
+                }
+                if let Some(q) = &qp {
+                    r = r.qualifier_prefix(q);
+                }
+                if let Some(s) = &snap {
+                    r = r.snapshot(s);
+                }
+                if let Some(n) = parallel {
+                    r = r.parallel(n);
+                }
+                r.run()
+            })?;
+            Ok((seeds.iter().map(<[u8]>::to_vec).collect::<Vec<_>>(), t))
+        })?;
+        let stats = t.stats();
+        let out_hops = ruby.ary_new_capa(t.hops().len());
+        for hop in t.hops() {
+            let parents = hop.parents().map_or_else(
+                || ruby.qnil().as_value(),
+                |p| p.to_vec().into_value_with(ruby),
+            );
+            out_hops.push((strings(ruby, hop.nodes().iter()), parents))?;
+        }
+        let out = ruby.ary_new_capa(7);
+        out.push(strings(ruby, &sorted))?;
+        out.push(out_hops)?;
+        out.push(stats.rows)?;
+        out.push(stats.edges)?;
+        out.push(stats.hops_cut)?;
+        out.push(stats.cut_by_max_nodes)?;
+        out.push(stats.cut_by_budget)?;
+        Ok(out)
+    }
+
+    /// `pages(row, size, families, qualifier_prefix, versions, snapshot, after)`: a walk of
+    /// `row`'s pages; nothing is read until the first page is asked for.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn pages(
+        ruby: &Ruby,
+        rb_self: &Self,
+        row: Bytes,
+        size: usize,
+        families: Option<RArray>,
+        qualifier_prefix: Option<Bytes>,
+        versions: u32,
+        snapshot: Option<&Snapshot>,
+        after: Option<&RowPosition>,
+    ) -> Result<Pages, Error> {
+        if size == 0 {
+            return Err(arg_error(ruby, "size must be at least 1"));
+        }
+        Ok(Pages(ForkSafe::new(Mutex::new(PagesState {
+            table: rb_self.handle(ruby)?.clone(),
+            row: row.0,
+            size,
+            families: convert::names(families)?,
+            qualifier_prefix: convert::opt_bytes(qualifier_prefix),
+            versions,
+            snapshot: snapshot_arg(ruby, snapshot)?,
+            position: after.map(|p| p.0.clone()),
+            done: false,
+        }))))
+    }
+
+    /// `nearest(family, query, k, prefix, start, end, keys, qualifier_prefix, snapshot,
+    /// parallel, within)`: the `k` cells of vector family `family` nearest `query`, as
+    /// `[row, qualifier, distance, ts]` Arrays in (distance, row, qualifier) order; with
+    /// `within` (D308), `[neighbours, bytes, next_bytes]`: the nearest that fit that many
+    /// bytes.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn nearest(
+        ruby: &Ruby,
+        rb_self: &Self,
+        family: Name,
+        query: Value,
+        k: usize,
+        prefix: Option<Bytes>,
+        start: Option<Bytes>,
+        end: Option<Bytes>,
+        keys: Option<RArray>,
+        qualifier_prefix: Option<Bytes>,
+        snapshot: Option<&Snapshot>,
+        parallel: Option<usize>,
+        within: Option<u64>,
+    ) -> Result<Value, Error> {
+        let h = rb_self.handle(ruby)?.clone();
+        let family = family.0;
+        let spec = vector::family_spec(ruby, &h, &family, "nearest searches")?;
+        let query = vector::vector(ruby, query, spec.element())?;
+        let (prefix, start, end) = (
+            convert::opt_bytes(prefix),
+            convert::opt_bytes(start),
+            convert::opt_bytes(end),
+        );
+        let ranged = prefix.is_some() || start.is_some() || end.is_some();
+        if prefix.is_some() && (start.is_some() || end.is_some()) {
+            return Err(arg_error(
+                ruby,
+                "nearest takes a prefix or start:/end:, not both",
+            ));
+        }
+        let keys = keys.map(byte_list).transpose()?.map(KeySet::from_unsorted);
+        if keys.is_some() && ranged {
+            return Err(arg_error(ruby, "nearest takes keys: or a range, not both"));
+        }
+        let qp = convert::opt_bytes(qualifier_prefix);
+        let snap = snapshot_arg(ruby, snapshot)?;
+        macro_rules! search {
+            ($read:expr) => {{
+                let r = $read;
+                let mut n = match &query {
+                    Vector::F32(q) => r.nearest_f32(q, k),
+                    Vector::I8(q) => r.nearest_i8(q, k),
+                    Vector::Bits(q) => r.nearest_bits(q, k),
+                };
+                if let Some(p) = parallel {
+                    n = n.parallel(p);
+                }
+                match within {
+                    Some(b) => n.run_within(b).map(|p| {
+                        let (bytes, next) = (p.bytes(), p.next_bytes());
+                        (p.into_neighbours(), Some((bytes, next)))
+                    }),
+                    None => n.run().map(|v| (v, None)),
+                }
+            }};
+        }
+        let (found, page) = engine(ruby, move || {
+            either!(&h, |t| {
+                if let Some(keys) = &keys {
+                    let mut r = t.keys(keys).family(&family);
+                    if let Some(q) = &qp {
+                        r = r.qualifier_prefix(q);
+                    }
+                    if let Some(s) = &snap {
+                        r = r.snapshot(s);
+                    }
+                    search!(r)
+                } else {
+                    let mut r = match &prefix {
+                        Some(p) => t.scan_prefix(p),
+                        None => t.scan_bounds(
+                            start
+                                .as_deref()
+                                .map_or(KeyBound::Unbounded, KeyBound::Included),
+                            end.as_deref()
+                                .map_or(KeyBound::Unbounded, KeyBound::Excluded),
+                        ),
+                    }
+                    .family(&family);
+                    if let Some(q) = &qp {
+                        r = r.qualifier_prefix(q);
+                    }
+                    if let Some(s) = &snap {
+                        r = r.snapshot(s);
+                    }
+                    search!(r)
+                }
+            })
+        })?;
+        let neighbours = ruby.ary_new_capa(found.len());
+        for n in found {
+            neighbours.push((
+                frozen(ruby, &n.row),
+                frozen(ruby, &n.qualifier),
+                n.distance,
+                n.ts,
+            ))?;
+        }
+        Ok(match page {
+            None => neighbours.as_value(),
+            Some((bytes, next)) => (neighbours, bytes, next).into_value_with(ruby),
+        })
+    }
+}
+
+impl Pages {
+    /// The next page, or `nil` once the row is done. Each page is one read with the GVL
+    /// released; none is held open between pages.
+    pub(crate) fn next_page(ruby: &Ruby, rb_self: &Self) -> Result<Option<Row>, Error> {
+        let state = rb_self.0.get(ruby)?;
+        // The state's mutex is taken only inside the call, so a second thread waiting on it
+        // never holds the GVL.
+        let page = engine(ruby, || {
+            let mut s = lock(state);
+            if s.done {
+                return Ok(None);
+            }
+            let page = either!(&s.table, |t| {
+                let mut r = t.row(&s.row).versions(s.versions);
+                if let Some(f) = &s.families {
+                    r = r.families(f.iter().map(String::as_str));
+                }
+                if let Some(q) = &s.qualifier_prefix {
+                    r = r.qualifier_prefix(q);
+                }
+                if let Some(sn) = &s.snapshot {
+                    r = r.snapshot(sn);
+                }
+                if let Some(p) = &s.position {
+                    r = r.resume_after(p);
+                }
+                let mut pages = r.pages(s.size)?;
+                let page = pages.next()?.map(|p| p.to_owned());
+                Ok::<_, pigeonhole::Error>(page.map(|p| (p, pages.position())))
+            })?;
+            Ok(match page {
+                Some((p, position)) => {
+                    s.position = position;
+                    Some(p)
+                }
+                None => {
+                    s.done = true;
+                    None
+                }
+            })
+        })?;
+        Ok(page.map(Row))
+    }
+
+    /// Where the last page ended (`nil` before the first page, unless the walk started from
+    /// one).
+    pub(crate) fn position(ruby: &Ruby, rb_self: &Self) -> Result<Option<RowPosition>, Error> {
+        let state = rb_self.0.get(ruby)?;
+        let p = crate::gvl::without_gvl(ruby, || lock(state).position.clone())?;
+        Ok(p.map(RowPosition))
+    }
+}
+
+impl RowPosition {
+    /// The position as bytes: stable, so a client can hand them back later.
+    pub(crate) fn to_bytes(ruby: &Ruby, rb_self: &Self) -> RString {
+        binary(ruby, &rb_self.0.to_bytes())
+    }
+
+    /// The position `to_bytes` wrote.
+    pub(crate) fn from_bytes(ruby: &Ruby, b: Bytes) -> Result<Self, Error> {
+        pigeonhole::RowPosition::from_bytes(&b.0)
+            .or_rb(ruby)
+            .map(Self)
+    }
+
+    /// The same position.
+    pub(crate) fn eq(&self, other: Value) -> bool {
+        <&RowPosition>::try_convert(other).is_ok_and(|o| o.0 == self.0)
+    }
+
+    /// A hash consistent with `==`.
+    pub(crate) fn hash(&self) -> i64 {
+        use std::hash::{Hash, Hasher};
+        let mut h = std::hash::DefaultHasher::new();
+        self.0.hash(&mut h);
+        h.finish().cast_signed()
+    }
+}

data/vendor/bundle/ruby/3.4.0/bin/minitest

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by RubyGems.
+#
+# The application 'minitest' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+Gem.use_gemdeps
+
+version = ">= 0.a"
+
+str = ARGV.first
+if str
+  str = str.b[/\A_(.*)_\z/, 1]
+  if str and Gem::Version.correct?(str)
+    version = str
+    ARGV.shift
+  end
+end
+
+if Gem.respond_to?(:activate_bin_path)
+load Gem.activate_bin_path('minitest', 'minitest', version)
+else
+gem "minitest", version
+load Gem.bin_path("minitest", "minitest", version)
+end