Learn Rust Coding · Lektion

CRUD-Operationen

Abfragen und ausführen

CRUD-Operationen ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

CRUD with sqlx

CRUD means Create, Read, Update, Delete. sqlx splits these into two execution styles:

fetch_* for queries that return rows
execute for statements that change data

Create (INSERT)

Insert a row with bound parameters and run it via execute. Use RETURNING to get the generated id back.

use sqlx::{Pool, Postgres};

async fn create(pool: &Pool<Postgres>, name: &str) -> i32 {
    let rec = sqlx::query!(
        "INSERT INTO users (name) VALUES ($1) RETURNING id",
        name
    ).fetch_one(pool).await.unwrap();
    rec.id
}

Read one row

fetch_one expects exactly one row and errors otherwise. Use fetch_optional when the row may be absent.

use sqlx::{Pool, Postgres};

async fn find(pool: &Pool<Postgres>, id: i32) -> Option<String> {
    let rec = sqlx::query!("SELECT name FROM users WHERE id = $1", id)
        .fetch_optional(pool)
        .await
        .unwrap();
    rec.map(|r| r.name)
}

Read many rows

fetch_all returns a Vec of all matching rows.

use sqlx::{Pool, Postgres};

async fn all_names(pool: &Pool<Postgres>) -> Vec<String> {
    let rows = sqlx::query!("SELECT name FROM users ORDER BY id")
        .fetch_all(pool)
        .await
        .unwrap();
    rows.into_iter().map(|r| r.name).collect()
}

Update

UPDATE statements use execute, which returns a result carrying the number of affected rows.

use sqlx::{Pool, Postgres};

async fn rename(pool: &Pool<Postgres>, id: i32, name: &str) -> u64 {
    let res = sqlx::query!("UPDATE users SET name = $1 WHERE id = $2", name, id)
        .execute(pool)
        .await
        .unwrap();
    res.rows_affected()
}

Delete

DELETE also uses execute. Check rows_affected() to know whether anything was removed.

use sqlx::{Pool, Postgres};

async fn delete(pool: &Pool<Postgres>, id: i32) -> bool {
    let res = sqlx::query!("DELETE FROM users WHERE id = $1", id)
        .execute(pool)
        .await
        .unwrap();
    res.rows_affected() > 0
}

Modeling CRUD in plain Rust

CRUD against an in-memory map mirrors the same operations sqlx performs against a table.

use std::collections::HashMap;

fn main() {
    let mut users: HashMap<i32, String> = HashMap::new();
    users.insert(1, "Alice".to_string());      // create
    println!("{:?}", users.get(&1));            // read
    users.insert(1, "Alicia".to_string());      // update
    println!("{:?}", users.get(&1));
    users.remove(&1);                            // delete
    println!("{:?}", users.get(&1));
}

Transactions

Group multiple statements atomically with a transaction. Either all succeed on commit or none apply.

use sqlx::{Pool, Postgres};

async fn transfer(pool: &Pool<Postgres>) {
    let mut tx = pool.begin().await.unwrap();
    sqlx::query!("UPDATE acct SET bal = bal - 10 WHERE id = 1")
        .execute(&mut *tx).await.unwrap();
    sqlx::query!("UPDATE acct SET bal = bal + 10 WHERE id = 2")
        .execute(&mut *tx).await.unwrap();
    tx.commit().await.unwrap();
}

Rolling back

If a transaction guard is dropped without commit, sqlx rolls back automatically. You can also call rollback explicitly.

use sqlx::{Pool, Postgres};

async fn maybe(pool: &Pool<Postgres>, ok: bool) {
    let mut tx = pool.begin().await.unwrap();
    sqlx::query!("INSERT INTO log (msg) VALUES ('x')").execute(&mut *tx).await.unwrap();
    if ok { tx.commit().await.unwrap(); } else { tx.rollback().await.unwrap(); }
}

Streaming large reads

For huge result sets, fetch returns a stream so you process rows without loading them all into memory.

use sqlx::{Pool, Postgres};
use futures::TryStreamExt;

async fn stream(pool: &Pool<Postgres>) {
    let mut rows = sqlx::query!("SELECT id FROM big_table").fetch(pool);
    while let Some(row) = rows.try_next().await.unwrap() {
        println!("id {}", row.id);
    }
}

Handling errors

Database calls return Result. Propagate with ? in functions returning Result<_, sqlx::Error> instead of unwrapping.

use sqlx::{Pool, Postgres};

async fn count(pool: &Pool<Postgres>) -> Result<i64, sqlx::Error> {
    let rec = sqlx::query!("SELECT COUNT(*) as n FROM users")
        .fetch_one(pool)
        .await?;
    Ok(rec.n.unwrap_or(0))
}

Quick Check

Test your understanding of CRUD operations.

Recap

You learned CRUD with sqlx:

fetch_one, fetch_optional, fetch_all read rows
execute changes data and reports rows_affected()
RETURNING retrieves generated values
Transactions with begin/commit/rollback ensure atomicity

Next: migrations to evolve the schema.

Häufig gestellte Fragen

Ist die Lektion „CRUD-Operationen“ kostenlos?

Ja — der vollständige Text von „CRUD-Operationen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „CRUD-Operationen“?

Abfragen und ausführen Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „CRUD-Operationen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding