Trabajar con bases de datos SQL en Rust

A medida que crea más programas de Rust, es posible que deba interactuar con bases de datos para el almacenamiento y la recuperación de datos.

La escritura sólida, la seguridad de la memoria y el rendimiento de Rust, combinados con su soporte para operaciones asincrónicas, ORM y migraciones, permiten un procesamiento de datos eficiente y escalable, lo que convierte a Rust en una excelente opción para crear bases de datos aplicaciones

Introducción al uso de bases de datos SQL en Rust

Hay muchas cajas de bases de datos y bibliotecas en el ecosistema de Rust que brindan soporte para los diversos paradigmas de bases de datos.

Para bases de datos SQL, puede elegir entre controladores de base de datos como libpq, conector mysql, y Sqlite3 que proporcionan una interfaz para que los programas de Rust interactúen con las bases de datos directamente sin ninguna capa de abstracción en SQL y ORM (mapeadores relacionales de objetos) como

Diesel, Sqlx, y Rust-postgres que proporcionan una manera conveniente de trabajar con la base de datos sobre Tipos de datos de óxido como estructuras y funciones.

Diesel ORM es uno de los paquetes de bases de datos más populares en el ecosistema Rust. Como ORM, Diesel proporciona características que van desde la creación y ejecución de consultas hasta la definición de modelos y las migraciones de esquemas de bases de datos, lo que facilita la interacción con las bases de datos y escribir código eficiente, limpio y fácil de mantener.

Diesel también admite múltiples motores de bases de datos, incluidos PostgreSQL, MySQL y SQLitey proporciona un sólido conjunto de características para manejar operaciones de base de datos complejas como transacciones, uniones y funciones agregadas.

Con potentes herramientas, funciones y excelente documentación, Diesel se ha convertido en una opción preferida para muchos desarrolladores de Rust que buscan crear aplicaciones basadas en datos robustas y escalables.

Primeros pasos con diésel

Tendrás que agregar el diesel y dotenv cajas a las dependencias de su proyecto en la sección de dependencias de su carga.toml archivo.

[dependencias]
diesel = { versión = "1.4.4", caracteristicas = ["sqlite"] }
dotenv = "0.15.0"

Después de agregar las cajas como dependencias, debe instalar el diesel_cli Herramienta CLI para interactuar con Diesel.

Ejecute este comando para instalar el diesel_cli herramienta:

instalación de carga diesel_cli

Puede llamar a la herramienta CLI con el diesel comando después de instalar la herramienta.

A continuación, cree un archivo de variables de entorno y especifique la URL de su base de datos.

Ejecute este comando para crear e insertar la URL de la base de datos para una base de datos SQLite en memoria.

echo DATABASE_URL=base de datos.db > .env

Para trabajar con Diesel, debe instalar sqlite3 o su base de datos preferida en su computadora.

Finalmente, ejecute el configuración comando para que Diesel configure una base de datos para su proyecto:

configuración diésel

El configuración comando crea un migraciones directorio, crea la base de datos especificada en el DATABASE_URLy ejecuta las migraciones existentes.

Configuración de migraciones con diesel

Después de configurar su base de datos con Diesel, utilizará el la migración genera Comando para generar archivos de migración. Agregará el nombre del archivo como argumento:

migración diesel generar create_humans

El comando genera dos archivos SQL en el migraciones directorio: up.sql y abajo.sql.

Escribirá SQL para las definiciones de la tabla de su base de datos en el up.sql archivo:

-- Tu SQL va aquí
CREARMESA"humano"
(
 "id" ENTERO NO NULO CLAVE PRIMARIA AUTOINCREMENTO,
 "first_name" TEXTO NO NULO,
 "apellido" TEXTO NO NULO,
 "edad" ENTERO NO NULO
);

Escribirá código SQL para colocar las tablas de la base de datos en el abajo.sql archivo:

-- abajo.sql
-- Este archivo debería deshacer cualquier cosa en `up.sql`
GOTAMESA"humano"

Después de escribir los archivos SQL, ejecute el ejecución de migración Comando para aplicar migraciones pendientes.

corrida de migración diesel

Además, puede utilizar el rehacer la migración Comando para revertir migraciones:

rehacer migración diesel

Además, puede utilizar el esquema de impresión comando para imprimir el esquema. El comando imprime el contenido del esquema.rs archivo.

esquema de impresión diesel

La salida del imprimir_esquema El comando es código Rust que coincide con su esquema SQL:

Conexión a su base de datos SQL con Diesel

Primero, agregue estas importaciones y directivas a su archivo:

modificación esquema;
#[uso_macro]
externocaja diesel;
usar dotenv:: dotenv;
usar diésel:: preludio::*;
usar estándar:: env;
usar Diesel::{Conexión, ExpressionMethods, QueryDsl, RunQueryDsl, SqliteConnection};
usar caja:: esquema:: humano;

Utilizará las importaciones y directivas para conectarse a su base de datos y realizar operaciones.

