Learn Rust Coding · Lekcja

Operacje CRUD

Wykonywanie zapytań i operacji

Operacje CRUD to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

CRUD z sqlx

CRUD oznacza Create, Read, Update, Delete, czyli tworzenie, odczytywanie, aktualizowanie i usuwanie. sqlx dzieli te operacje na dwa sposoby wykonywania:

fetch_* służy do zapytań zwracających wiersze
execute służy do instrukcji zmieniających dane

Tworzenie (INSERT)

Wstaw wiersz za pomocą parametrów wiązanych i wykonaj operację przez execute. Użyj RETURNING, aby otrzymać z powrotem wygenerowany identyfikator.

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
}

Odczytywanie jednego wiersza

fetch_one oczekuje dokładnie jednego wiersza i zgłasza błąd w przeciwnym razie. Użyj fetch_optional, gdy wiersz może nie istnieć.

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)
}

Odczytywanie wielu wierszy

fetch_all zwraca Vec zawierający wszystkie pasujące wiersze.

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()
}

Aktualizowanie

Instrukcje UPDATE używają execute, które zwraca wynik zawierający liczbę zmodyfikowanych wierszy.

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()
}

Usuwanie

Instrukcje DELETE również używają execute. Sprawdź rows_affected(), aby dowiedzieć się, czy cokolwiek usunięto.

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
}

Modelowanie CRUD w czystym Rust

Operacje CRUD na mapie przechowywanej w pamięci odzwierciedlają te same operacje, które sqlx wykonuje na tabeli.

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));
}

Transakcje

Połącz wiele instrukcji atomowo za pomocą transakcji. Wszystkie zakończą się powodzeniem po commit albo żadna nie zostanie zastosowana.

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();
}

Wycofywanie zmian

Jeśli strażnik transakcji zostanie usunięty bez wywołania commit, sqlx automatycznie wycofa transakcję. Możesz też jawnie wywołać rollback.

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(); }
}

Strumieniowe odczyty dużych zbiorów

W przypadku ogromnych zbiorów wyników fetch zwraca strumień, dzięki czemu można przetwarzać wiersze bez ładowania ich wszystkich do pamięci.

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);
    }
}

Obsługa błędów

Wywołania bazy danych zwracają Result. Propaguj błędy za pomocą ? w funkcjach zwracających Result<_, sqlx::Error>, zamiast używać unwrap.

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))
}

Szybki test

Sprawdź swoją wiedzę na temat operacji CRUD.

Podsumowanie

Nauczyłeś się korzystać z CRUD w sqlx:

fetch_one, fetch_optional i fetch_all służą do odczytywania wierszy
execute zmienia dane i raportuje wartość rows_affected()
RETURNING pobiera wygenerowane wartości
Transakcje z użyciem begin/commit/rollback zapewniają atomowość

Następnie: migracje służące do rozwijania schematu.

Często zadawane pytania

Czy lekcja „Operacje CRUD” jest bezpłatna?

Tak — pełny tekst „Operacje CRUD” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „Operacje CRUD”?

Wykonywanie zapytań i operacji Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Operacje CRUD”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding