Struct Db 

pub struct Db { /* private fields */ }

Implementations

impl Db

pub async fn connect(url: &str) -> Result<Self, Error>

Open a pool against the given SQLite URL.

Foreign-key enforcement is always on (PRAGMA foreign_keys = ON applied on every connection via sqlx’s connect-time hook). SQLite ignores FK constraints unless this pragma is set per-connection, and relying on user configuration to enable it is unsafe — ON DELETE CASCADE in the schema would silently do nothing.

pub async fn memory() -> Result<Self, Error>

Open an in-memory pool with FK enforcement on.

Limited to a single connection because each :memory: connection opens its own database; multiple would not share rows.

Examples found in repository

examples/admin_demo.rs (line 23)

async fn main() -> std::io::Result<()> {
    let db = Db::memory().await.expect("db connect");
    auth::ensure_core_tables(&db)
        .await
        .expect("create auth tables");

    auth::user::create(&db, "admin@example.com", "admin", "admin")
        .await
        .expect("seed admin user");

    seed_demo_data(&db).await;

    let router = with_defaults(Router::new()).wrap(authenticate(db.clone()));
    // No `.model::<T>()` calls: the new engine uses its own
    // `AdminUiModel` registry (Users + Orders are wired in by
    // `Admin::register`). The legacy AdminModel + macro path is
    // intentionally not exercised here so there is exactly one
    // admin surface in the demo.
    let router = Admin::new().register(router, &db);

    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    eprintln!("admin demo: open http://{addr}/admin and sign in as admin@example.com / admin");
    Server::bind(addr).serve_router(router).await
}

examples/orm_demo.rs (line 34)

async fn main() -> Result<(), Error> {
    let db = Db::memory().await?;
    db.execute(
        "CREATE TABLE users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            is_admin INTEGER NOT NULL
        )",
    )
    .await?;

    let alice_id = User {
        id: 0,
        name: "Alice".into(),
        is_admin: false,
    }
    .create(&db)
    .await?;
    let bob_id = User {
        id: 0,
        name: "Bob".into(),
        is_admin: true,
    }
    .create(&db)
    .await?;
    println!("created ids: alice={alice_id} bob={bob_id}");

    let alice = User::find(&db, alice_id).await?.expect("alice");
    println!("find alice: {alice:?}");

    let all = User::all(&db).await?;
    println!("all: {all:?}");

    let renamed = User {
        id: alice_id,
        name: "Alicia".into(),
        is_admin: false,
    };
    renamed.update(&db).await?;
    let after_update = User::find(&db, alice_id).await?.unwrap();
    println!("after update: {after_update:?}");

    User::delete(&db, bob_id).await?;
    println!("remaining after delete bob: {:?}", User::all(&db).await?);

    Ok(())
}

examples/homepage.rs (line 52)

