Consultas verificadas em tempo de compilação
SQL seguro quanto aos tipos
Consultas verificadas em tempo de compilação é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 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.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
The killer feature
sqlx can verify your SQL at compile time against a real database schema. Typos, wrong column names, and type mismatches become build errors.
- Uses the
query!family of macros - Catches bugs before runtime
query! vs query
The query() function is checked at runtime. The query! macro is checked at compile time by connecting to the database during the 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();
}Typed result fields
The query! macro generates an anonymous struct whose fields match the selected columns, with the correct Rust types inferred from the 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
}How checking works
At build time sqlx needs either a live DATABASE_URL or a cached .sqlx directory. It sends the query to the DB to learn its parameter and result types.
Offline mode with cargo sqlx prepare
For CI without a database, run cargo sqlx prepare to save query metadata into .sqlx/. Builds then use the cache.
cargo sqlx preparequery_as! into your struct
Use query_as! to map rows directly into a struct you define, still fully checked.
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()
}Nullable columns become Option
If a column may be NULL, sqlx makes the field an Option. You can override inference with type annotations like 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
}Modeling type inference
Compile-time checking maps SQL types to Rust types. This runnable example models that mapping decision.
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 errors you will see
If you reference a missing column, sqlx fails the build with a clear message. This safety is the whole point of the macros.
- Wrong column name → error at compile time
- Type mismatch → error at compile time
Bind parameters are positional
Use $1, $2 placeholders for Postgres. sqlx checks each bound argument's type against the 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();
}When to use the non-macro form
For dynamic SQL built at runtime (you do not know columns ahead of time), use query() / query_as(). You trade compile-time checks for flexibility.
use sqlx::{Pool, Postgres};
async fn dynamic(pool: &Pool<Postgres>, sql: &str) {
let _ = sqlx::query(sql).execute(pool).await.unwrap();
}Quick Check
Test your understanding of compile-time checking.
Recap
You learned compile-time checked queries:
query!andquery_as!verify SQL against the schema at build time- Result fields and types are inferred automatically
- Nullable columns become
Option cargo sqlx prepareenables offline builds- Use non-macro
query()for dynamic SQL
Next: CRUD operations.
Perguntas Frequentes
A aula “Consultas verificadas em tempo de compilação” é grátis?
Sim — o texto completo de “Consultas verificadas em tempo de compilação” é 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 “Consultas verificadas em tempo de compilação”?
SQL seguro quanto aos tipos 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 2 de 4.
Quanto tempo leva a aula “Consultas verificadas em tempo de compilação”?
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