Así es como puede conectarse a una base de datos SQLite con una función y devolver una instancia de conexión:

usar estándar:: env;
usar diésel::{Conexión, SqliteConnection};
fnestablecer_conexión() -> Conexión Sqlite {
 dotenv().ok();
dejar base_de_datos_url = entorno:: var("DATABASE_URL")
 .esperar("DATABASE_URL debe establecerse");
 SqliteConnection:: establecer(&database_url)
 .unwrap_or_else(|_| ¡pánico!("Error al conectarse a {}", base de datos_url))
}

El establecer_conexión función devuelve la estructura de instancia de conexión (Conexión Sqlite). El establecer_conexión carga las variables de entorno con el OK función, accede a la URL de la base de datos con el variable función, y establece una conexión con la base de datos a través de la URL con el establecer función.

Después de una conexión exitosa, puede ejecutar consultas e insertarlas en su base de datos.

Inserción de valores en una base de datos con diésel

Utilizará una estructura que coincida con su esquema SQL para insertar valores en su base de datos.

Aquí hay una estructura que coincide con la humano esquema de tabla:

#[derivar (Consultable)]
pubestructuraHumano {
pub identificación: i32,
pub nombre de pila: Cadena,
pub apellido: Cadena,
pub edad: i32,
}

La función de inserción devolverá una instancia de la Humano tipo para otras operaciones.

Necesitará una estructura para su función de inserción; la estructura implementará dos atributos de macro, uno para la funcionalidad de inserción y el otro que identifica la tabla para la operación.

Aquí está la estructura para la operación de inserción:

#[derivar (insertable)]
#[nombre_tabla = "humano"]
estructuranuevohumano<'a> {
 nombre de pila: &'acalle,
 apellido: &'acalle,
 edad: i32,
}

Su función de inserción tomará una instancia de conexión y los datos que desea insertar en la base de datos. Inserte los datos e imprima un mensaje basado en el estado de la operación.

fninsertar en<'a>(conexión: &SqliteConnection, nombre: &'acalle, apellido: &'acalle, edad: i32) -> Humano {
usar caja:: esquema:: humano;
dejar nuevo_humano = NuevoHumano {
 nombre de pila,
 apellido,
 edad,
 };
 diesel:: insertar_en (humano:: tabla).valores(&nuevo_humano).ejecutar (conexion).esperar("Error al insertar un nuevo humano");
 humano:: table.order (humano:: id.desc()).first (conn).unwrap()
}

El insertar en La función toma los parámetros e inserta los valores en la base de datos con Diesel insertar en función que toma en la tabla y el valores función que toma una instancia de estructura. La función asigna el ID en orden descendente con el descripción función antes de ejecutar la operación.

Aquí esta la principal función que llama al insertar en función:

fnprincipal() {
dejar conn = establecer_conexión();
dejar nuevo_humano = insertar_en(&conn, "John", "Gama", 25);
imprimir!("Nuevo humano insertado con ID: {}", nuevo_humano.id);

}

El control variable es una instancia de conexión, y la nuevo_humano variable es la llamada a la función. El principal La función imprime el ID después de una operación exitosa.

Consultar bases de datos con diesel

Alternativamente, su estructura de función de consulta implementará el consultable atributo con un derivar macro.

Aquí está la estructura para la operación de consulta:

// Define una estructura que representa una fila en tu tabla
#[derivar (Consultable)]
estructuraHumano {
 identificación: i32,
 nombre de pila: Cadena,
 apellido: Cadena,
 edad: i32,
}

La función de consulta tomará una instancia de conexión y devolverá un Humano estructura de la siguiente manera:

fnconsulta_db(conexión: &SqliteConnection) -> Humano {
 humano.filtro (edad.eq(25)).primero (con).esperar("Error al consultar la base de datos")
}

El consulta_db función filtra la tabla humana para la fila donde el edad es igual a 25 y devuelve la primera aparición como una instancia de estructura.

fnprincipal() {
dejar conn = establecer_conexión();
dejar persona = consulta_db(&conn);
imprimir!("IDENTIFICACIÓN: {}", persona.id);
imprimir!("Nombre de pila: {}", persona.nombre_de pila);
imprimir!("Apellido: {}", persona.apellido);
imprimir!("Edad: {}", persona.edad);
}

En el principal función, la persona variable llama al consulta_db e imprime los campos de la fila con un valor de edad igual a 25.

Puedes construir servidores web con Rust

Rust continúa ganando popularidad en el desarrollo web como un lenguaje del lado del servidor con bibliotecas como Actix-web y Cohete que facilitan la configuración de servidores y la creación de API y sitios web mediante la abstracción de funciones complejas.

La mayoría de los servidores web tienen que interactuar con bases de datos para el almacenamiento y recuperación de datos. Puede integrar aún más sus aplicaciones con tecnología Diesel con Actix-web o Rocket para crear aplicaciones web sofisticadas.