Au fur et à mesure que vous développez des programmes Rust, vous pouvez avoir besoin d’interagir avec des bases de données pour le stockage et la récupération de données.
Le typage, la sécurité mémoire et les performances de Rust, combinés à son support pour les opérations asynchrones, les ORM et les migrations, permettent un traitement des données efficace et évolutif, faisant de Rust un excellent choix pour la construction d’applications de bases de données.
Introduction à l’utilisation des bases de données SQL en Rust
Il existe de nombreux crates et bibliothèques de bases de données dans l’écosystème Rust qui fournissent un support pour les différents paradigmes de bases de données.
Pour les bases de données SQL, vous avez le choix entre des pilotes de base de données comme Libpq, Mysql-connecteuret Sqlite3 qui fournissent une interface pour les programmes Rust afin d’interagir avec les bases de données directement sans aucune couche d’abstraction sur le SQL et les ORMs (Object-Relational Mappers) comme Diesel, Sqlx, et Rust-postgres qui fournissent un moyen pratique de travailler avec une base de données sur des types de données Rust tels que les structures et les fonctions.
L’ORM Diesel est l’un des packages de base de données les plus populaires dans l’écosystème Rust. En tant qu’ORM, Diesel fournit des fonctionnalités allant de la construction et de l’exécution de requêtes à la définition de modèles et aux migrations de schémas de base de données, facilitant ainsi l’interaction avec les bases de données et l’écriture d’un code efficace, propre et facile à maintenir.
Diesel supporte également plusieurs moteurs de base de données, dont PostgreSQL, MySQL et SQLite, et fournit un ensemble de fonctionnalités robustes pour gérer des opérations de base de données complexes telles que les transactions, les jointures et les fonctions d’agrégation.
Avec des outils puissants, des fonctionnalités et une excellente documentation, Diesel est devenu un choix incontournable pour de nombreux développeurs Rust qui cherchent à construire des applications robustes et évolutives basées sur les données.
Démarrer avec Diesel
Vous devrez ajouter l’élément diesel et dotenv aux dépendances de votre projet dans la section des dépendances de votre fichier cargo.toml fichier.
[dependencies]
diesel = { version = "1.4.4", features = ["sqlite"] }
dotenv = "0.15.0"
Après avoir ajouté les crates en tant que dépendances, vous devez installer le fichier diesel_cli Outil CLI pour interagir avec Diesel.
Exécutez cette commande pour installer l’outil diesel_cli outil :
cargo install diesel_cli
Vous pouvez appeler l’outil CLI avec la commande diesel après l’installation de l’outil.
Ensuite, créez un fichier de variables d’environnement et spécifiez l’URL de votre base de données.
Exécutez cette commande pour créer et insérer l’URL d’une base de données SQLite en mémoire.
echo DATABASE_URL=database.db > .env
Pour travailler avec Diesel, vous devez installer sqlite3 ou la base de données de votre choix sur votre ordinateur.
Enfin, exécutez le programme setup pour Diesel afin de mettre en place une base de données pour votre projet :
diesel setup
La commande configuration La commande crée un migrations crée la base de données spécifiée dans le fichier DATABASE_URLet exécute les migrations existantes.
Configurer des migrations avec Diesel
Après avoir configuré votre base de données avec Diesel, vous utiliserez la commande migration générer pour générer des fichiers de migration. Vous ajouterez le nom du fichier en argument :
diesel migration generate create_humans
La commande génère deux fichiers SQL dans le répertoire migrations répertoire : up.sql et down.sql.
Vous écrirez le langage SQL pour les définitions des tables de votre base de données dans la section up.sql fichier :
-- Your SQL goes here
CREATE TABLE "human"
(
"id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
"first_name" TEXT NOT NULL,
"last_name" TEXT NOT NULL,
"age" INTEGER NOT NULL
);
Vous écrirez du code SQL pour supprimer des tables de la base de données dans le fichier down.sql fichier :
-- down.sql
-- This file should undo anything in `up.sql`
DROP TABLE "human"
Après avoir écrit les fichiers SQL, exécutez la commande migration run pour appliquer les migrations en cours.
diesel migration run
En outre, vous pouvez utiliser la commande migration redo La commande « migration redo » permet d’annuler les migrations :
diesel migration redo
Vous pouvez également utiliser la commande print-schema pour imprimer le schéma. La commande imprime le contenu du fichier schema.rs fichier.
diesel print-schema
La sortie de la fonction print_schema est le code Rust qui correspond à votre schéma SQL :
Connexion à votre base de données SQL avec Diesel
Tout d’abord, ajoutez ces importations et directives à votre fichier :
mod schema;
#[macro_use]
extern crate diesel;
use dotenv::dotenv;
use diesel::prelude::*;
use std::env;
use Diesel::{Connection, ExpressionMethods, QueryDsl, RunQueryDsl, SqliteConnection};
use crate::schema::human;
Vous utiliserez les importations et les directives pour vous connecter à votre base de données et effectuer des opérations.
Voici comment vous pouvez vous connecter à une base de données SQLite avec une fonction et retourner une instance de connexion :
use std::env;
use diesel::{Connection, SqliteConnection};
fn establish_connection() -> SqliteConnection {
dotenv().ok();
let database_url = env::var("DATABASE_URL")
.expect("DATABASE_URL must be set");
SqliteConnection::establish(&database_url)
.unwrap_or_else(|_| panic!("Error connecting to {}", database_url))
}
La fonction établir_la_connexion La fonction renvoie la structure de l’instance de connexion (SqliteConnection). Les établir_connexion charge les variables d’environnement avec l’option ok accède à l’URL de la base de données avec la fonction var et établit une connexion avec la base de données via l’URL avec l’attribut établir fonction.
Après une connexion réussie, vous pouvez exécuter des requêtes et les insérer dans votre base de données.
Insérer des valeurs dans une base de données avec Diesel
Vous allez utiliser une structure qui correspond à votre schéma SQL pour insérer des valeurs dans votre base de données.
Voici une structure qui correspond au schéma humain schéma de table :
#[derive(Queryable)]
pub struct Human {
pub id: i32,
pub first_name: String,
pub last_name: String,
pub age: i32,
}
La fonction d’insertion renvoie une instance de la classe Humain pour d’autres opérations.
Vous aurez besoin d’une structure pour votre fonction d’insertion ; la structure mettra en œuvre deux macroattributs, l’un pour la fonctionnalité d’insertion et l’autre qui identifie la table pour l’opération.
Voici la structure pour l’opération d’insertion :
#[derive(Insertable)]
#[table_name = "human"]
struct NewHuman<'a> {
first_name: &'a str,
last_name: &'a str,
age: i32,
}
Votre fonction d’insertion prend en charge une instance de connexion et les données que vous souhaitez insérer dans la base de données. Elle insère les données et imprime un message en fonction de l’état de l’opération.
fn insert_into<'a>(conn: &SqliteConnection, first_name: &'a str, last_name: &'a str, age: i32) -> Human {
use crate::schema::human;
let new_human = NewHuman {
first_name,
last_name,
age,
};
diesel::insert_into(human::table).values(&new_human).execute(conn).expect("Error inserting new human");
human::table.order(human::id.desc()).first(conn).unwrap()
}
La fonction insert_into prend les paramètres et insère les valeurs dans la base de données avec la fonction insert_into qui prend en compte le tableau et la fonction valeurs fonction qui prend en charge une instance de structure. La fonction attribue l’ID dans l’ordre décroissant avec l’attribut desc avant d’exécuter l’opération.
Voici le principal qui appelle la fonction insert_into fonction :
fn main() {
let conn = establish_connection();
let new_human = insert_into(&conn, "John", "Doe", 25);
println!("New human inserted with ID: {}", new_human.id);
}
Le conn est une instance de connexion, et la variable nouveau_humain est l’appel de fonction. La variable principal imprime l’ID après une opération réussie.
Interroger les bases de données avec Diesel
Alternativement, votre structure de fonction d’interrogation implémentera la fonction Interrogeable avec un attribut dérivé macro.
Voici la structure de l’opération de requête :
// Define a struct that represents a row in your table
#[derive(Queryable)]
struct Human {
id: i32,
first_name: String,
last_name: String,
age: i32,
}
La fonction d’interrogation prend en charge une instance de connexion et renvoie une structure Humain struct comme suit :
fn query_db(conn: &SqliteConnection) -> Human {
human.filter(age.eq(25)).first(conn).expect("Error querying database")
}
La query_db filtre la table humaine pour la ligne où la fonction âge est égal à 25 et renvoie la première occurrence sous la forme d’une instance struct.
fn main() {
let conn = establish_connection();
let person = query_db(&conn);
println!("ID: {}", person.id);
println!("First Name: {}", person.first_name);
println!("Last Name: {}", person.last_name);
println!("Age: {}", person.age);
}
Dans l’article principal la fonction personne La variable appelle le query_db et imprime les champs de la ligne dont la valeur de l’âge est égale à 25.
Vous pouvez construire des serveurs Web avec Rust
Rust continue de gagner en popularité dans le développement web en tant que langage côté serveur avec des bibliothèques telles que Actix-web et Fusée qui facilitent la mise en place de serveurs et la création d’API et de sites web en abstrayant des fonctionnalités complexes.
La plupart des serveurs web doivent interagir avec des bases de données pour le stockage et la récupération des données. Vous pouvez intégrer vos applications Diesel-powered avec Actix-web ou Rocket pour créer des applications web sophistiquées.
