Query verificate a compile time
SQL con sicurezza dei tipi
Query verificate a compile time è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.
La funzionalità decisiva
sqlx può verificare il codice SQL al momento della compilazione rispetto allo schema di un database reale. Errori di battitura, nomi di colonne errati e incompatibilità di tipo diventano errori di build.
- Usa la famiglia di macro
query! - Rileva i bug prima dell'esecuzione
query! e query
La funzione query() viene verificata durante l'esecuzione. La macro query! viene verificata al momento della compilazione, connettendosi al database durante la build.
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();
}Campi del risultato tipizzati
La macro query! genera una struct anonima i cui campi corrispondono alle colonne selezionate, con i tipi Rust corretti dedotti dallo schema.
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
}Come funziona la verifica
Durante la build, sqlx richiede un DATABASE_URL attivo oppure una directory .sqlx memorizzata nella cache. Invia la query al DB per determinarne i tipi dei parametri e dei risultati.
Modalità offline con cargo sqlx prepare
Per la CI senza database, esegua cargo sqlx prepare per salvare i metadati delle query in .sqlx/. Le build useranno quindi la cache.
cargo sqlx preparequery_as! nella propria struct
Usi query_as! per mappare direttamente le righe in una struct definita da Lei, mantenendo tutti i controlli.
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()
}Le colonne nullable diventano Option
Se una colonna può contenere NULL, sqlx rende il campo un Option. Può sovrascrivere l'inferenza con annotazioni di tipo come 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
}Rappresentare l'inferenza dei tipi
Il controllo al momento della compilazione associa i tipi SQL ai tipi Rust. Questo esempio eseguibile rappresenta tale scelta di associazione.
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));
}Errori di compilazione che vedrà
Se fa riferimento a una colonna inesistente, sqlx interrompe la build mostrando un messaggio chiaro. Questa sicurezza è proprio lo scopo delle macro.
- Nome di colonna errato → errore al momento della compilazione
- Tipo incompatibile → errore al momento della compilazione
I parametri bind sono posizionali
Usi i segnaposto $1, $2 per Postgres. sqlx verifica il tipo di ogni argomento associato rispetto allo 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();
}Quando usare la forma senza macro
Per SQL dinamico costruito durante l'esecuzione, quando non conosce in anticipo le colonne, usi query() / query_as(). Rinuncia ai controlli in compilazione in cambio della flessibilità.
use sqlx::{Pool, Postgres};
async fn dynamic(pool: &Pool<Postgres>, sql: &str) {
let _ = sqlx::query(sql).execute(pool).await.unwrap();
}Verifica rapida
Verifichi la sua comprensione dei controlli al momento della compilazione.
Riepilogo
Ha imparato a usare query verificate al momento della compilazione:
query!equery_as!verificano l'SQL rispetto allo schema durante la build- I campi e i tipi del risultato vengono dedotti automaticamente
- Le colonne nullable diventano
Option cargo sqlx prepareabilita le build offline- Usi
query()senza macro per l'SQL dinamico
Prossimo argomento: operazioni CRUD.
Domande Frequenti
La lezione «Query verificate a compile time» è gratuita?
Sì — il testo completo di «Query verificate a compile time» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.
Cosa imparerò in «Query verificate a compile time»?
SQL con sicurezza dei tipi Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn Rust Coding?
Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Query verificate a compile time»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?
Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Connessione a un database
- Query verificate a compile time
- Operazioni CRUD
- Migrazioni