0Pricing
Learn Rust Coding · Lekcja

Zapytania sprawdzane podczas kompilacji

SQL bezpieczny typowo

Zapytania sprawdzane podczas kompilacji to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 2 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.

Najważniejsza funkcja

sqlx może sprawdzać poprawność SQL podczas kompilacji względem rzeczywistego schematu bazy danych. Literówki, nieprawidłowe nazwy kolumn i niezgodności typów stają się błędami kompilacji.

  • Używa rodziny makr query!
  • Wykrywa błędy przed uruchomieniem programu

query! a query

Funkcja query() jest sprawdzana podczas działania programu. Makro query! jest sprawdzane podczas kompilacji przez połączenie z bazą danych w trakcie budowania.

use sqlx::{Pool, Postgres};

async fn run(pool: &Pool<Postgres>) {
    let rec = sqlx::query!("SELECT id, name FROM users WHERE id = $1", 1i32)
        .fetch_one(pool)
        .await
        .unwrap();
}

Typowane pola wyników

Makro query! generuje anonimową strukturę, której pola odpowiadają wybranym kolumnom i mają poprawne typy Rust wywnioskowane ze schematu.

use sqlx::{Pool, Postgres};

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

Jak działa sprawdzanie

Podczas budowania sqlx potrzebuje działającego DATABASE_URL albo buforowanego katalogu .sqlx. Wysyła zapytanie do bazy danych, aby poznać typy parametrów i wyników.

Tryb offline z cargo sqlx prepare

W przypadku CI bez bazy danych uruchom cargo sqlx prepare, aby zapisać metadane zapytań w .sqlx/. Następne kompilacje będą korzystać z pamięci podręcznej.

cargo sqlx prepare

query_as! do własnej struktury

Użyj query_as!, aby bezpośrednio mapować wiersze na zdefiniowaną przez siebie strukturę, zachowując pełne sprawdzanie.

use sqlx::{Pool, Postgres};

struct User { id: i32, name: String }

async fn get(pool: &Pool<Postgres>) -> User {
    sqlx::query_as!(User, "SELECT id, name FROM users WHERE id = $1", 1i32)
        .fetch_one(pool)
        .await
        .unwrap()
}

Kolumny dopuszczające NULL stają się Option

Jeśli kolumna może mieć wartość NULL, sqlx tworzy dla niej pole typu Option. Wnioskowanie można zmienić za pomocą adnotacji typów, takich jak name as "name!".

use sqlx::{Pool, Postgres};

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

Modelowanie wnioskowania typów

Sprawdzanie podczas kompilacji mapuje typy SQL na typy Rust. Ten uruchamialny przykład modeluje decyzję dotyczącą tego mapowania.

fn rust_type(sql: &str, nullable: bool) -> String {
    let base = match sql {
        "int4" => "i32",
        "text" => "String",
        "bool" => "bool",
        _ => "unknown",
    };
    if nullable { format!("Option<{}>", base) } else { base.to_string() }
}

fn main() {
    println!("{}", rust_type("int4", false));
    println!("{}", rust_type("text", true));
}

Błędy kompilacji, które zobaczysz

Jeśli odwołasz się do nieistniejącej kolumny, sqlx przerwie budowanie z czytelnym komunikatem. To bezpieczeństwo jest głównym celem tych makr.

  • Nieprawidłowa nazwa kolumny → błąd podczas kompilacji
  • Niezgodność typów → błąd podczas kompilacji

Parametry są wiązane pozycyjnie

W przypadku Postgresa użyj symboli zastępczych $1, $2. sqlx sprawdza typ każdego powiązanego argumentu względem schematu.

use sqlx::{Pool, Postgres};

async fn search(pool: &Pool<Postgres>, name: &str, min_age: i32) {
    let _ = sqlx::query!(
        "SELECT id FROM users WHERE name = $1 AND age >= $2",
        name, min_age
    ).fetch_all(pool).await.unwrap();
}

Kiedy używać formy bez makra

W przypadku dynamicznego SQL tworzonego podczas działania programu, gdy z wyprzedzeniem nie znasz kolumn, użyj query() / query_as(). Zyskujesz elastyczność kosztem sprawdzania podczas kompilacji.

use sqlx::{Pool, Postgres};

async fn dynamic(pool: &Pool<Postgres>, sql: &str) {
    let _ = sqlx::query(sql).execute(pool).await.unwrap();
}

Szybki test

Sprawdź swoją wiedzę na temat sprawdzania podczas kompilacji.

Podsumowanie

Nauczyłeś się korzystać z zapytań sprawdzanych podczas kompilacji:

  • query! i query_as! sprawdzają SQL względem schematu podczas budowania
  • Pola wyników i ich typy są wnioskowane automatycznie
  • Kolumny dopuszczające wartość NULL stają się typu Option
  • cargo sqlx prepare umożliwia budowanie offline
  • Do dynamicznego SQL używaj formy bez makra: query()

Następnie: operacje CRUD.

Często zadawane pytania

Czy lekcja „Zapytania sprawdzane podczas kompilacji” jest bezpłatna?

Tak — pełny tekst „Zapytania sprawdzane podczas kompilacji” 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 „Zapytania sprawdzane podczas kompilacji”?

SQL bezpieczny typowo Ć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 2 z 4.

Ile czasu zajmuje lekcja „Zapytania sprawdzane podczas kompilacji”?

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

  1. Łączenie z bazą danych
  2. Zapytania sprawdzane podczas kompilacji
  3. Operacje CRUD
  4. Migracje
← Powrót do Learn Rust Coding