Rust Client

cargo add geode-client

use geode_client::Client;

#[tokio::main]
async fn main() -> geode_client::Result<()> {
    let client = Client::new("localhost", 3141).skip_verify(true);
    let mut conn = client.connect().await?;

    let (page, _) = conn.query("MATCH (p:Person) RETURN p.name AS name").await?;
    for row in page.rows {
        let name = row.get("name").unwrap().as_string()?;
        println!("{}", name);
    }

    conn.close()?;
    Ok(())
}

use geode_client::Client;

let client = Client::from_dsn("localhost:3141")?;
let client = Client::from_dsn("localhost:3141?insecure_tls_skip_verify=true&page_size=500")?;
let client = Client::from_dsn("quic://admin:secret@localhost:3141?insecure_tls_skip_verify=true")?;

use geode_client::Client;

let client = Client::new("localhost", 3141)
    .skip_verify(true)
    .page_size(2000)
    .client_name("my-app")
    .client_version("0.1.0")
    .conformance("full")
    .username("admin")
    .password("secret");

let (page, _) = conn.query("MATCH (n) RETURN n").await?;
for row in page.rows {
    let obj = row.get("n").unwrap().as_object()?;
    println!("{:?}", obj);
}

conn.begin().await?;

let (page, _) = conn.query("CREATE (:Person {name: 'Alice'})").await?;
let _ = page;

conn.commit().await?;

let sp = conn.savepoint("before_risky_op")?;
if let Err(_) = conn.query("CREATE (:Invalid)").await {
    conn.rollback_to(&sp).await?;
}

use geode_client::{PreparedStatement, Value};
use std::collections::HashMap;

let stmt = conn.prepare("MATCH (p:Person {id: $id}) RETURN p")?;

let mut params = HashMap::new();
params.insert("id".to_string(), Value::int(42));

let (page, _) = stmt.execute(&mut conn, &params).await?;

use geode_client::{QueryBuilder, Value};
use std::collections::HashMap;

let (query, params_json) = QueryBuilder::new()
    .match_pattern("(p:Person)")
    .where_clause("p.age >= $min_age")
    .return_(&["p.name AS name", "p.age AS age"])
    .with_param("min_age", 21)
    .build();

let params: HashMap<String, Value> = params_json
    .into_iter()
    .map(|(k, v)| (k, Value::from_json(v)))
    .collect();

let (page, _) = conn.query_with_params(&query, &params).await?;

let plan = conn.explain("MATCH (p:Person) RETURN p").await?;
let profile = conn.profile("MATCH (p:Person) RETURN p").await?;

use geode_client::ConnectionPool;

let pool = ConnectionPool::new("localhost", 3141, 10).skip_verify(true);
let mut conn = pool.acquire().await?;
let (page, _) = conn.query("RETURN 1 AS ok").await?;

use geode_client::Value;

let (page, _) = conn.query("RETURN 42 AS answer").await?;
let value: &Value = page.rows[0].get("answer").unwrap();
println!("{}", value.as_int()?);