Learn Rust Coding · Leçon

Opérations CRUD

Interroger et exécuter

Opérations CRUD est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 3 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.

CRUD avec sqlx

CRUD signifie Create, Read, Update, Delete, c’est-à-dire créer, lire, mettre à jour et supprimer. sqlx répartit ces opérations entre deux modes d’exécution :

fetch_* pour les requêtes qui renvoient des lignes
execute pour les instructions qui modifient les données

Créer (INSERT)

Insérez une ligne avec des paramètres liés et exécutez-la via execute. Utilisez RETURNING pour récupérer l’identifiant généré.

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
}

Lire une ligne

fetch_one attend exactement une ligne et renvoie une erreur dans le cas contraire. Utilisez fetch_optional lorsque la ligne peut être absente.

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

Lire plusieurs lignes

fetch_all renvoie un Vec contenant toutes les lignes correspondantes.

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

Mettre à jour

Les instructions UPDATE utilisent execute, qui renvoie un résultat indiquant le nombre de lignes affectées.

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

Supprimer

DELETE utilise également execute. Consultez rows_affected() pour savoir si un élément a été supprimé.

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
}

Modélisation de CRUD en Rust simple

Effectuer des opérations CRUD sur une table en mémoire reproduit les mêmes opérations que celles effectuées par sqlx sur une table.

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

Transactions

Regroupez plusieurs instructions de manière atomique dans une transaction. Soit elles réussissent toutes avec commit, soit aucune n’est appliquée.

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

Annulation

Si une garde de transaction est détruite sans commit, sqlx annule automatiquement la transaction. Vous pouvez également appeler explicitement 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(); }
}

Lire de grands volumes en flux

Pour les ensembles de résultats volumineux, fetch renvoie un flux afin que vous puissiez traiter les lignes sans toutes les charger en mémoire.

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

Gérer les erreurs

Les appels à la base de données renvoient un Result. Propagez l’erreur avec ? dans les fonctions qui renvoient Result<_, sqlx::Error>, plutôt que de retirer la valeur sans vérification.

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

Vérification rapide

Testez votre compréhension des opérations CRUD.

Récapitulatif

Vous avez appris CRUD avec sqlx :

fetch_one, fetch_optional et fetch_all lisent les lignes
execute modifie les données et indique rows_affected()
RETURNING récupère les valeurs générées
Les transactions avec begin/commit/rollback garantissent l’atomicité

Ensuite : les migrations pour faire évoluer le schéma.

Questions Fréquemment Posées

La leçon « Opérations CRUD » est-elle gratuite ?

Oui — le texte complet de « Opérations CRUD » 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 « Opérations CRUD » ?

Interroger et exécuter 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 3 sur 4.

Combien de temps prend la leçon « Opérations CRUD » ?

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

← Retour à Learn Rust Coding