Learn Rust Coding · Aula

Operações CRUD

Consulte e execute

Operações CRUD é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

CRUD com sqlx

CRUD significa Criar, Ler, Atualizar e Excluir. O sqlx divide essas operações em dois estilos de execução:

fetch_* para consultas que retornam linhas
execute para instruções que alteram dados

Criar (INSERT)

Insira uma linha com parâmetros vinculados e execute-a por meio de execute. Use RETURNING para obter de volta o identificador gerado.

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
}

Ler uma linha

fetch_one espera exatamente uma linha e gera um erro caso contrário. Use fetch_optional quando a linha puder não existir.

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

Ler várias linhas

fetch_all retorna um Vec com todas as linhas correspondentes.

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

Atualizar

As instruções UPDATE usam execute, que retorna um resultado contendo o número de linhas afetadas.

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

Excluir

DELETE também usa execute. Verifique rows_affected() para saber se algo foi removido.

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
}

Modelando CRUD em Rust puro

Executar operações CRUD em um mapa mantido na memória reproduz as mesmas operações que o sqlx realiza em uma tabela.

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

Transações

Agrupe várias instruções atomicamente usando uma transação. Ou todas são bem-sucedidas em commit, ou nenhuma é aplicada.

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

Revertendo alterações

Se uma proteção de transação for descartada sem commit, o sqlx fará o rollback automaticamente. Você também pode chamar rollback explicitamente.

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

Transmitindo leituras grandes

Para conjuntos de resultados enormes, fetch retorna um fluxo, permitindo processar as linhas sem carregá-las todas na memória.

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

Lidando com erros

As chamadas ao banco de dados retornam Result. Propague o resultado com ? em funções que retornam Result<_, sqlx::Error>, em vez de remover a verificação com unwrap.

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

Verificação rápida

Teste sua compreensão das operações CRUD.

Recapitulação

Você aprendeu CRUD com sqlx:

fetch_one, fetch_optional e fetch_all leem linhas
execute altera dados e informa rows_affected()
RETURNING recupera valores gerados
Transações com begin/commit/rollback garantem atomicidade

A seguir: migrações para evoluir o esquema.

Perguntas Frequentes

A aula “Operações CRUD” é grátis?

Sim — o texto completo de “Operações CRUD” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Operações CRUD”?

Consulte e execute Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Operações CRUD”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Conexão com um banco de dados
Consultas verificadas em tempo de compilação
Operações CRUD
Migrações

← Voltar para Learn Rust Coding