0Pricing
Learn Rust Coding · Leçon

Requêtes vérifiées à la compilation

SQL garantissant la sûreté des types

Requêtes vérifiées à la compilation est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.

La fonctionnalité phare

sqlx peut vérifier votre SQL au moment de la compilation par rapport au schéma réel d’une base de données. Les fautes de frappe, les noms de colonnes incorrects et les incompatibilités de types deviennent des erreurs de compilation.

  • Utilise la famille de macros query!
  • Détecte les bogues avant l’exécution

query! ou query

La fonction query() est vérifiée à l’exécution. La macro query! est vérifiée à la compilation en se connectant à la base de données pendant la construction.

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

Champs de résultat typés

La macro query! génère une structure anonyme dont les champs correspondent aux colonnes sélectionnées, avec les types Rust corrects déduits du schéma.

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
}

Fonctionnement de la vérification

Lors de la construction, sqlx a besoin soit d’un DATABASE_URL actif, soit d’un répertoire .sqlx mis en cache. Il envoie la requête à la base de données pour connaître les types de ses paramètres et de son résultat.

Mode hors ligne avec cargo sqlx prepare

Pour la CI sans base de données, exécutez cargo sqlx prepare afin d’enregistrer les métadonnées des requêtes dans .sqlx/. Les constructions utilisent alors le cache.

cargo sqlx prepare

query_as! dans votre structure

Utilisez query_as! pour mapper directement les lignes dans une structure que vous définissez, tout en conservant une vérification complète.

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

Les colonnes nullables deviennent des Option

Si une colonne peut être NULL, sqlx fait du champ un Option. Vous pouvez remplacer l’inférence avec des annotations de type comme 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
}

Modélisation de l’inférence des types

La vérification à la compilation associe les types SQL aux types Rust. Cet exemple exécutable modélise cette décision d’association.

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

Erreurs de compilation que vous verrez

Si vous faites référence à une colonne inexistante, sqlx échoue lors de la construction en affichant un message clair. C’est précisément l’objectif de sécurité des macros.

  • Nom de colonne incorrect → erreur à la compilation
  • Incompatibilité de types → erreur à la compilation

Les paramètres liés sont positionnels

Utilisez les paramètres fictifs $1 et $2 pour Postgres. sqlx vérifie le type de chaque argument lié par rapport au schéma.

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

Quand utiliser la forme sans macro

Pour le SQL dynamique construit à l’exécution, lorsque vous ne connaissez pas les colonnes à l’avance, utilisez query() / query_as(). Vous échangez la vérification à la compilation contre davantage de souplesse.

use sqlx::{Pool, Postgres};

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

Vérification rapide

Testez votre compréhension de la vérification à la compilation.

Récapitulatif

Vous avez appris les requêtes vérifiées à la compilation :

  • query! et query_as! vérifient le SQL par rapport au schéma lors de la construction
  • Les champs et les types de résultat sont déduits automatiquement
  • Les colonnes nullables deviennent des Option
  • cargo sqlx prepare permet les constructions hors ligne
  • Utilisez query(), sans macro, pour le SQL dynamique

Ensuite : les opérations CRUD.

Questions Fréquemment Posées

La leçon « Requêtes vérifiées à la compilation » est-elle gratuite ?

Oui — le texte complet de « Requêtes vérifiées à la compilation » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Requêtes vérifiées à la compilation » ?

SQL garantissant la sûreté des types Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Requêtes vérifiées à la compilation » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Connexion à une base de données
  2. Requêtes vérifiées à la compilation
  3. Opérations CRUD
  4. Migrations
← Retour à Learn Rust Coding