Embedding

# For an in memory database
cargo add surrealdb --features kv-mem

# For a SurrealKV database on disk
cargo add surrealdb --features kv-surrealkv

cargo add tokio --features macros,rt-multi-thread

use surrealdb::types::{RecordId, SurrealValue};
use surrealdb::Surreal;

// For an in memory database
use surrealdb::engine::local::Mem;

// For a SurrealKV database on disk
// use surrealdb::engine::local::SurrealKv;

#[derive(Debug, SurrealValue)]
struct Name {
    first: String,
    last: String,
}

#[derive(Debug, SurrealValue)]
struct Person {
    title: String,
    name: Name,
    marketing: bool,
}

#[derive(Debug, SurrealValue)]
struct Responsibility {
    marketing: bool,
}

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

#[tokio::main]
async fn main() -> surrealdb::Result<()> {
    // Create database connection in memory
    let db = Surreal::new::<Mem>(()).await?;
    
    // Create database connection using SurrealKV
    // let db = Surreal::new::<SurrealKv>("path/to/database-folder").await?;

    // Select a specific namespace / database
    db.use_ns("main").use_db("main").await?;

    // Create a new person with a random id
    let created: Option<Record> = db
        .create("person")
        .content(Person {
            title: "Founder & CEO".to_string(),
            name: Name {
                first: "Tobie".to_string(),
                last: "Morgan Hitchcock".to_string(),
            },
            marketing: true,
        })
        .await?;
    dbg!(created);

    // Update a person record with a specific id
    let updated: Option<Record> = db
        .update(("person", "jaime"))
        .merge(Responsibility { marketing: true })
        .await?;
    dbg!(updated);

    // Select all people records
    let people: Vec<Record> = db.select("person").await?;
    dbg!(people);

    // Perform a custom advanced query
    let groups = db
        .query("SELECT marketing, count() FROM type::table($table) GROUP BY marketing")
        .bind(("table", "person"))
        .await?;
    dbg!(groups);

    Ok(())
}

cargo run

use tracing_subscriber::EnvFilter;

#[tokio::main]
async fn main() -> surrealdb::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .init();

    // Connect and query as usual
    Ok(())
}

RUST_LOG=surrealdb=info cargo run

[profile.release-trace]
inherits = "release"
debug-assertions = true

RUST_LOG=surrealdb=trace cargo run --profile release-trace

static DB: LazyLock<Surreal<Client>> = LazyLock::new(Surreal::init);

#[tokio::main]
async fn main() -> surrealdb::Result<()> {
    // Connect to the database
    DB.connect::<Wss>("cloud.surrealdb.com").await?;
    // Select a namespace + database
    DB.use_ns("main").use_db("main").await?;
    // Create or update a specific record
    let tobie: Option<Record> = DB
        .update(("person", "tobie"))
        .content(Person { name: "Tobie" })
        .await?;
    Ok(())
}

// Connect to a local endpoint
DB.connect::<Ws>("127.0.0.1:8000").await?;
// Connect to a remote endpoint
DB.connect::<Wss>("cloud.surrealdb.com").await?;

let db = Surreal::new::<Ws>("127.0.0.1:8000").await?;

db.use_ns("main").use_db("main").await?;

use surrealdb::opt::auth::Record;
use surrealdb::types::SurrealValue;

#[derive(SurrealValue)]
struct Credentials {
    email: String,
    pass: String,
}

let jwt = db.signup(Record {
    namespace: "main".to_string(),
    database: "main".to_string(),
    access: "user".to_string(),
    params: Credentials {
        email: "info@surrealdb.com".to_string(),
        pass: "123456".to_string(),
    },
}).await?;

// ⚠️: It is important to note that the token should be handled securely
// and protected from unauthorised access.
let token = jwt.access.as_insecure_token();

use surrealdb::opt::auth::Record;
use surrealdb::types::SurrealValue;

#[derive(SurrealValue)]
struct Credentials {
    email: String,
    pass: String,
}

let jwt = db.signin(Record {
    namespace: "main".to_string(),
    database: "main".to_string(),
    access: "user".to_string(),
    params: Credentials {
        email: "info@surrealdb.com".to_string(),
        pass: "123456".to_string(),
    },
}).await?;

// ⚠️: It is important to note that the token should be handled securely
// and protected from unauthorised access.
let token = jwt.access.as_insecure_token();

db.invalidate().await?;

db.authenticate(jwt).await?;

// Assign the variable on the connection
db.set("name", Name {
    first: "Tobie",
    last: "Morgan Hitchcock",
}).await?;
// Use the variable in a subsequent query
db.query("CREATE person SET name = $name").await?;
// Use the variable in a subsequent query
db.query("SELECT * FROM person WHERE name.first = $name.first").await?;

// Run some queries
let sql = "
    CREATE person;
    SELECT * FROM type::table($table);
";
let mut result = db
    .query(sql)
    .bind(("table", "person"))
    .await?;
// Get the first result from the first query
let created: Option<Person> = result.take(0)?;
// Get all of the results from the second query
let people: Vec<Person> = result.take(1)?;

// Select all records from a table
let people: Vec<Person> = db.select("person").await?;
// Select a specific record from a table
let person: Option<Person> = db.select(("person", "h5wxrf2ewk8xjxosxtyc")).await?;

SELECT * FROM $resource;

// Create a record with a random ID
let person: Option<Person> = db.create("person").await?;
// Create a record with a specific ID
let record: Record = db
    .create(("person", "tobie"))
    .content(Person {
        name: "Tobie",
        settings: {
            active: true,
            marketing: true,
       },
    }).await?;

CREATE $resource CONTENT $data;

// Update all records in a table
let people: Vec<Person> = db.update("person").await?;
// Update a record with a specific ID
let person: Option<Person> = db
    .update(("person", "tobie"))
    .content(Person {
        name: "Tobie",
        settings: {
            active: true,
            marketing: true,
        },
    }).await?;

UPDATE $resource CONTENT $data;

// Update all records in a table
let people: Vec<Person> = db.update("person")
    .merge(Document {
        updated_at: Datetime::default(),
    })
    .await?;
// Update a record with a specific ID
let person: Option<Person> = db.update(("person", "tobie"))
    .merge(Document {
        updated_at: Datetime::default(),
        settings: Settings {
            active: true,
        },
    })
    .await?;

UPDATE $resource MERGE $data;

// Update all records in a table
let people: Vec<Person> = db.update("person")
    .patch(PatchOp::replace("/created_at", Datetime::default()))
    .await?;

// Update a record with a specific ID
let person: Option<Person> = db.update(("person", "tobie"))
    .patch(PatchOp::replace("/settings/active", false))
    .patch(PatchOp::add("/tags", &["developer", "engineer"]))
    .patch(PatchOp::remove("/temp"))
    .await?;

UPDATE $resource PATCH $data;

// Delete all records from a table
let people: Vec<Person> = db.delete("person").await?;
// Delete a specific record from a table
let person: Option<Person> = db.delete(("person", "h5wxrf2ewk8xjxosxtyc")).await?;

DELETE FROM $resource RETURN BEFORE;