Learn Rust Coding · Lektion

Zur Compile-Zeit geprüfte Queries

Typsicheres SQL

Zur Compile-Zeit geprüfte Queries ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Das entscheidende Feature

sqlx kann Ihr SQL zur Compile-Zeit anhand eines echten Datenbankschemas überprüfen. Tippfehler, falsche Spaltennamen und Typkonflikte werden zu Build-Fehlern.

Verwendet die Makrofamilie query!
Findet Fehler vor der Laufzeit

query! im Vergleich zu query

Die Funktion query() wird zur Laufzeit geprüft. Das Makro query! wird zur Compile-Zeit geprüft, indem während des Builds eine Verbindung zur Datenbank hergestellt wird.

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

Typisierte Ergebnisfelder

Das Makro query! erzeugt eine anonyme Struktur, deren Felder den ausgewählten Spalten entsprechen und deren korrekte Rust-Typen aus dem Schema abgeleitet werden.

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
}

So funktioniert die Prüfung

Zur Build-Zeit benötigt sqlx entweder eine erreichbare DATABASE_URL oder ein zwischengespeichertes .sqlx-Verzeichnis. Es sendet die Abfrage an die Datenbank, um die Typen ihrer Parameter und Ergebnisse zu ermitteln.

Offline-Modus mit cargo sqlx prepare

Führen Sie für CI ohne Datenbank cargo sqlx prepare aus, um Metadaten der Abfragen in .sqlx/ zu speichern. Builds verwenden anschließend den Cache.

cargo sqlx prepare

query_as! in Ihre Struktur

Verwenden Sie query_as!, um Zeilen direkt in eine von Ihnen definierte Struktur zu übertragen; die Abfrage wird weiterhin vollständig geprüft.

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

NULL-Spalten werden zu Option

Wenn eine Spalte NULL enthalten kann, macht sqlx das Feld zu einem Option. Sie können die Ableitung mit Typannotationen wie name as "name!" überschreiben.

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
}

Typableitung modellieren

Die Prüfung zur Compile-Zeit ordnet SQL-Typen Rust-Typen zu. Dieses ausführbare Beispiel modelliert diese Zuordnungsentscheidung.

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

Compile-Fehler, die Sie sehen werden

Wenn Sie auf eine nicht vorhandene Spalte verweisen, bricht sqlx den Build mit einer verständlichen Meldung ab. Genau dafür sind die Makros gedacht.

Falscher Spaltenname → Fehler zur Compile-Zeit
Typkonflikt → Fehler zur Compile-Zeit

Gebundene Parameter sind positionsbezogen

Verwenden Sie für Postgres die Platzhalter $1 und $2. sqlx prüft den Typ jedes gebundenen Arguments gegen das Schema.

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

Wann Sie die Variante ohne Makro verwenden sollten

Verwenden Sie für dynamisches SQL, das zur Laufzeit erstellt wird und dessen Spalten Sie im Voraus nicht kennen, query() / query_as(). Dafür verzichten Sie zugunsten der Flexibilität auf Prüfungen zur Compile-Zeit.

use sqlx::{Pool, Postgres};

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

Kurzer Test

Testen Sie Ihr Verständnis der Prüfung zur Compile-Zeit.

Zusammenfassung

Sie haben zur Compile-Zeit geprüfte Abfragen kennengelernt:

query! und query_as! überprüfen SQL beim Build anhand des Schemas
Ergebnisfelder und Typen werden automatisch abgeleitet
Nullable-Spalten werden zu Option
cargo sqlx prepare ermöglicht Offline-Builds
Verwenden Sie query() ohne Makro für dynamisches SQL

Als Nächstes: CRUD-Operationen.

Häufig gestellte Fragen

Ist die Lektion „Zur Compile-Zeit geprüfte Queries“ kostenlos?

Ja — der vollständige Text von „Zur Compile-Zeit geprüfte Queries“ 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 „Zur Compile-Zeit geprüfte Queries“?

Typsicheres SQL 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 2 von 4.

Wie lange dauert die Lektion „Zur Compile-Zeit geprüfte Queries“?

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