Travailler avec des bases de données SQL dans Rust

Au fur et à mesure que vous créez des programmes Rust, vous devrez peut-être interagir avec des bases de données pour le stockage et la récupération de données.

Le typage, la sécurité de la mémoire et les performances de Rust, combinés à sa prise en charge des opérations asynchrones, des ORM et migrations, permettent un traitement de données efficace et évolutif, faisant de Rust un excellent choix pour la création de bases de données applications.

Introduction à l'utilisation des bases de données SQL dans Rust

Il existe de nombreuses caisses de bases de données et bibliothèques dans l'écosystème Rust qui prennent en charge les différents paradigmes de base de données.

Pour les bases de données SQL, vous avez le choix entre des pilotes de base de données tels que LibpqComment, Connecteur MySQL, et SQLite3 qui fournissent une interface permettant aux programmes Rust d'interagir directement avec les bases de données sans aucune couche d'abstraction sur le SQL et les ORM (Object-Relational Mappers) comme

Diesel, SQLx, et Rouille-postgres qui offrent un moyen pratique de travailler avec la base de données sur Types de données de rouille telles que les structures et les fonctions.

L'ORM Diesel est l'un des packages de base de données les plus populaires de l'écosystème Rust. En tant qu'ORM, Diesel fournit des fonctionnalités allant de la création 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, ce qui vous permet d'interagir plus facilement avec les bases de données et écrire un code efficace, propre et facile à maintenir.

Le diesel prend également en charge plusieurs moteurs de base de données, y compris PostgreSQL, MySQL et SQLite, et fournit un ensemble robuste de fonctionnalités pour gérer les 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 à créer des applications basées sur les données robustes et évolutives.

Premiers pas avec le diesel

Vous devrez ajouter le diesel et dotenv crates aux dépendances de votre projet dans la section dépendances de votre cargo.toml déposer.

[dépendances]
diesel = { version = "1.4.4", caractéristiques = ["sqlite"] }
dotenv = "0.15.0"

Après avoir ajouté les caisses en tant que dépendances, vous devez installer le diesel_cli Outil CLI pour interagir avec Diesel.

Exécutez cette commande pour installer le diesel_cli outil:

cargaison installer diesel_cli

Vous pouvez appeler l'outil CLI avec le diesel commande après avoir installé 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 de la base de données pour une base de données SQLite en mémoire.

echo DATABASE_URL=database.db > .env

Pour travailler avec Diesel, vous devez installer sqlite3 ou votre base de données préférée sur votre ordinateur.

Enfin, lancez le installation commande pour que Diesel configure une base de données pour votre projet :

configuration diesel

Le installation commande crée un migrations répertoire, crée la base de données spécifiée dans le DATABASE_URL, et exécute les migrations existantes.

Configuration des migrations avec Diesel

Après avoir configuré votre base de données avec Diesel, vous utiliserez le la migration génère commande pour générer des fichiers de migration. Vous ajouterez le nom du fichier comme argument :

la migration diesel génère create_humans

La commande génère deux fichiers SQL dans le migrations annuaire: up.sql et bas.sql.

Vous écrirez SQL pour vos définitions de table de base de données dans le up.sql déposer:

-- Votre SQL va ici
CRÉERTABLEAU"humain"
(
 "id" NOMBRE ENTIER NON NULL AUTO-INCRÉMENTATION DE LA CLÉ PRIMAIRE,
 "prénom" TEXTE NON NULL,
 "nom_de_famille" TEXTE NON NULL,
 "âge" ENTIER NON NULL
);

Vous allez écrire du code SQL pour supprimer des tables de base de données dans le bas.sql déposer:

-- bas.sql
-- Ce fichier devrait tout annuler dans `up.sql`
GOUTTETABLEAU"humain"

Après avoir écrit les fichiers SQL, exécutez le course de migration commande pour appliquer les migrations en attente.

course de migration diesel

De plus, vous pouvez utiliser le refaire la migration commande pour annuler les migrations :

migration diesel refaire

Aussi, vous pouvez utiliser le schéma d'impression commande pour imprimer le schéma. La commande imprime le contenu du schema.rs déposer.

schéma d'impression diesel

La sortie du print_schema commande 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 :

mode schéma;
#[macro_use]
externeCaisse diesel;
utiliser dotenv:: dotenv;
utiliser diesel:: prélude ::*;
utiliser std:: env;
utiliser Diesel ::{Connexion, ExpressionMethods, QueryDsl, RunQueryDsl, SqliteConnection} ;
utiliser caisse:: schema:: humain;

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 renvoyer une instance de connexion :

