answer history len and contains server-side

len() and `in` on the remote history and its sub-collections downloaded
the entire history to answer a scalar question. The server's History type
gains contains (by timestamp, optionally with the event id), and the
timestamps, event-id and intervals sub-views gain count and contains; the
client asks those instead. Membership takes whatever converts to an
EventTime, exactly as locally — a bare int means (t, event_id=0), and a
naive datetime is not a member and never reaches the wire.

Author: shivamka1

python/tests/test_base_install/test_graphql/parity/test_parity_rpc_counts.py

@@ -702,6 +702,36 @@ def test_list_builtin_adds_the_length_hint_len_rpc(counted):
     ),
     "history.t.len": (lambda rg: rg.node("a").history.t, lambda t: len(t), 1),
     "history.t.contains": (lambda rg: rg.node("a").history.t, lambda t: 1 in t, 1),
+    "history.event_id.contains": (
+        lambda rg: rg.node("a").history.event_id,
+        lambda e: 0 in e,
+        1,
+    ),
+    "history.intervals.len": (
+        lambda rg: rg.node("a").history.intervals,
+        lambda i: len(i),
+        1,
+    ),
+    "history.intervals.contains": (
+        lambda rg: rg.node("a").history.intervals,
+        lambda i: 1 in i,
+        1,
+    ),
+    "history.dt.contains": (
+        lambda rg: rg.node("a").history.dt,
+        lambda d: __import__("datetime").datetime(
+            1970, 1, 1, tzinfo=__import__("datetime").timezone.utc
+        )
+        in d,
+        1,
+    ),
+    # A naive datetime is not UTC-convertible, so it is simply not a member —
+    # answered client-side with no wire trip at all.
+    "history.dt.contains_naive": (
+        lambda rg: rg.node("a").history.dt,
+        lambda d: __import__("datetime").datetime(1970, 1, 1) in d,
+        0,
+    ),
     "nodes.len": (lambda rg: rg.nodes, lambda ns: len(ns), 1),
     "nodes.bool": (lambda rg: rg.nodes, lambda ns: bool(ns), 1),
     "edges.len": (lambda rg: rg.edges, lambda es: len(es), 1),

raphtory-graphql/schema.graphql

