Struct PagedQuery 

pub struct PagedQuery<TRow: Clone + Serialize> {
    pub params: PagedQueryParams,
    pub current_cursor: Option<Cursor>,
    /* private fields */
}

Generic paginator that wraps the circles_query RPC method. The fetcher function is responsible for honoring current_cursor if desired.

Fields

params: PagedQueryParams

Base params to reuse across calls.

current_cursor: Option<Cursor>

Last cursor that was seen (advanced after each page).

Implementations

impl<TRow> PagedQuery<TRow>

where TRow: Clone + Serialize + DeserializeOwned + Send + 'static,

pub fn new(fetch: PagedFetch<TRow>, params: PagedQueryParams) -> Self

pub async fn next_page(&mut self) -> Result<Option<Page<TRow>>>

Fetch the next page. Consumers can track current_cursor to drive cursor-based filters.

Examples found in repository

examples/paged_and_ws.rs (line 46)

async fn main() -> Result<()> {
    let rpc_url = std::env::var("CIRCLES_RPC_URL").unwrap_or_else(|_| DEFAULT_RPC_URL.to_string());
    let rpc = CirclesRpc::try_from(rpc_url.as_str())?;

    let avatar: Address = SAMPLE_AVATAR.parse().expect("valid sample address");

    // --- Paged query example (first page) ---
    let params = PagedQueryParams {
        namespace: "V_Crc".to_string(),
        table: "Avatars".to_string(),
        sort_order: SortOrder::DESC,
        columns: vec!["avatar".into(), "timestamp".into()],
        filter: None,
        cursor_columns: None,
        order_columns: None,
        limit: 10,
    };

    let mut pager = rpc.paged_query::<AvatarRow>(params);
    if let Some(page) = pager.next_page().await? {
        println!(
            "Fetched {} avatar rows (has_more={})",
            page.items.len(),
            page.has_more
        );
        for row in page.items {
            println!("avatar {} @ {}", row.avatar, row.timestamp);
        }
    } else {
        println!("No rows returned");
    }

    // --- WebSocket events example (requires `ws` feature) ---
    #[cfg(feature = "ws")]
    {
        let ws_url =
            std::env::var("CIRCLES_RPC_WS_URL").unwrap_or_else(|_| DEFAULT_WS_URL.to_string());
        match CirclesRpc::try_from_ws(ws_url.as_str()).await {
            Ok(rpc_ws) => stream_events(&rpc_ws, avatar).await?,
            Err(e) => println!("WebSocket connect failed, skipping subscription: {e}"),
        }
    }
    #[cfg(not(feature = "ws"))]
    {
        println!("WebSocket example skipped; enable the `ws` feature to run it.");
    }

    Ok(())
}

pub fn into_stream(self) -> impl Stream<Item = Result<TRow>>

Convert this paginator into a stream of rows.