utiliser std:: env;
utiliser diesel ::{Connexion, SqliteConnection} ;
fnétablir_connexion() -> SqliteConnection {
 dotenv().ok();
laisser url_base de données = env:: var("DATABASE_URL")
 .attendre("DATABASE_URL doit être défini");
 SqliteConnection:: établir(&database_url)
 .unwrap_or_else(|_| panique!("Erreur de connexion à {}", base de données_url))
}

Le établir_connexion La fonction renvoie la structure de l'instance de connexion (SqliteConnection). Le établir_connexion charge les variables d'environnement avec le d'accord fonction, accède à l'URL de la base de données avec la var fonction, et établit une connexion avec la base de données via l'URL avec le é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.

Insertion de valeurs dans une base de données avec Diesel

Vous utiliserez une structure qui correspond à votre schéma SQL pour insérer des valeurs dans votre base de données.

Voici une structure qui correspond à humain schéma de table :

#[dériver (interrogeable)]
pubstructureHumain {
pub identifiant: i32,
pub prénom: Chaîne,
pub nom de famille: Chaîne,
pub âge: i32,
}

La fonction d'insertion renverra une instance de Humain type pour d'autres opérations.

Vous aurez besoin d'une structure pour votre fonction d'insertion; la structure implémentera deux attributs de macro, l'un pour la fonctionnalité d'insertion et l'autre qui identifie la table pour l'opération.

Voici la structure de l'opération d'insertion :

#[dériver (Insérable)]
#[nom_table = "humain"]
structureNouveauHumain<'un> {
 prénom: &'unchaîne,
 nom de famille: &'unchaîne,
 âge: i32,
}

Votre fonction d'insertion prendra une instance de connexion et les données que vous souhaitez insérer dans la base de données. Insérez les données et imprimez un message en fonction de l'état de l'opération.

fninsérer dans<'un>(conn: &SqliteConnection, prénom: &'unchaîne, nom de famille: &'unchaîne, âge: i32) -> Humain {
utiliser caisse:: schema:: humain;
laisser new_human = NouvelHumain {
 prénom,
 nom de famille,
 âge,
 };
 diesel:: insert_into (humain:: table).values(&new_human).execute (conn).expect("Erreur lors de l'insertion d'un nouvel humain");
 humain:: table.order (humain:: id.desc()).first (conn).unwrap()
}

Le insérer dans fonction prend les paramètres et insère les valeurs dans la base de données avec Diesel insérer dans fonction qui prend dans le tableau et le valeurs fonction qui prend une instance de structure. La fonction attribue l'ID dans l'ordre décroissant avec le desc fonction avant d'exécuter l'opération.

Ici se trouve le principal fonction qui appelle le insérer dans fonction:

fnprincipal() {
laisser conn = établir_connexion();
laisser new_human = insert_into(&conn, "John", "Biche", 25);
imprimez !("Nouvel humain inséré avec ID: {}", new_human.id);

}

Le Connecticut variable est une instance de connexion, et la nouveau_humain variable est l'appel de la fonction. Le principal La fonction imprime l'ID après une opération réussie.

Interroger des bases de données avec Diesel

Alternativement, votre structure de fonction de requête implémentera le Interrogable attribut avec un dériver macro.

Voici la structure de l'opération de requête :

// Définit une structure qui représente une ligne de votre table
#[dériver (interrogeable)]
structureHumain {
 identifiant: i32,
 prénom: Chaîne,
 nom de famille: Chaîne,
 âge: i32,
}

La fonction de requête prendra une instance de connexion et renverra un Humain structure comme suit :

fnquery_db(conn: &SqliteConnection) -> Humain {
 human.filter (age.eq(25)).premier (conn).attendre("Erreur lors de l'interrogation de la base de données")
}

Le query_db la fonction filtre la table humaine pour la ligne où âge est égal à 25 et renvoie la première occurrence en tant qu'instance de structure.

fnprincipal() {
laisser conn = établir_connexion();
laisser personne = query_db(&conn);
imprimez !("IDENTIFIANT: {}", personne.id);
imprimez !("Prénom: {}", personne.prénom);
imprimez !("Nom de famille: {}", personne.nom_de_famille);
imprimez !("Âge: {}", personne.age);
}

Dans le principal fonction, la personne la variable appelle la query_db fonction et imprime les champs de la ligne avec une valeur d'âge égale à 25.

Vous pouvez créer 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 configuration des serveurs et la création d'API et de sites Web en éliminant les 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 également intégrer vos applications alimentées par Diesel avec Actix-web ou Rocket pour créer des applications Web sophistiquées.