async fn main() -> std::io::Result<()> {
    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    let db = Db::memory().await.expect("db connect");
    auth::ensure_core_tables(&db)
        .await
        .expect("create auth tables");
    auth::user::create(&db, "admin@example.com", "admin", "admin")
        .await
        .expect("seed admin user");

    let router = with_defaults(Router::new())
        .get("/whoami", |req, _params| async move {
            let id = req
                .ctx()
                .get::<RequestId>()
                .map(|r| r.0.to_string())
                .unwrap_or_else(|| "unknown".into());
            Ok::<Response, Error>(text(format!("your request id is req-{id}\n")))
        })
        .get("/me", |req, _params| async move {
            let id = require_auth(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello {}\n", id.email)))
        })
        .get("/admin-only", |req, _params| async move {
            let id = require_admin(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello admin {}\n", id.email)))
        })
        .get("/crash", |_req, _params| async {
            Err::<Response, Error>(Error::Internal("simulated failure".into()))
        })
        .get("/unauth", |_req, _params| async {
            Err::<Response, Error>(Error::Unauthorized)
        })
        .wrap(request_id)
        .wrap(authenticate(db))
        .wrap(logger);
    Server::bind(addr).serve_router(router).await
}

pub async fn execute(&self, sql: &str) -> Result<(), Error>

Examples found in repository

examples/orm_demo.rs (lines 35-41)

async fn main() -> Result<(), Error> {
    let db = Db::memory().await?;
    db.execute(
        "CREATE TABLE users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            is_admin INTEGER NOT NULL
        )",
    )
    .await?;

    let alice_id = User {
        id: 0,
        name: "Alice".into(),
        is_admin: false,
    }
    .create(&db)
    .await?;
    let bob_id = User {
        id: 0,
        name: "Bob".into(),
        is_admin: true,
    }
    .create(&db)
    .await?;
    println!("created ids: alice={alice_id} bob={bob_id}");

    let alice = User::find(&db, alice_id).await?.expect("alice");
    println!("find alice: {alice:?}");

    let all = User::all(&db).await?;
    println!("all: {all:?}");

    let renamed = User {
        id: alice_id,
        name: "Alicia".into(),
        is_admin: false,
    };
    renamed.update(&db).await?;
    let after_update = User::find(&db, alice_id).await?.unwrap();
    println!("after update: {after_update:?}");

    User::delete(&db, bob_id).await?;
    println!("remaining after delete bob: {:?}", User::all(&db).await?);

    Ok(())
}

examples/admin_demo.rs (lines 58-67)

async fn seed_demo_data(db: &Db) {
    db.execute(
        "CREATE TABLE IF NOT EXISTS admin_new_demo_users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            username TEXT NOT NULL,
            email TEXT NOT NULL,
            is_active TEXT NOT NULL DEFAULT 'false',
            doctor_id TEXT,
            salary_amount TEXT
        )",
    )
    .await
    .expect("create users table");

    db.execute(
        "CREATE TABLE IF NOT EXISTS admin_new_demo_orders (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            order_number TEXT,
            customer_email TEXT,
            total_amount TEXT,
            is_paid TEXT
        )",
    )
    .await
    .expect("create orders table");

    let user_inserts = "INSERT INTO admin_new_demo_users \
         (username, email, is_active, doctor_id, salary_amount) VALUES \
         ('amansour',  'abdulwahed@rustio.dev', 'true',  '1', '5400'), \
         ('b.hassan',  'bashayer@rustio.dev',   'true',  '1', '4800'), \
         ('sara_m',    'sara@rustio.dev',       'true',  '2', '3600'), \
         ('l.nguyen',  'linh@example.com',      'true',  '1', '5100'), \
         ('k.ito',     'kenji@example.com',     'true',  '2', '3200'), \
         ('m.osei',    'maya@example.com',      'true',  '2', '3000'), \
         ('r.silva',   'rafael@example.com',    'false', '1', '2800'), \
         ('p.kapoor',  'priya@example.com',     'true',  '2', '4200'), \
         ('n.eriksson','nils@example.com',      'true',  '1', '3900'), \
         ('z.ahmed',   'zainab@example.com',    'false', '2', '2100')";
    let _ = db.execute(user_inserts).await;

    let order_inserts = "INSERT INTO admin_new_demo_orders \
         (order_number, customer_email, total_amount, is_paid) VALUES \
         ('RIO-1001', 'abdulwahed@rustio.dev', '129.00', 'true'), \
         ('RIO-1002', 'bashayer@rustio.dev',   '89.50',  'true'), \
         ('RIO-1003', 'sara@rustio.dev',       '245.00', 'false'), \
         ('RIO-1004', 'linh@example.com',      '320.00', 'true'), \
         ('RIO-1005', 'kenji@example.com',     '57.25',  'false'), \
         ('RIO-1006', 'maya@example.com',      '412.10', 'true'), \
         ('RIO-1007', 'rafael@example.com',    '76.40',  'false'), \
         ('RIO-1008', 'priya@example.com',     '199.99', 'true'), \
         ('RIO-1009', 'nils@example.com',      '88.00',  'true'), \
         ('RIO-1010', 'zainab@example.com',    '33.00',  'false')";
    let _ = db.execute(order_inserts).await;
}

Trait Implementations

impl Clone for Db

fn clone(&self) -> Db

Returns a duplicate of the value.

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

Performs copy-assignment from source.