re_query 0.31.4

High-level query APIs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::sync::Arc;

use anyhow::Context as _;
use arrow::array::UInt32Array as ArrowUInt32Array;
use itertools::Itertools as _;
use re_arrow_util::ArrowArrayDowncastRef as _;
use re_chunk::{Chunk, RowId, TimelineName};
use re_chunk_store::{ChunkStore, ChunkStoreHandle, LatestAtQuery};
use re_log_types::build_frame_nr;
use re_log_types::example_components::{MyColor, MyLabel, MyPoint, MyPoints};
use re_query::{LatestAtResults, clamped_zip_1x2};
use re_types_core::Archetype as _;

// ---

fn main() -> anyhow::Result<()> {
    let store = store()?;
    eprintln!("store:\n{store}");

    let entity_path = "points";
    let timeline = TimelineName::new("frame_nr");
    let query = LatestAtQuery::latest(timeline);
    eprintln!("query:{query:?}");

    let caches = re_query::QueryCache::new(store.clone());

    // First, get the (potentially cached) results for this query.
    let results: LatestAtResults = caches.latest_at(
        &query,
        &entity_path.into(),
        MyPoints::all_component_identifiers(),
    );

    // The results can be accessed either through the low-level Chunk APIs, or the higher-level helpers.

    // Example of accessing the data using the higher-level APIs.
    //
    // These APIs will log errors instead of returning them.
    {
        let points = results
            .component_batch::<MyPoint>(MyPoints::descriptor_points().component)
            .context("missing")?;
        let colors = results
            .component_batch::<MyColor>(MyPoints::descriptor_colors().component)
            .unwrap_or_default();
        let labels = results
            .component_batch::<MyLabel>(MyPoints::descriptor_labels().component)
            .unwrap_or_default();

        // Then apply your instance-level joining logic, if any:
        let color_default_fn = || MyColor(0xFF00FFFF);
        let label_default_fn = || MyLabel("N/A".to_owned());
        let results = clamped_zip_1x2(points, colors, color_default_fn, labels, label_default_fn)
            .collect_vec();

        eprintln!("results 1:\n{results:#?}");
    }

    // Example of accessing the data using the Chunk APIs.
    //
    // Because a latest-at query can only ever return a single row's worth of data for each
    // individual component, the chunks returned here will be so-called unit chunks, which are
    // guaranteed to only contain a single row.
    {
        // * `get_required` returns an error if the chunk is missing.
        // * `get` returns an option.
        let points = results.get_required(MyPoints::descriptor_points().component)?;
        let colors = results.get(MyPoints::descriptor_colors().component);
        let labels = results.get(MyPoints::descriptor_labels().component);

        // You can always use the standard deserialization path:
        let points = points
            .component_batch::<MyPoint>(MyPoints::descriptor_points().component)
            .context("missing")??;
        let labels = labels
            .and_then(|unit| {
                unit.component_batch::<MyLabel>(MyPoints::descriptor_labels().component)?
                    .ok()
            })
            .unwrap_or_default();

        // Or, if you want every last bit of performance you can get, you can manipulate the raw
        // data directly:
        let colors = colors
            .context("missing")?
            .component_batch_raw(MyPoints::descriptor_colors().component)
            .context("invalid")?;
        let colors = colors
            .downcast_array_ref::<ArrowUInt32Array>()
            .context("invalid")?;
        let colors = colors.values().iter().map(|&color| MyColor(color));

        // And finally apply your instance-level joining logic, if any:
        let color_default_fn = || MyColor(0xFF00FFFF);
        let label_default_fn = || MyLabel("N/A".to_owned());
        let results = clamped_zip_1x2(points, colors, color_default_fn, labels, label_default_fn)
            .collect_vec();

        eprintln!("results 2:\n{results:#?}");
    }

    Ok(())
}

// ---

fn store() -> anyhow::Result<ChunkStoreHandle> {
    let store = ChunkStore::new_handle(
        re_log_types::StoreId::random(re_log_types::StoreKind::Recording, "test_app"),
        Default::default(),
    );

    let entity_path = "points";

    {
        let timepoint = [build_frame_nr(123)];

        let chunk = Chunk::builder(entity_path)
            .with_archetype(
                RowId::new(),
                timepoint,
                &MyPoints::new([MyPoint::new(1.0, 2.0), MyPoint::new(3.0, 4.0)])
                    .with_colors([MyColor::from_rgb(255, 0, 0)])
                    .with_labels([MyLabel("a".into()), MyLabel("b".into())]),
            )
            .build()?;

        store.write().insert_chunk(&Arc::new(chunk))?;
    }

    Ok(store)
}