Struct Query 

pub struct Query {
    pub key_prefix: String,
    pub predicate: String,
    pub value: String,
    pub json: Option<Value>,
}

Fields

key_prefix: String

predicate: String

value: String

json: Option<Value>

Implementations

impl Query

pub fn all(prefix: &[u8]) -> Self

Examples found in repository

examples/local_bench.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    assert_eq!(
        args.len(),
        3,
        "ADDRESS PREFIX COUNT on a disposable console"
    );
    let client = Client::new(args[0].parse()?)?;
    let count = args[2].parse::<usize>()?;
    assert!((1..=128).contains(&count));
    let query = Query::all(args[1].as_bytes());
    let session = client.subscribe(&query)?;
    assert!(session.rows.is_empty());
    let started = Instant::now();
    for i in 0..count {
        let key = format!("{}{i:04}", args[1]);
        let read = client.read_revision(key.as_bytes())?;
        assert!(read.value.is_none());
        let value = json!({"client":"rust","n":i}).to_string();
        let receipt = client.write_revision(&read.revision, Some(value.as_bytes()))?;
        assert!(receipt.durable);
    }
    let write_us = started.elapsed().as_micros();
    let started = Instant::now();
    let page = client.page(&query, None, 128)?;
    assert_eq!(page.rows.len(), count);
    let page_us = started.elapsed().as_micros();
    let started = Instant::now();
    let delta = client.poll(&session, &session.token)?;
    assert_eq!(delta.commits.len(), count);
    let poll_us = started.elapsed().as_micros();
    client.unsubscribe(&session, &delta.token)?;
    println!(
        "{}",
        json!({"client":"rust","records":count,"revision_read_write_us":write_us,"page_us":page_us,"poll_us":poll_us,"correctness_verified":true})
    );
    Ok(())
}

pub fn json(prefix: &[u8], predicate: Value) -> Self

Trait Implementations

impl Clone for Query

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Query

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Query

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Query

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.