snapshot of https://github.com/ActivityWatch/aw-server-rust.git (master, 2026-09-16; blobs > 131072B omitted)

aw-query/benches/benchmark.rs

@@ -0,0 +1,127 @@
+use criterion::{criterion_group, criterion_main};
+
+// TODO: Move me to an appropriate place
+#[macro_export]
+macro_rules! json_map {
+    { $( $key:literal : $value:expr),* } => {{
+        use serde_json::Value;
+        use serde_json::map::Map;
+        #[allow(unused_mut)]
+        let mut map : Map<String, Value> = Map::new();
+        $(
+          map.insert( $key.to_string(), json!($value) );
+        )*
+        map
+    }};
+}
+
+#[cfg(test)]
+mod query_benchmarks {
+    use chrono::Duration;
+    use criterion::Criterion;
+    use serde_json::json;
+    use serde_json::Map;
+    use serde_json::Value;
+
+    use aw_datastore::Datastore;
+    use aw_models::Bucket;
+    use aw_models::BucketMetadata;
+    use aw_models::Event;
+    use aw_models::TimeInterval;
+
+    static BUCKETNAME: &str = "testbucket";
+    static TIME_INTERVAL: &str = "1980-01-01T00:00:00Z/2080-01-02T00:00:00Z";
+
+    fn setup_datastore() -> Datastore {
+        Datastore::new_in_memory(false)
+    }
+
+    fn create_bucket(ds: &Datastore, bucketname: String) {
+        let bucket = Bucket {
+            bid: None,
+            id: bucketname,
+            _type: "testtype".to_string(),
+            client: "testclient".to_string(),
+            hostname: "testhost".to_string(),
+            created: Some(chrono::Utc::now()),
+            data: json_map! {},
+            metadata: BucketMetadata::default(),
+            events: None,
+            last_updated: None,
+        };
+        ds.create_bucket(&bucket).unwrap();
+    }
+
+    fn insert_events(ds: &Datastore, bucketname: &str, num_events: i64) {
+        let mut possible_data = Vec::<Map<String, Value>>::new();
+        for i in 0..20 {
+            possible_data.push(json_map! {"number": i});
+        }
+        let mut event_list = Vec::new();
+        for i in 0..num_events {
+            let e = Event {
+                id: None,
+                timestamp: chrono::Utc::now() + Duration::seconds(i),
+                duration: Duration::seconds(10),
+                data: possible_data[i as usize % 20].clone(),
+            };
+            event_list.push(e);
+        }
+        ds.insert_events(bucketname, &event_list).unwrap();
+    }
+
+    pub fn bench_assign(c: &mut Criterion) {
+        let ds = setup_datastore();
+        let interval = TimeInterval::new_from_string(TIME_INTERVAL).unwrap();
+        c.bench_function("bench assign", |b| {
+            b.iter(|| {
+                let code = String::from("return a=1;");
+                match aw_query::query(&code, &interval, &ds).unwrap() {
+                    aw_query::DataType::None() => (),
+                    ref data => panic!("Wrong datatype, {data:?}"),
+                };
+            })
+        });
+    }
+
+    pub fn bench_many_events(c: &mut Criterion) {
+        let ds = setup_datastore();
+        create_bucket(&ds, BUCKETNAME.to_string());
+        insert_events(&ds, BUCKETNAME, 5000);
+
+        let interval = TimeInterval::new_from_string(TIME_INTERVAL).unwrap();
+        c.bench_function("bench many events", |b| {
+            b.iter(|| {
+                let code = String::from(
+                    "
+                events = query_bucket(\"testbucket\");
+                return events;
+                ",
+                );
+                aw_query::query(&code, &interval, &ds).unwrap();
+            })
+        });
+    }
+
+    pub fn bench_read_only_references(c: &mut Criterion) {
+        let ds = setup_datastore();
+        create_bucket(&ds, BUCKETNAME.to_string());
+        insert_events(&ds, BUCKETNAME, 50_000);
+        let interval = TimeInterval::new_from_string(TIME_INTERVAL).unwrap();
+        let code = format!(
+            "events = query_bucket(\"testbucket\"); total = 0; {} return total;",
+            "total = total + sum_durations(events);".repeat(20)
+        );
+        c.bench_function("read-only references 50000 events", |b| {
+            b.iter(|| aw_query::query(&code, &interval, &ds).unwrap())
+        });
+    }
+}
+
+criterion_group!(
+    benches,
+    query_benchmarks::bench_assign,
+    query_benchmarks::bench_many_events,
+    query_benchmarks::bench_read_only_references
+);
+criterion_main!(benches);