Creación de Modelos y Migraciones en Rust con Diesel

Toda base de datos SQL posee tablas para almacenar los datos. Gracias al ORM Diesel y sus migraciones, automatizaremos la creación y actualización de las mismas.

Primera tabla con Diesel

Comienza creando tu primera migración con el comando diesel migration generate create_posts. El mismo producirá un nuevo directorio dentro de /migrations que contiene dos archivos: up.sql y down.sql. En el primero, escribiremos el código SQL para generar o modificar nuestras tablas, en el segundo el código para destruir y borrar las mismas.

-- up.sql
CREATE TABLE posts (
    id SERIAL PRIMARY KEY, 
    title VARCHAR NOT NULL,
    slug VARCHAR NOT NULL,
    body TEXT NOT NULL
);

-- down.sql
DROP TABLE posts;

A continuación, utiliza el comando diesel migration run que leerá el archivo up.sql y creará el esquema apropiado para la tabla posts. Caso contrario, si quieres destruir estas tablas, utiliza diesel migration redo.

Qué son los Macros en Rust

Los Macros son similares a las funciones, con la desventaja de que su implementación es más compleja porque estás escribiendo código Rust, que generará código Rust. La definición de un Macro es generalmente más difícil de leer, entender y mantener que una función.

Este es un concepto bastante avanzado y difícil de comprender, pero es una buena oportunidad para tenerlos presente e ir averiguando más de ellos más adelante.

Otra importante diferencia entre los Macros y las funciones comunes es que debes definir su alcance antes de llamarlos en un archivo, al contrario de las funciones donde los defines donde quieras y los llamas cuando quieres.

Fuente: The Difference Between Macros and Functions

Los Macros son altamente poderosos, permiten manipular el core de Rust o cambiar el comportamiento de algo. Si tienes experiencia con otros lenguajes como Javascript, Python, tal vez te sirva hacer una analogía con el concepto de “Decoradores” para cambiar el comportamiento de una clase o variable.

Es algo complicado de entender, pero sabiendo que son similares a las funciones y cambian el comportamieto de una cosa, podemos continuar.

Configuración del proyecto

Para establecer la conexión con la base de datos y realizar consultas a la tabla que hemos creado llamado posts, primero es necesario realizar varias importaciones en el archivo main.rs:

// Indicamos que vamos a utilizar macros
#[macro_use]

// Importamos Diesel
extern crate diesel;

// Importamos la conexión con PostgreSQL
use diesel::prelude::*;
use diesel::pg::PgConnection;

// Importamos librerias para leer variables de entorno
use dotenv::dotenv;
use std::env;

// Importamos esquemas de BBDD y modelos
pub mod schema;
pub mod models;

fn main() {}

También vamos a crear una estructura que nos servirá como modelo de nuestra tabla posts en la base de datos y realizar el mapeo correspondiente.
Crea un archivo llamado models.rs que contendrá lo siguiente:

// Macro para indicar que los registros de la BBDD tendrán la misma forma que la estructura.
#[derive(Queryable)]        
pub struct Post {
    pub id: i32,
    pub title: String,
    pub slug: String,
    pub body: String,
}

Conexión con la BBDD

Teniendo listo todas las importaciones, establezcamos la conexión con la base de datos y ejecutemos la primera consulta.

// ...

fn main() {

    // Indicamos que vamos a utilizar el esquema de Posts y el modelo
    use self::models::Post;
    use self::schema::posts;
    use self::schema::posts::dsl::*;

    // Lectura de variables de entorno
    dotenv().ok();
    let db_url = env::var("DATABASE_URL").expect("La variable de entorno DATABASE_URL no existe.");

    // Conexión con la BBDD
    let conn = PgConnection::establish(&db_url).expect("No se ha podido establecer la conexión con la base de datos.");

    // Realizamos la consulta equivalente a: SELECT * FROM posts;
    let posts_result = posts.load::<Post>(&conn).expect("Error en la consulta SQL.");

    // Iteramos los resultados de la consulta
    for post in posts_result {
        println!("{}", post.title);
    }

}

Finalmente, utiliza cargo run para correr tu código y verificar si está correctamente establecida la conexión a la base y si se ejecuta la consulta. Recuerda que aún no tenemos registros en la tabla, así que la misma no devolverá resultados.

Has logrado hasta aquí conectarte a una base de datos SQL con Rust y realizar consultas. ¡Felicidades!

---

Contribución creada por: Kevin Fiorentino.