probe-format 0.1.0__tar.gz → 0.2.0__tar.gz

{probe_format-0.1.0 → probe_format-0.2.0}/Cargo.lock

@@ -767,7 +767,7 @@ checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
 
 [[package]]
 name = "probe-cli"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "clap",
  "probe-format",
@@ -776,7 +776,7 @@ dependencies = [
 
 [[package]]
 name = "probe-format"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "arrow-array",
  "arrow-ipc",
@@ -791,7 +791,7 @@ dependencies = [
 
 [[package]]
 name = "probe-py"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "probe-format",
  "pyo3",

{probe_format-0.1.0 → probe_format-0.2.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["probe", "probe-py"]
 
 [workspace.package]
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 rust-version = "1.85"
 license = "Apache-2.0"
@@ -11,7 +11,7 @@ authors = ["ProbNode <hello@probnode.com>"]
 repository = "https://github.com/probnode/probe"
 
 [workspace.dependencies]
-probe-format = { path = "probe", version = "0.1.0" }
+probe-format = { path = "probe", version = "0.2.0" }
 memmap2 = "0.9"
 rayon = "1.10"
 serde = { version = "1", features = ["derive"] }

{probe_format-0.1.0 → probe_format-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: probe-format
-Version: 0.1.0
+Version: 0.2.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Financial and Insurance Industry
 Classifier: Intended Audience :: Science/Research
@@ -51,8 +51,11 @@ events = f.events(start_ns=f.header["hour_start_ns"],
                   end_ns=f.header["hour_start_ns"] + 600_000_000_000)
 levels = f.levels(market="will-x-happen")      # best-price exceptions and book hashes included
 f.book_at("7001", 1794477900000000000)          # {"bids": [(price_micro, size_micro), ...], ...}
+f.transcode("hour.v3.probe")                   # Probe v3 (profile "fast"), losslessly
 ```
 
+It reads Probe v1, v2 and v3.
+
 | method | rows |
 |---|---|
 | `markets()` | the markets table: slug, condition id, tokens, units |

{probe_format-0.1.0 → probe_format-0.2.0}/README.md

@@ -23,8 +23,11 @@ events = f.events(start_ns=f.header["hour_start_ns"],
                   end_ns=f.header["hour_start_ns"] + 600_000_000_000)
 levels = f.levels(market="will-x-happen")      # best-price exceptions and book hashes included
 f.book_at("7001", 1794477900000000000)          # {"bids": [(price_micro, size_micro), ...], ...}
+f.transcode("hour.v3.probe")                   # Probe v3 (profile "fast"), losslessly
 ```
 
+It reads Probe v1, v2 and v3.
+
 | method | rows |
 |---|---|
 | `markets()` | the markets table: slug, condition id, tokens, units |

{probe_format-0.1.0 → probe_format-0.2.0}/probe/README.md

@@ -2,7 +2,7 @@
 
 The Rust reader of [Probe](https://github.com/probnode/probe), a lossless file format for
 prediction-market order books: every change of every price level of every outcome token, every
-trade, two clocks, and five-minute full-book checkpoints, at about 3.3 bytes per level change.
+trade, two clocks, and five-minute full-book checkpoints, at about 2.5 bytes per level as Probe v3.
 
 ```rust
 use probe_format::File;
@@ -16,11 +16,14 @@ for ev in f.query().market("will-x-happen")?.events() {
 }
 ```
 
-It reads Probe v1 and v2 completely: header, markets table, segments and block indexes, every
+It reads Probe v1, v2 and v3 completely: header, markets table, segments and block indexes, every
 event and level in the reference order, one market through the block index, a time range, the
 book of a token at a time, and every side stream (trade transaction hashes, JSON payloads,
 best-price exceptions, venue book hashes). Corrupt input gives an error, never a panic.
 
+`probe_format::v3::transcode` writes Probe v3 from any Probe file, losslessly, in the profiles
+`fast` (the default), `fast1` and `rc1`.
+
 Features: `parallel` (default, rayon), `arrow` (record batches, Arrow IPC), `parquet`.
 
 The specification is [spec/PROBE.md](https://github.com/probnode/probe/blob/main/spec/PROBE.md).

{probe_format-0.1.0 → probe_format-0.2.0}/probe/src/decoder.rs

@@ -1,5 +1,7 @@
 //! The decoder core: blocks, the order stream and the reference order of a segment (5.1 steps
 //! 1-4), without the side streams. This is the fast path; [`crate::Event`] adds the side streams.
+//! A v3 segment decodes through the same API: its blocks into [`Block`]s, its order part into the
+//! same arrival order.
 
 use crate::error::{format_err, Error, Result};
 use crate::file::File;
@@ -10,7 +12,7 @@ use crate::walker::{Walker, ET_CHECKPOINT, ET_OTHER, ET_TRADE};
 use std::io::Write;
 
 /// One decoded block.
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct Block {
     /// The block's market row, or the segment's `nmkt` for the type-4 block.
     pub row: usize,
@@ -32,7 +34,7 @@ impl Block {
 
 /// A decoded segment: its blocks in block-index order, and the reference order as
 /// (block index, event index in the block) pairs.
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct SegmentCore {
     /// The blocks, in block-index order.
     pub blocks: Vec<Block>,
@@ -76,7 +78,13 @@ impl File {
             .ok_or_else(|| Error::Format(format!("segment {}: block {} outside its part", si, bi)))
     }
 
-    fn walk(&self, w: &mut Walker, si: usize, bi: usize, limit: Option<i64>) -> Result<Block> {
+    pub(crate) fn walk(
+        &self,
+        w: &mut Walker,
+        si: usize,
+        bi: usize,
+        limit: Option<i64>,
+    ) -> Result<Block> {
         let s = self.seg(si)?;
         let row = s
             .blocks
@@ -124,6 +132,9 @@ impl File {
 
     /// Decodes block `bi` (an index into the segment's block index) alone.
     pub fn decode_block(&self, si: usize, bi: usize) -> Result<Block> {
+        if self.is_v3() {
+            return self.v3_block(si, bi);
+        }
         self.walk(&mut Walker::new(), si, bi, None)
     }
 
@@ -137,6 +148,9 @@ impl File {
         bi: usize,
         limit: i64,
     ) -> Result<(Block, [[Vec<(i64, i64)>; 2]; 2])> {
+        if self.is_v3() {
+            return self.v3_block_until(si, bi, limit);
+        }
         let mut w = Walker::new();
         let b = self.walk(&mut w, si, bi, Some(limit))?;
         let book = [
@@ -147,7 +161,12 @@ impl File {
     }
 
     /// Decodes segment `si`'s order stream: the block id of every real event in arrival order.
+    /// In v3 the order part needs the blocks' clocks, so this decodes the segment's blocks.
     pub fn decode_order(&self, si: usize) -> Result<Vec<u32>> {
+        if self.is_v3() {
+            let blocks = self.v3_blocks(si, cfg!(feature = "parallel"))?;
+            return self.v3_ids(si, &blocks);
+        }
         let s = self.seg(si)?;
         let b = self
             .part_bytes(si, "order")
@@ -162,6 +181,11 @@ impl File {
 
     /// Decodes segment `si` into its blocks and the reference order, on one thread.
     pub fn segment_core(&self, si: usize) -> Result<SegmentCore> {
+        if self.is_v3() {
+            let blocks = self.v3_blocks(si, false)?;
+            let ids = self.v3_ids(si, &blocks)?;
+            return self.assemble(si, blocks, ids);
+        }
         let n = self.seg(si)?.blocks.len();
         let mut w = Walker::new();
         let mut blocks = Vec::with_capacity(n);
@@ -176,6 +200,11 @@ impl File {
     #[cfg(feature = "parallel")]
     pub fn segment_core_par(&self, si: usize) -> Result<SegmentCore> {
         use rayon::prelude::*;
+        if self.is_v3() {
+            let blocks = self.v3_blocks(si, true)?;
+            let ids = self.v3_ids(si, &blocks)?;
+            return self.assemble(si, blocks, ids);
+        }
         let n = self.seg(si)?.blocks.len();
         let chunk = 64usize;
         let (ids, blocks) = rayon::join(
@@ -479,7 +508,7 @@ pub fn core_dump(f: &File, mut out: Option<&mut dyn Write>) -> Result<CoreDumpSu
                 e.out,
                 e.cont,
                 floor_div(tns, 1000),
-                floor_div(tns, 1_000_000) - e.lat,
+                floor_div(tns, 1_000_000).wrapping_sub(e.lat),
                 e.fee
             );
             for (k, l) in b.event_levels(j as usize).iter().enumerate() {

{probe_format-0.1.0 → probe_format-0.2.0}/probe/src/event.rs

@@ -264,8 +264,8 @@ impl File {
             pos[bi as usize][j as usize] = idx;
         }
         let side = SideStreams::read(self, si, hashes)?;
-        match self.header.version {
-            Version::V1 => {
+        match self.header.side_layout() {
+            Version::V1 | Version::V3 => {
                 let nck = self.segments[si].n_ck.min(evs.len());
                 attach_v1(&mut evs, nck, &side)?;
             }
@@ -310,7 +310,7 @@ impl File {
         let mut evs: Vec<Event> = (0..b.events.len())
             .map(|j| self.build_event(si, None, j, b.row, &b.events[j], b.event_levels(j)))
             .collect();
-        if let (Some(sd), Version::V2) = (side, self.header.version) {
+        if let (Some(sd), Version::V2) = (side, self.header.side_layout()) {
             let entry = &self.segments[si].blocks[bi];
             let c = entry
                 .counts

{probe_format-0.1.0 → probe_format-0.2.0}/probe/src/file.rs

@@ -1,12 +1,12 @@
-//! The container (specification section 3): magic, header JSON, markets table, segments, parts and
-//! the block index.
+//! The container (specification sections 3 and 9.1): magic, header JSON, markets table, segments,
+//! parts and the block index.
 
 use crate::error::{format_err, Error, Result};
 use crate::uvarint;
 use serde::Deserialize;
 use std::path::Path;
 
-/// The magic of every Probe file, v1 and v2.
+/// The magic of every Probe file, v1, v2 and v3.
 pub const MAGIC: &[u8; 4] = b"EVM4";
 
 /// The flag bits this reader decodes (3.11): 16 (`lat` as a delta) and 64 (price from the best).
@@ -21,22 +21,27 @@ pub enum Version {
     /// Probe v2, header version `"evmin/5"`: per-block counts in the block index, side streams in
     /// block order.
     V2,
+    /// Probe v3, header version `"evmin/6"`: every part names its codec (specification 9). The
+    /// side streams keep the layout of the source version ([`Header::source_version`]).
+    V3,
 }
 
 impl Version {
-    /// The header's `version` string: `"evmin/4"` or `"evmin/5"`.
+    /// The header's `version` string: `"evmin/4"`, `"evmin/5"` or `"evmin/6"`.
     pub fn header_str(self) -> &'static str {
         match self {
             Version::V1 => "evmin/4",
             Version::V2 => "evmin/5",
+            Version::V3 => "evmin/6",
         }
     }
 
-    /// The version number: 1 or 2.
+    /// The version number: 1, 2 or 3.
     pub fn number(self) -> u32 {
         match self {
             Version::V1 => 1,
             Version::V2 => 2,
+            Version::V3 => 3,
         }
     }
 
@@ -45,6 +50,7 @@ impl Version {
         match s {
             "evmin/4" => Some(Version::V1),
             "evmin/5" => Some(Version::V2),
+            "evmin/6" => Some(Version::V3),
             _ => None,
         }
     }
@@ -77,6 +83,20 @@ pub struct Header {
     pub hour_start_ns: i64,
     /// `[offset, length]` of the zstd markets table in the body.
     pub markets_zst: (u64, u64),
+    /// v3: the profile the writer used (`fast`, `fast1`, `rc1`). Informative: readers go by the
+    /// codec ids of the parts.
+    pub profile: Option<String>,
+    /// v3: the version of the file it was transcoded from (v1 or v2), which sets the layout of
+    /// the side streams. `None` in a v1 or v2 file.
+    pub source_version: Option<Version>,
+}
+
+impl Header {
+    /// The version whose side-stream layout the file uses: the file's own for v1 and v2, the
+    /// source's for v3.
+    pub fn side_layout(&self) -> Version {
+        self.source_version.unwrap_or(self.version)
+    }
 }
 
 /// One row of the markets table (3.4). A market whose units become finer during the hour gets a
@@ -109,13 +129,16 @@ pub struct Market {
 /// A named byte range of a segment, offset into the body.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Part {
-    /// The part name: `order`, `bidx`, `blocks`, `tx`, `payload.zst`, `hash`, or one a later
-    /// writer added (readers ignore names they do not know).
+    /// The part name: `order`, `bidx`, `blocks`, `tx`, `payload.zst`, `hash`; in v3 also
+    /// `bidx3`, `tables`, `evcols`; or one a later writer added (readers ignore names they do not
+    /// know).
     pub name: String,
     /// Offset into the body.
     pub offset: u64,
     /// Length in bytes.
     pub length: u64,
+    /// v3: the codec id of the part (specification 9.2); `None` in v1 and v2.
+    pub codec: Option<u32>,
 }
 
 /// A v2 block's side-stream counts (3.7) and their prefix sums over the blocks before it, which
@@ -176,7 +199,9 @@ pub struct Segment {
     pub parts: Vec<Part>,
     /// The block index, ascending row.
     pub blocks: Vec<BlockEntry>,
-    bitmap: Vec<u8>,
+    pub(crate) bitmap: Vec<u8>,
+    /// v3: what the codecs need beyond the block index.
+    pub(crate) v3: Option<crate::v3::Seg3>,
 }
 
 impl Segment {
@@ -201,6 +226,11 @@ impl Segment {
         self.blocks.binary_search_by_key(&row, |b| b.row).ok()
     }
 
+    /// v3: the codec id of the segment's `blocks` part; `None` in v1 and v2.
+    pub fn blocks_codec(&self) -> Option<u32> {
+        self.v3.as_ref().map(|v| v.blocks_codec)
+    }
+
     /// Whether the segment has a type-4 block.
     pub fn has_other_block(&self) -> bool {
         self.blocks.last().is_some_and(|b| b.row == self.nmkt)
@@ -246,6 +276,14 @@ struct HeaderJson {
     #[serde(default)]
     hour_start_ns: i64,
     markets_zst: (i64, i64),
+    #[serde(default)]
+    profile: Option<String>,
+    #[serde(default)]
+    src_version: Option<String>,
+    #[serde(default)]
+    mkunits: Option<(i64, i64)>,
+    #[serde(default)]
+    mkslugs: Option<(i64, i64)>,
     segments: Vec<SegmentJson>,
 }
 
@@ -256,7 +294,7 @@ fn default_seg_s() -> i64 {
 #[derive(Deserialize)]
 struct SegmentJson {
     t0_ns: i64,
-    parts: Vec<(String, i64, i64)>,
+    parts: Vec<Vec<serde_json::Value>>,
     nmkt: usize,
     n_ev: usize,
     n_lv: usize,
@@ -317,7 +355,7 @@ fn check_header(h: &HeaderJson) -> Result<Header> {
         Some(v) => v,
         None => {
             return Err(Error::Unsupported(format!(
-                "version {}, want \"evmin/4\" or \"evmin/5\"",
+                "version {}, want \"evmin/4\", \"evmin/5\" or \"evmin/6\"",
                 h.version
             )))
         }
@@ -325,12 +363,30 @@ fn check_header(h: &HeaderJson) -> Result<Header> {
     if !h.magic.is_empty() && h.magic != "EVM4" {
         return format_err(format!("header magic {:?}", h.magic));
     }
-    if h.family != "rc" || h.layout != "mkt" {
+    let family = if version == Version::V3 {
+        crate::v3::FAMILY
+    } else {
+        "rc"
+    };
+    if h.family != family || h.layout != "mkt" {
         return Err(Error::Unsupported(format!(
-            "family {:?} layout {:?}, want rc / mkt",
-            h.family, h.layout
+            "family {:?} layout {:?}, want {} / mkt",
+            h.family, h.layout, family
         )));
     }
+    let source_version = if version == Version::V3 {
+        match h.src_version.as_deref().and_then(Version::from_header_str) {
+            Some(v @ (Version::V1 | Version::V2)) => Some(v),
+            _ => {
+                return Err(Error::Unsupported(format!(
+                    "v3 src_version {:?}, want \"evmin/4\" or \"evmin/5\"",
+                    h.src_version
+                )))
+            }
+        }
+    } else {
+        None
+    };
     if h.unit_ns != 1000 {
         return Err(Error::Unsupported(format!(
             "unit_ns {}, want 1000",
@@ -362,9 +418,37 @@ fn check_header(h: &HeaderJson) -> Result<Header> {
         has_hash: h.has_hash,
         hour_start_ns: h.hour_start_ns,
         markets_zst: (h.markets_zst.0 as u64, h.markets_zst.1 as u64),
+        profile: if version == Version::V3 {
+            h.profile.clone()
+        } else {
+            None
+        },
+        source_version,
     })
 }
 
+/// A part entry of the header: `[name, offset, length]` in v1 / v2, `[name, offset, length,
+/// codec]` in v3.
+type PartEntry = (String, i64, i64, Option<u32>);
+
+fn part_entry(v: &[serde_json::Value], v3: bool) -> Result<PartEntry> {
+    let want = if v3 { 4 } else { 3 };
+    let bad = || Error::Format(format!("part entry {:?}: want {} fields", v, want));
+    if v.len() != want {
+        return Err(bad());
+    }
+    let name = v[0].as_str().ok_or_else(bad)?.to_string();
+    let off = v[1].as_i64().ok_or_else(bad)?;
+    let len = v[2].as_i64().ok_or_else(bad)?;
+    let codec = if v3 {
+        let c = v[3].as_u64().ok_or_else(bad)?;
+        Some(u32::try_from(c).map_err(|_| bad())?)
+    } else {
+        None
+    };
+    Ok((name, off, len, codec))
+}
+
 /// Lenient base64 (standard alphabet, padding optional).
 fn b64decode(s: &str) -> Result<Vec<u8>> {
     let mut out = Vec::with_capacity(s.len() / 4 * 3);
@@ -483,7 +567,8 @@ impl File {
         let b: &[u8] = &data;
         let (hj, body_off) = parse_header_json(b)?;
         let header = check_header(&hj)?;
-        let v2 = header.version == Version::V2;
+        let is_v3 = header.version == Version::V3;
+        let v2 = header.side_layout() == Version::V2;
         let body_len = b.len() - body_off;
         let rng = |off: i64, n: i64| -> Result<(usize, usize)> {
             if off < 0
@@ -515,14 +600,42 @@ impl File {
             }
             let mut parts = Vec::with_capacity(s.parts.len());
             for p in &s.parts {
-                let (o, n) = rng(p.1, p.2)
-                    .map_err(|e| Error::Format(format!("segment {} part {}: {}", si, p.0, e)))?;
+                let (name, off, len, codec) = part_entry(p, is_v3)
+                    .map_err(|e| Error::Format(format!("segment {}: {}", si, e)))?;
+                let (o, n) = rng(off, len)
+                    .map_err(|e| Error::Format(format!("segment {} part {}: {}", si, name, e)))?;
                 parts.push(Part {
-                    name: p.0.clone(),
+                    name,
                     offset: o as u64,
                     length: n as u64,
+                    codec,
                 });
             }
+            let bitmap =
+                b64decode(&s.ckpt).map_err(|e| Error::Format(format!("segment {}: {}", si, e)))?;
+            if is_v3 {
+                let seg = crate::v3::parse_segment(
+                    &b[body_off..],
+                    si,
+                    crate::v3::SegHead {
+                        t0_ns: s.t0_ns,
+                        nmkt: s.nmkt,
+                        n_ev: s.n_ev,
+                        n_lv: s.n_lv,
+                        n_ck: s.n_ck,
+                        unsynced: s.unsynced.clone().unwrap_or_default(),
+                    },
+                    parts,
+                    bitmap,
+                    v2,
+                )?;
+                if v2 {
+                    check_side_totals(&seg, header.has_hash)
+                        .map_err(|e| Error::Format(format!("segment {}: {}", si, e)))?;
+                }
+                segments.push(seg);
+                continue;
+            }
             let get = |name: &str| -> Result<(usize, usize)> {
                 parts
                     .iter()
@@ -545,8 +658,8 @@ impl File {
                 unsynced: s.unsynced.clone().unwrap_or_default(),
                 parts,
                 blocks,
-                bitmap: b64decode(&s.ckpt)
-                    .map_err(|e| Error::Format(format!("segment {}: {}", si, e)))?,
+                bitmap,
+                v3: None,
             };
             if v2 {
                 check_side_totals(&seg, header.has_hash)
@@ -554,6 +667,17 @@ impl File {
             }
             segments.push(seg);
         }
+        if is_v3 {
+            let mk = |r: Option<(i64, i64)>| -> Result<Option<(usize, usize)>> {
+                r.map(|(o, n)| rng(o, n)).transpose()
+            };
+            crate::v3::check_market_parts(
+                &b[body_off..],
+                mk(hj.mkunits)?,
+                mk(hj.mkslugs)?,
+                &markets,
+            )?;
+        }
         Ok(File {
             data,
             body_off,
@@ -640,6 +764,10 @@ impl File {
         self.order_fast = fast;
     }
 
+    pub(crate) fn is_v3(&self) -> bool {
+        self.header.version == Version::V3
+    }
+
     pub(crate) fn seg(&self, si: usize) -> Result<&Segment> {
         self.segments.get(si).ok_or_else(|| {
             Error::NotFound(format!(

{probe_format-0.1.0 → probe_format-0.2.0}/probe/src/lib.rs

@@ -3,10 +3,15 @@
 //! full-book checkpoint of each market every five minutes.
 //!
 //! The format is specified in `spec/PROBE.md` of the repository. This crate reads Probe v1
-//! (header version `evmin/4`) and v2 (`evmin/5`) completely: the header, the markets table, the
-//! segments and block indexes, every event and level in the reference order, one market through
-//! the block index, and every side stream (trade transaction hashes, JSON payloads, best-price
-//! exceptions, venue book hashes).
+//! (header version `evmin/4`), v2 (`evmin/5`) and v3 (`evmin/6`) completely: the header, the
+//! markets table, the segments and block indexes, every event and level in the reference order,
+//! one market through the block index, and every side stream (trade transaction hashes, JSON
+//! payloads, best-price exceptions, venue book hashes). [`File::open`] detects the version, and
+//! every API below works the same on all three.
+//!
+//! Probe v3 is a container in which every part names its codec. [`v3::transcode`] turns any
+//! v1, v2 or v3 file into a v3 file of a [`v3::Profile`] (`fast`, `fast1`, `rc1`), losslessly:
+//! the result decodes to the same events, levels and side streams, byte for byte.
 //!
 //! ```no_run
 //! use probe_format::File;
@@ -49,6 +54,8 @@
 //! - `arrow`: [`arrow`] record batches of events, levels, markets and `book-max` rows, and Arrow
 //!   IPC output.
 //! - `parquet`: parquet output of `book-max` rows.
+//!
+//! Transcoding to v3 is part of the default build.
 
 #![warn(missing_docs)]
 
@@ -60,6 +67,7 @@ mod event;
 mod file;
 mod query;
 mod rc;
+pub mod v3;
 mod walker;
 
 #[cfg(feature = "arrow")]
@@ -74,6 +82,16 @@ pub use file::{
 };
 pub use query::{Book, Events, Query};
 
+/// Appends v as an unsigned LEB128 varint.
+#[inline]
+pub(crate) fn put_uvarint(out: &mut Vec<u8>, mut v: u64) {
+    while v >= 0x80 {
+        out.push((v as u8) | 0x80);
+        v >>= 7;
+    }
+    out.push(v as u8);
+}
+
 /// Reads an unsigned LEB128 varint: (value, bytes read). `None` when cut short or longer than 10
 /// bytes.
 #[inline]

{probe_format-0.1.0 → probe_format-0.2.0}/probe/src/query.rs

@@ -224,7 +224,7 @@ impl<'a> Query<'a> {
                 let held: Vec<usize> = rows.iter().copied().filter(|&r| s.has_row(r)).collect();
                 if held.is_empty() {
                     Vec::new()
-                } else if self.side && f.header.version == Version::V1 {
+                } else if self.side && f.header.side_layout() == Version::V1 {
                     let all = f.segment_events_opts(si, self.hashes)?;
                     all.into_iter()
                         .filter(|e| e.kind != EventType::Other && held.contains(&e.row))