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

//! Demonstrates basic usage of the dataframe APIs.

use itertools::Itertools;

use rerun::{
    dataframe::{EntityPathFilter, QueryEngine, QueryExpression, SparseFillStrategy, Timeline},
    external::arrow,
    external::re_format_arrow::format_record_batch,
    ChunkStoreConfig, StoreKind, VersionPolicy,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args = std::env::args().collect_vec();

    let get_arg = |i| {
        let Some(value) = args.get(i) else {
            let bin_name = args.first().map_or("$BIN", |s| s.as_str());
            eprintln!(
                "{}",
                unindent::unindent(&format!(
                    "\
                    Usage: {bin_name} <path_to_rrd> [entity_path_filter]

                    This example will query for the first 10 rows of data in your recording of choice,
                    and display the results as a table in your terminal.

                    You can use one of your recordings, or grab one from our hosted examples, e.g.:
                    curl 'https://app.rerun.io/version/latest/examples/dna.rrd' -o - > /tmp/dna.rrd

                    The results can be filtered further by specifying an entity filter expression:
                    {bin_name} my_recording.rrd /helix/structure/**\
                    ",
                )),
            );
            std::process::exit(1);
        };
        value
    };

    let path_to_rrd = get_arg(1);
    let entity_path_filter = EntityPathFilter::try_from(args.get(2).map_or("/**", |s| s.as_str()))?;
    let timeline = Timeline::log_time();

    let engines = QueryEngine::from_rrd_filepath(
        &ChunkStoreConfig::DEFAULT,
        path_to_rrd,
        VersionPolicy::Warn,
    )?;

    for (store_id, engine) in engines {
        if store_id.kind != StoreKind::Recording {
            continue;
        }

        let query = QueryExpression {
            filtered_index: Some(timeline),
            view_contents: Some(
                engine
                    .iter_entity_paths_sorted(&entity_path_filter)
                    .map(|entity_path| (entity_path, None))
                    .collect(),
            ),
            sparse_fill_strategy: SparseFillStrategy::LatestAtGlobal,
            ..Default::default()
        };

        let query_handle = engine.query(query.clone());
        let record_batches = query_handle.batch_iter().take(10).collect_vec();

        let batch = arrow::compute::concat_batches(query_handle.schema(), &record_batches)?;
        println!("{}", format_record_batch(&batch));
    }

    Ok(())
}