@@ -93,7 +93,7 @@ ua-parser = "0.2"
 url = "2.5"
 
 # database
-duckdb = { version = "=1.10506", features = ["bundled", "chrono", "r2d2"] }
+duckdb = { version = "1.20000", features = ["bundled", "chrono", "r2d2"] }
 maxminddb = { version = "0.32", optional = true }
 mimalloc = { version = "0.1" }
 r2d2 = { version = "0.8", default-features = false }
 
@@ -73,6 +73,17 @@ fn benchmark_reports(c: &mut Criterion) {
         group.finish();
     }
 
+    {
+        let mut group = c.benchmark_group("custom_events_report");
+        configure_group(&mut group);
+        group.bench_function("counts", |b| {
+            b.iter(|| {
+                reports::custom_events_report(&conn, &entities, &range, &[], 100).expect("custom_events_report failed")
+            });
+        });
+        group.finish();
+    }
+
     {
         let mut group = c.benchmark_group("dimension_report");
         configure_group(&mut group);
 
@@ -360,11 +360,10 @@ fn update_event_times(conn: &Connection, from_time: DateTime<Utc>, entities: &[S
     }
 
     let entity_vars = repeat_vars(entities.len());
-    // this can probably be simplified, sadly the where clause can't contain window functions
     let sql = format!("--sql
         with
             filtered_events as (
-                select *
+                select rowid, entity_id, visitor_group_id, created_at
                 from events
                 where event = 'pageview' and entity_id in ({entity_vars}) and (created_at >= ?::timestamp or visitor_group_id in (
                     select visitor_group_id
@@ -374,19 +373,17 @@ fn update_event_times(conn: &Connection, from_time: DateTime<Utc>, entities: &[S
             ),
             cte as (
                 select
-                    entity_id,
-                    visitor_group_id,
-                    created_at,
-                    created_at - lag(created_at) over (partition by entity_id, visitor_group_id order by created_at) as time_from_last_event,
-                    lead(created_at) over (partition by entity_id, visitor_group_id order by created_at) - created_at as time_to_next_event
+                    rowid,
+                    created_at - lag(created_at) over (partition by entity_id, visitor_group_id order by created_at, rowid) as time_from_last_event,
+                    lead(created_at) over (partition by entity_id, visitor_group_id order by created_at, rowid) - created_at as time_to_next_event
                 from filtered_events
             )
         update events
             set
                 time_from_last_event = cte.time_from_last_event,
                 time_to_next_event = cte.time_to_next_event
             from cte
-            where events.event = 'pageview' and events.entity_id = cte.entity_id and events.visitor_group_id = cte.visitor_group_id and events.created_at = cte.created_at;
+            where events.rowid = cte.rowid;
     ");
 
     let mut params = ParamVec::new();
@@ -404,6 +401,61 @@ mod tests {
     use crate::app::Liwan;
     use crate::config::Config;
 
+    #[test]
+    fn failed_append_does_not_update_cache() {
+        let app = Liwan::new_memory(Config::default()).unwrap();
+        let conn = app.events_conn().unwrap();
+        conn.execute_batch("create unique index unique_visitor on events(visitor_group_id)").unwrap();
+        let entities = ["entity-1".into()];
+        assert!(!app.events.custom_data(&entities).unwrap().events);
+        let mut first = event(Utc::now());
+        first.event = "signup".into();
+        let second = first.clone();
+
+        assert!(app.events.append([first, second].into_iter()).is_err());
+
+        assert_eq!(conn.query_row("select count(*) from events", [], |row| row.get::<_, u64>(0)).unwrap(), 0);
+        assert!(!app.events.custom_data(&entities).unwrap().events);
+    }
+
+    #[test]
+    fn session_updates_identify_individual_rows() {
+        let app = Liwan::new_memory(Config::default()).unwrap();
+        let conn = app.events_conn().unwrap();
+        conn.execute_batch(
+            "insert into events (entity_id, visitor_group_id, event, created_at)
+             values ('a', 'visitor', 'pageview', '2026-01-01 00:00:00'),
+                    ('a', 'visitor', 'pageview', '2026-01-01 00:00:00'),
+                    ('a', 'visitor', 'pageview', '2026-01-01 00:01:00'),
+                    ('b', 'visitor', 'pageview', '2026-01-01 00:00:00'),
+                    ('b', 'visitor', 'pageview', '2026-01-01 00:02:00'),
+                    ('a', 'visitor', 'signup', '2026-01-01 00:00:30'),
+                    ('c', 'visitor', 'pageview', '2026-01-01 00:00:00')",
+        )
+        .unwrap();
+        let from = "2026-01-01T00:00:00Z".parse().unwrap();
+        update_event_times(&conn, from, &["a".into(), "b".into()]).unwrap();
+        let rows = conn
+            .prepare("select epoch(time_from_last_event)::bigint, epoch(time_to_next_event)::bigint from events order by rowid")
+            .unwrap()
+            .query_map([], |row| Ok((row.get::<_, Option<i64>>(0)?, row.get::<_, Option<i64>>(1)?)))
+            .unwrap()
+            .collect::<DuckResult<Vec<_>>>()
+            .unwrap();
+        assert_eq!(
+            rows,
+            vec![
+                (None, Some(0)),
+                (Some(0), Some(60)),
+                (Some(60), None),
+                (None, Some(120)),
+                (Some(120), None),
+                (None, None),
+                (None, None)
+            ]
+        );
+    }
+
     fn event(created_at: DateTime<Utc>) -> Event {
         Event {
             entity_id: "entity-1".to_string(),
 
@@ -101,6 +101,16 @@ mod tests {
         assert_eq!(report.rows[0].completions, 3);
         assert_eq!(report.rows[0].uniques, 2);
 
+        let report = custom_events_report(&conn, &["a".into(), "b".into()], &range, &[], 10).unwrap();
+        assert!(!report.truncated);
+        assert_eq!(report.rows.len(), 2);
+        assert_eq!(report.rows[0].completions, 4);
+        assert_eq!(report.rows[0].uniques, 3);
+
+        let report = custom_events_report(&conn, &["a".into()], &range, &[], 0).unwrap();
+        assert!(report.truncated);
+        assert!(report.rows.is_empty());
+
         let empty = DateRange { start: now - Duration::hours(3), end: now - Duration::hours(2) };
         assert!(custom_events_report(&conn, &["a".into()], &empty, &[], 10).unwrap().rows.is_empty());
 
 
@@ -66,9 +66,7 @@ pub fn dimension_report(
         Dimension::Orientation => ("orientation", None),
         Dimension::Property => match property_key {
             None => ("unnest(map_keys(properties))", Some("properties is not null".to_string())),
-            Some(_) => {
-                ("map_extract_value(properties, ?)", Some("map_extract_value(properties, ?) is not null".to_string()))
-            }
+            Some(_) => ("map_extract_value(properties, ?)", Some("map_contains(properties, ?)".to_string())),
         },
     };
     let filters_sql = match (filters_sql.is_empty(), dimension_scope_sql) {
@@ -330,6 +328,7 @@ mod tests {
         assert_eq!(report("pageview", None, &[]), [row("plan", 3.0), row("ref", 1.0)]);
         assert_eq!(report("signup", None, &[]), [row("source", 1.0)]);
         assert_eq!(report("pageview", Some("plan"), &[]), [row("free", 1.0), row("pro", 2.0)]);
+        assert!(report("pageview", Some("missing"), &[]).is_empty());
 
         let filter = |key: &str, filter_type: FilterType, value: Option<&str>| DimensionFilter {
             dimension: Dimension::Property,
 
@@ -198,25 +198,15 @@ pub fn overall_report(
 					e.entity_id in ({entity_vars})
 					{filters_sql}
 			),
-			bucketed_events as (
+			event_bins as (
 				select
 					tb.bucket_idx,
-					sd.visitor_group_id,
-					sd.created_at,
-					sd.time_from_last_event,
-					sd.time_to_next_event,
-					sd.exited_at
-				from (select * from session_data order by created_at) sd
-				asof join (select * from time_bins order by bin_start) tb
+					{metric_sql} as metric_value
+				from session_data sd
+				asof join time_bins tb
 					on sd.created_at >= tb.bin_start
 				where sd.created_at < tb.bin_end
-			),
-			event_bins as (
-				select
-					sd.bucket_idx,
-					{metric_sql} as metric_value
-				from bucketed_events sd
-				group by sd.bucket_idx
+				group by tb.bucket_idx
 			)
 		select
 			tb.bin_start,
@@ -392,6 +382,42 @@ mod tests {
         assert_eq!(values, vec![1.0, 1.0]);
     }
 
+    #[test]
+    fn overall_report_handles_irregular_buckets() {
+        let app = Liwan::new_memory(Config::default()).unwrap();
+        let conn = app.events_conn().unwrap();
+        let start = local_datetime(Tz::UTC, 2024, 1, 1, 0, 0);
+        for (visitor, hours, previous, next, exit) in [
+            ("outside", -1, None, None, None),
+            ("one", 0, None, Some(60), None),
+            ("one", 1, Some(60), None, Some(120)),
+            ("gap", 4, None, None, None),
+            ("two", 5, None, None, Some(30)),
+            ("boundary", 6, None, None, None),
+        ] {
+            conn.execute(
+                "insert into events (entity_id, visitor_group_id, event, created_at, time_from_last_event, time_to_next_event, exited_at)
+                 values ('entity-1', ?, 'pageview', ?, ? * interval '1 second', ? * interval '1 second', ?)",
+                duckdb::params![visitor, start + Duration::hours(hours), previous, next, exit.map(|seconds| start + Duration::hours(hours) + Duration::seconds(seconds))],
+            ).unwrap();
+        }
+        let range = DateRange { start: start - Duration::hours(2), end: start + Duration::hours(10) };
+        let buckets: Vec<_> = [(0, 2), (5, 6), (7, 8)]
+            .into_iter()
+            .map(|(from, to)| DateRange { start: start + Duration::hours(from), end: start + Duration::hours(to) })
+            .collect();
+        for (metric, expected) in [
+            (Metric::Views, vec![2.0, 1.0, 0.0]),
+            (Metric::UniqueVisitors, vec![1.0, 1.0, 0.0]),
+            (Metric::BounceRate, vec![0.0, 1.0, 0.0]),
+            (Metric::AvgTimeOnSite, vec![90.0, 30.0, 0.0]),
+        ] {
+            let report =
+                overall_report(&conn, &["entity-1".into()], "pageview", &range, &buckets, &[], &metric).unwrap();
+            assert_eq!(report.iter().map(|point| point.value).collect::<Vec<_>>(), expected);
+        }
+    }
+
     #[test]
     fn build_graph_buckets_rejects_excessive_ranges() {
         let start = local_datetime(Tz::UTC, 2024, 1, 1, 0, 0);