@@ -3036,6 +3036,12 @@ type History {
 	"""
 	count: Int!
 	"""
+	Whether an entry equal to the given time is present. With `eventId`,
+	an entry must match both the timestamp and the event id; without it,
+	any entry at the timestamp matches.
+	"""
+	contains(timestamp: Int!, eventId: Int): Boolean!
+	"""
 	Returns a HistoryTimestamp object which accesses timestamps (milliseconds since the Unix epoch)
 	instead of EventTime entries.
 	"""
@@ -3152,6 +3158,14 @@ type HistoryDateTime {
 History object that provides access to event ids instead of `EventTime` entries.
 """
 type HistoryEventId {
+	"""
+	Get the number of event ids (one per entry).
+	"""
+	count: Int!
+	"""
+	Whether the given value is present among the event ids.
+	"""
+	contains(value: Int!): Boolean!
 	"""
 	List event ids.
 	"""
@@ -3208,6 +3222,14 @@ type HistoryEventId {
 History object that provides access to timestamps (milliseconds since the Unix epoch) instead of `EventTime` entries.
 """
 type HistoryTimestamp {
+	"""
+	Get the number of timestamps (one per entry).
+	"""
+	count: Int!
+	"""
+	Whether the given value is present among the timestamps.
+	"""
+	contains(value: Int!): Boolean!
 	"""
 	List all timestamps.
 	"""
@@ -3275,6 +3297,15 @@ input InputEdge {
 Provides access to the intervals between temporal entries of an object.
 """
 type Intervals {
+	"""
+	Get the number of intervals (one per consecutive pair of entries,
+	so one less than the history's count; zero for an empty history).
+	"""
+	count: Int!
+	"""
+	Whether the given value is present among the intervals.
+	"""
+	contains(value: Int!): Boolean!
 	"""
 	List time intervals between consecutive timestamps in milliseconds.
 	"""

raphtory-graphql/src/client/graphql_transport.rs

@@ -1105,6 +1105,24 @@ fn render_read_into(
             render_read_into(input, vars, out)?;
             out.push_str(" { reverse");
         }
+        ReadExpr::HistoryContains {
+            input,
+            timestamp,
+            event_id,
+        } => {
+            render_read_into(input, vars, out)?;
+            match event_id {
+                Some(event_id) => write!(
+                    out,
+                    " {{ contains(timestamp: {timestamp}, eventId: {event_id})"
+                )?,
+                None => write!(out, " {{ contains(timestamp: {timestamp})")?,
+            }
+        }
+        ReadExpr::HistoryValueContains { input, value } => {
+            render_read_into(input, vars, out)?;
+            write!(out, " {{ contains(value: {value})")?;
+        }
         ReadExpr::Deletions { input } => {
             render_read_into(input, vars, out)?;
             out.push_str(" { deletions");
@@ -1943,6 +1961,8 @@ fn read_depth(expr: &ReadExpr) -> usize {
         | ReadExpr::History { input }
         | ReadExpr::CombinedHistory { input }
         | ReadExpr::HistoryReverse { input }
+        | ReadExpr::HistoryContains { input, .. }
+        | ReadExpr::HistoryValueContains { input, .. }
         | ReadExpr::Deletions { input }
         | ReadExpr::Nodes { input }
         | ReadExpr::Neighbours { input }
@@ -3119,6 +3139,8 @@ fn parse_read(expr: &ReadExpr, root: &JsonValue) -> Result<Option<Prop>, ClientE
         // Bool-shaped terminals.
         ReadExpr::HasNode { .. }
         | ReadExpr::HasEdge { .. }
+        | ReadExpr::HistoryContains { .. }
+        | ReadExpr::HistoryValueContains { .. }
         | ReadExpr::IsActive { .. }
         | ReadExpr::IsValid { .. }
         | ReadExpr::IsDeleted { .. }
@@ -3286,6 +3308,14 @@ fn build_json_path(expr: &ReadExpr) -> Vec<&'static str> {
                 go(input, out);
                 out.push("reverse");
             }
+            ReadExpr::HistoryContains { input, .. } => {
+                go(input, out);
+                out.push("contains");
+            }
+            ReadExpr::HistoryValueContains { input, .. } => {
+                go(input, out);
+                out.push("contains");
+            }
             ReadExpr::Deletions { input } => {
                 go(input, out);
                 out.push("deletions");
@@ -4102,6 +4132,8 @@ fn child_input(expr: &ReadExpr) -> Option<&ReadExpr> {
         | ReadExpr::History { input }
         | ReadExpr::CombinedHistory { input }
         | ReadExpr::HistoryReverse { input }
+        | ReadExpr::HistoryContains { input, .. }
+        | ReadExpr::HistoryValueContains { input, .. }
         | ReadExpr::Deletions { input }
         | ReadExpr::Nodes { input }
         | ReadExpr::Neighbours { input }

raphtory-graphql/src/client/op.rs

@@ -127,6 +127,19 @@ pub enum ReadExpr {
     /// `History` whose iteration order is flipped. Container-selection like
     /// `History`. Server field: `reverse`.
     HistoryReverse { input: Arc<ReadExpr> },
+    /// Terminal on History: whether an entry equal to the given time is
+    /// present — `bool`. With `event_id`, both fields must match; without it,
+    /// any entry at the timestamp matches (the two equalities `EventTime`
+    /// itself defines). Server field: `contains(timestamp:, eventId:)`.
+    HistoryContains {
+        input: Arc<ReadExpr>,
+        timestamp: i64,
+        event_id: Option<usize>,
+    },
+    /// Terminal on a history sub-container (timestamps / event ids /
+    /// intervals): whether the given value is present — `bool`. Server
+    /// field: `contains(value:)`.
+    HistoryValueContains { input: Arc<ReadExpr>, value: i64 },
     /// Navigate to the deletion history of an edge. Edge → History.
     /// Same shape as `History` but reads the `deletions` server field
     /// instead of `history` — deletions are edge-only.

raphtory-graphql/src/client/remote/remote_history.rs

@@ -155,6 +155,22 @@ impl RemoteHistory {
         )
     }
 
+    /// Terminal: whether an entry equal to the given time is present. With
+    /// `event_id`, both fields must match; without it, any entry at the
+    /// timestamp matches. Fires one RPC — the check runs server-side.
+    pub async fn contains(
+        &self,
+        timestamp: i64,
+        event_id: Option<usize>,
+    ) -> Result<bool, ClientError> {
+        let op = Op::Read(ReadExpr::HistoryContains {
+            input: self.expr.clone(),
+            timestamp,
+            event_id,
+        });
+        expect_bool(self.transport.execute(&op).await?, "contains")
+    }
+
     /// Sub-container: timestamps view of this history — plain integer
     /// timestamps instead of full `EventTime` records. Lazy — no RPC.
     pub fn timestamps(&self) -> RemoteHistoryTimestamps {
@@ -228,6 +244,25 @@ pub struct RemoteHistoryTimestamps {
 }
 
 impl RemoteHistoryTimestamps {
+    /// Terminal: number of values in this container. Fires one RPC — the
+    /// count comes back alone, not the values.
+    pub async fn count(&self) -> Result<i64, ClientError> {
+        let op = Op::Read(ReadExpr::Count {
+            input: self.expr.clone(),
+        });
+        expect_i64(self.transport.execute(&op).await?, "count")
+    }
+
+    /// Terminal: whether the given value is present. Fires one RPC — the
+    /// membership check runs server-side.
+    pub async fn contains(&self, value: i64) -> Result<bool, ClientError> {
+        let op = Op::Read(ReadExpr::HistoryValueContains {
+            input: self.expr.clone(),
+            value,
+        });
+        expect_bool(self.transport.execute(&op).await?, "contains")
+    }
+
     /// Reversed view of this container. Lazy — no RPC: the reversal wraps the
     /// parent history (the server's `reverse` field), so downstream reads and
     /// any future optimised iterators compose with it automatically.
@@ -307,6 +342,25 @@ pub struct RemoteHistoryEventIds {
 }
 
 impl RemoteHistoryEventIds {
+    /// Terminal: number of values in this container. Fires one RPC — the
+    /// count comes back alone, not the values.
+    pub async fn count(&self) -> Result<i64, ClientError> {
+        let op = Op::Read(ReadExpr::Count {
+            input: self.expr.clone(),
+        });
+        expect_i64(self.transport.execute(&op).await?, "count")
+    }
+
+    /// Terminal: whether the given value is present. Fires one RPC — the
+    /// membership check runs server-side.
+    pub async fn contains(&self, value: i64) -> Result<bool, ClientError> {
+        let op = Op::Read(ReadExpr::HistoryValueContains {
+            input: self.expr.clone(),
+            value,
+        });
+        expect_bool(self.transport.execute(&op).await?, "contains")
+    }
+
     /// Reversed view of this container. Lazy — no RPC: the reversal wraps the
     /// parent history (the server's `reverse` field), so downstream reads and
     /// any future optimised iterators compose with it automatically.
@@ -399,6 +453,25 @@ fn to_datetimes(timestamps: Vec<i64>) -> Result<Vec<DateTime<Utc>>, ClientError>
 }
 
 impl RemoteHistoryDateTimes {
+    /// Terminal: number of datetimes (one per event). Fires one RPC.
+    pub async fn count(&self) -> Result<i64, ClientError> {
+        let op = Op::Read(ReadExpr::Count {
+            input: self.expr.clone(),
+        });
+        expect_i64(self.transport.execute(&op).await?, "count")
+    }
+
+    /// Terminal: whether an event exists at the given epoch-millisecond
+    /// timestamp — datetimes are derived 1:1 from timestamps, so membership
+    /// is checked on the timestamp container. Fires one RPC.
+    pub async fn contains_ms(&self, value: i64) -> Result<bool, ClientError> {
+        let op = Op::Read(ReadExpr::HistoryValueContains {
+            input: self.expr.clone(),
+            value,
+        });
+        expect_bool(self.transport.execute(&op).await?, "contains")
+    }
+
     /// Reversed view of this container. Lazy — no RPC: the reversal wraps the
     /// parent history (the server's `reverse` field), so downstream reads and
     /// any future optimised iterators compose with it automatically.
@@ -485,6 +558,25 @@ pub struct RemoteIntervals {
 }
 
 impl RemoteIntervals {
+    /// Terminal: number of values in this container. Fires one RPC — the
+    /// count comes back alone, not the values.
+    pub async fn count(&self) -> Result<i64, ClientError> {
+        let op = Op::Read(ReadExpr::Count {
+            input: self.expr.clone(),
+        });
+        expect_i64(self.transport.execute(&op).await?, "count")
+    }
+
+    /// Terminal: whether the given value is present. Fires one RPC — the
+    /// membership check runs server-side.
+    pub async fn contains(&self, value: i64) -> Result<bool, ClientError> {
+        let op = Op::Read(ReadExpr::HistoryValueContains {
+            input: self.expr.clone(),
+            value,
+        });
+        expect_bool(self.transport.execute(&op).await?, "contains")
+    }
+
     /// Reversed view of this container. Lazy — no RPC: the reversal wraps the
     /// parent history (the server's `reverse` field), so downstream reads and
     /// any future optimised iterators compose with it automatically.

raphtory-graphql/src/model/graph/history.rs

@@ -10,6 +10,7 @@ use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
 use raphtory::db::api::view::history::{
     History, HistoryDateTime, HistoryEventId, HistoryTimestamp, InternalHistoryOps, Intervals,
 };
+use raphtory_api::core::storage::timeindex::EventTime;
 use std::{any::Any, sync::Arc};
 
 /// History of updates for an object in Raphtory.
@@ -151,6 +152,21 @@ impl GqlHistory {
         blocking_compute(move || self_clone.history.len() as u64).await
     }
 
+    /// Whether an entry equal to the given time is present. With `eventId`,
+    /// an entry must match both the timestamp and the event id; without it,
+    /// any entry at the timestamp matches.
+    async fn contains(&self, timestamp: i64, event_id: Option<usize>) -> bool {
+        let self_clone = self.clone();
+        blocking_compute(move || match event_id {
+            Some(event_id) => self_clone
+                .history
+                .iter()
+                .any(|x| x == EventTime::new(timestamp, event_id)),
+            None => self_clone.history.iter().any(|x| x == timestamp),
+        })
+        .await
+    }
+
     /// Returns a HistoryTimestamp object which accesses timestamps (milliseconds since the Unix epoch)
     /// instead of EventTime entries.
     async fn timestamps(&self) -> GqlHistoryTimestamp {
@@ -213,6 +229,18 @@ pub struct GqlHistoryTimestamp {
 
 #[ResolvedObjectFields]
 impl GqlHistoryTimestamp {
+    /// Get the number of timestamps (one per entry).
+    async fn count(&self) -> u64 {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.history_t.iter().count() as u64).await
+    }
+
+    /// Whether the given value is present among the timestamps.
+    async fn contains(&self, value: i64) -> bool {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.history_t.iter().any(|v| v == value)).await
+    }
+
     /// List all timestamps.
     async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<i64>> {
         check_list_allowed(ctx)?;
@@ -500,6 +528,18 @@ pub struct GqlHistoryEventId {
 
 #[ResolvedObjectFields]
 impl GqlHistoryEventId {
+    /// Get the number of event ids (one per entry).
+    async fn count(&self) -> u64 {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.history_s.iter().count() as u64).await
+    }
+
+    /// Whether the given value is present among the event ids.
+    async fn contains(&self, value: u64) -> bool {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.history_s.iter().any(|v| v as u64 == value)).await
+    }
+
     /// List event ids.
     async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<u64>> {
         check_list_allowed(ctx)?;
@@ -602,6 +642,19 @@ pub struct GqlIntervals {
 
 #[ResolvedObjectFields]
 impl GqlIntervals {
+    /// Get the number of intervals (one per consecutive pair of entries,
+    /// so one less than the history's count; zero for an empty history).
+    async fn count(&self) -> u64 {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.intervals.iter().count() as u64).await
+    }
+
+    /// Whether the given value is present among the intervals.
+    async fn contains(&self, value: i64) -> bool {
+        let self_clone = self.clone();
+        blocking_compute(move || self_clone.intervals.iter().any(|v| v == value)).await
+    }
+
     /// List time intervals between consecutive timestamps in milliseconds.
     async fn list(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<i64>> {
         check_list_allowed(ctx)?;