Learning SurrealDB + Rust

sdb_4.rs

#![allow(unused)]
use serde::{Deserialize, Serialize};
use std::str::FromStr;
use surrealdb::dbs::Response;
use surrealdb::dbs::Status;
use surrealdb::err::Error;
use surrealdb::opt::PatchOp;
use surrealdb::sql::{Thing, Value};

#[derive(Debug, Deserialize, Serialize)]
struct Driver {
    name: String,
}

#[derive(Debug, Deserialize)]
struct Record {
    #[allow(dead_code)]
    id: Thing,
}

#[tokio::main]
async fn main() -> surrealdb::Result<()> {
    let db = surrealdb::engine::any::connect("ws://127.0.0.1:8000").await?;
    db.use_ns("test").use_db("test").await?;

    let _rm_driver = db.query("REMOVE TABLE driver").await?;
    let _rm_team = db.query("REMOVE TABLE team").await?;
    let _rm_won_monaco = db.query("REMOVE TABLE won_monaco").await?;

    db.query("CREATE driver:1 SET name='perez'")
        .await?
        .check()?;
    db.query("CREATE driver:2 SET name='verstappen'")
        .await?
        .check()?;
    db.query("CREATE driver:3 SET name='sainz'")
        .await?
        .check()?;
    db.query("CREATE driver:4 SET name='leclerc'")
        .await?
        .check()?;
    db.query("CREATE driver:5 SET name='ricciardo'")
        .await?
        .check()?;

    db.query("CREATE team:1 SET name='redbull'")
        .await?
        .check()?;
    db.query("CREATE team:2 SET name='ferrari'")
        .await?
        .check()?;
    db.query("CREATE team:3 SET name='rb'").await?.check()?;

    db.query("RELATE driver:1->won_monaco->team:redbull")
        .await?
        .check()?;
    db.query("RELATE driver:2->won_monaco->team:redbull")
        .await?
        .check()?;
    db.query("RELATE driver:5->won_monaco->team:redbull")
        .await?
        .check()?;

    let _res: Result<surrealdb::Response, surrealdb::Error> =
        db.query("SELECT in.name from won_monaco;").await;

    let _res2: Result<surrealdb::Response, surrealdb::Error> = db
        .query("SELECT count() FROM driver WHERE ->won_monaco GROUP ALL")
        .await;

    let res3: Result<surrealdb::Response, surrealdb::Error> = db
        .query("SELECT name,->won_monaco.out as won from driver")
        .await;
    dbg!(res3);


    /// -------- print a value from the response -------------------
    // let's use type:thing {converts a value into a record pointer definition}
    let res4: Vec<Record> = db
        .query("UPDATE ONLY type::thing($id) SET name = $name")
        .bind(("name", "sainZy"))
        .bind(("id", "driver:3"))
        .await
        .expect("issue on await")
        .take(0)
        .expect("issue on take");

    // get the first element of res4
    let result = match res4.first() {
        Some(Record { id }) => Ok(id.to_string()),
        _ => Err("couldnt get id".to_string()),
    };
    /// ------------------------------------------------------------

    println!("{:?} has been updated", result);

    

    // Update a record with a specific ID
    let driver: Option<Driver> = db
        .update(("driver", 1))
        .content(Driver {
            name: "perezzz".into(),
        })
        .await?;

    Ok(())
}