Consultas comprobadas en compilación
SQL seguro por tipos
Consultas comprobadas en compilación es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en 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.
Preguntas frecuentes
¿La lección «Consultas comprobadas en compilación» es gratis?
Sí — el texto completo de «Consultas comprobadas en compilación» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.
¿Qué aprenderé en «Consultas comprobadas en compilación»?
SQL seguro por tipos Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Learn Rust Coding?
No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Consultas comprobadas en compilación»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?
Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Conexión a una base de datos
- Consultas comprobadas en compilación
- Operaciones CRUD
- Migraciones