Arbeiten mit SQL-Datenbanken in Rust

Wenn Sie weitere Rust-Programme erstellen, müssen Sie möglicherweise mit Datenbanken interagieren, um Daten zu speichern und abzurufen.

Rusts starke Typisierung, Speichersicherheit und Leistung, kombiniert mit seiner Unterstützung für asynchrone Operationen, ORMs und Migrationen ermöglichen eine effiziente und skalierbare Datenverarbeitung und machen Rust zu einer ausgezeichneten Wahl für den Aufbau von Datenbanken Anwendungen.

Einführung in die Verwendung von SQL-Datenbanken in Rust

Im Rust-Ökosystem gibt es viele Datenbankkästen und -bibliotheken, die Unterstützung für die verschiedenen Datenbankparadigmen bieten.

Bei SQL-Datenbanken können Sie zwischen Datenbanktreibern wie wählen Libpq, MySQL-Connector, Und SQLite3 die eine Schnittstelle für Rust-Programme bieten, um direkt mit Datenbanken zu interagieren, ohne dass eine Abstraktionsschicht auf SQL und ORMs (Object-Relational Mappers) erforderlich ist

Diesel, SQLx, Und Rost-Postgres die eine bequeme Möglichkeit bieten, mit der Datenbank zu arbeiten Rust-Datentypen wie Strukturen und Funktionen.

Das Diesel ORM ist eines der beliebtesten Datenbankpakete im Rust-Ökosystem. Als ORM bietet Diesel Funktionen von der Abfrageerstellung und -ausführung bis hin zur Modelldefinition und Datenbankschemamigrationen und erleichtert Ihnen so die Interaktion mit Datenbanken und Schreiben Sie effizienten, sauberen und leicht zu wartenden Code.

Diesel unterstützt auch mehrere Datenbank-Engines, einschließlich PostgreSQL, MySQL und SQLiteund bietet eine Reihe robuster Funktionen für die Handhabung komplexer Datenbankoperationen wie Transaktionen, Verknüpfungen und Aggregatfunktionen.

Mit leistungsstarken Tools, Funktionen und hervorragender Dokumentation ist Diesel für viele Rust-Entwickler, die robuste und skalierbare datengesteuerte Anwendungen erstellen möchten, zur ersten Wahl geworden.

Erste Schritte mit Diesel

Sie müssen das hinzufügen Diesel Und dotenv Kisten zu den Abhängigkeiten Ihres Projekts im Abschnitt „Abhängigkeiten“ Ihres Projekts fracht.toml Datei.

[Abhängigkeiten]
Diesel = {Version = "1.4.4", Funktionen = [„SQLite“] }
dotenv = "0.15.0"

Nachdem Sie die Crates als Abhängigkeiten hinzugefügt haben, müssen Sie die installieren diesel_cli CLI-Tool zur Interaktion mit Diesel.

Führen Sie diesen Befehl aus, um die zu installieren diesel_cli Werkzeug:

Ladung Diesel_cli installieren

Sie können das CLI-Tool mit aufrufen Diesel Befehl nach der Installation des Tools.

Erstellen Sie als Nächstes eine Umgebungsvariablendatei und geben Sie Ihre Datenbank-URL an.

Führen Sie diesen Befehl aus, um die Datenbank-URL für eine In-Memory-SQLite-Datenbank zu erstellen und einzufügen.

echo DATABASE_URL=database.db > .env

Um mit Diesel arbeiten zu können, müssen Sie sqlite3 oder Ihre bevorzugte Datenbank auf Ihrem Computer installieren.

Führen Sie abschließend das aus aufstellen Befehl für Diesel, um eine Datenbank für Ihr Projekt einzurichten:

Diesel-Setup

Der aufstellen Der Befehl erstellt eine Migrationen Verzeichnis, erstellt die in angegebene Datenbank DATABASE_URLund führt vorhandene Migrationen aus.

Migrationen mit Diesel einrichten

Nachdem Sie Ihre Datenbank mit Diesel eingerichtet haben, verwenden Sie die Migration erzeugen Befehl zum Generieren von Migrationsdateien. Sie fügen den Namen der Datei als Argument hinzu:

Dieselmigration generiert create_humans

Der Befehl generiert zwei SQL-Dateien im Migrationen Verzeichnis: up.sql Und down.sql.

Sie schreiben SQL für Ihre Datenbanktabellendefinitionen im up.sql Datei:

-- Ihr SQL kommt hierher
ERSTELLENTISCH"menschlich"
(
 „id“ INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
 „Vorname“ TEXT NICHT NULL,
 „Nachname“ TEXT NICHT NULL,
 „Alter“ INTEGER NICHT NULL
);

Sie schreiben SQL-Code, um Datenbanktabellen darin abzulegen down.sql Datei:

-- down.sql
-- Diese Datei sollte alles in „up.sql“ rückgängig machen
TROPFENTISCH"menschlich"

Führen Sie nach dem Schreiben der SQL-Dateien die Datei aus Migrationslauf Befehl zum Anwenden ausstehender Migrationen.

Dieselmigrationslauf

Darüber hinaus können Sie die verwenden Migration wiederholen Befehl zum Zurücksetzen von Migrationen:

Dieselmigration wiederholen

Sie können auch die verwenden Druckschema Befehl zum Drucken des Schemas. Der Befehl gibt den Inhalt aus schema.rs Datei.

Diesel-Druckschema

Die Ausgabe der print_schema Der Befehl ist Rust-Code, der Ihrem SQL-Schema entspricht:

Herstellen einer Verbindung zu Ihrer SQL-Datenbank mit Diesel

Fügen Sie zunächst diese Importe und Anweisungen zu Ihrer Datei hinzu:

Mod Schema;
#[macro_use]
externKiste Diesel;
verwenden dotenv:: dotenv;
verwenden Diesel:: Vorspiel::*;
verwenden std:: env;
verwenden Diesel::{Connection, ExpressionMethods, QueryDsl, RunQueryDsl, SqliteConnection};
verwenden Kiste:: Schema:: Mensch;

Sie verwenden die Importe und Anweisungen, um eine Verbindung zu Ihrer Datenbank herzustellen und Vorgänge auszuführen.

So können Sie mit einer Funktion eine Verbindung zu einer SQLite-Datenbank herstellen und eine Verbindungsinstanz zurückgeben:

verwenden std:: env;
verwenden diesel::{Connection, SqliteConnection};
fnetablieren_Verbindung() -> SqliteConnection {
 dotenv().ok();
lassen Datenbank_URL = env:: var(„DATABASE_URL“)
 .erwarten(„DATABASE_URL muss festgelegt werden“);
 SqliteConnection:: Establish(&database_url)
 .unwrap_or_else(|_| Panik!(„Fehler beim Herstellen der Verbindung zu {}“, Datenbank-URL))
}

Der etablieren_Verbindung Die Funktion gibt die Verbindungsinstanzstruktur zurück (SQLiteConnection). Der etablieren_Verbindung lädt die Umgebungsvariablen mit dem OK Funktion, greift mit der auf die Datenbank-URL zu var Funktion und stellt über die URL mit dem eine Verbindung zur Datenbank her gründen Funktion.

Nach erfolgreicher Verbindung können Sie Abfragen ausführen und in Ihre Datenbank einfügen.

Mit Diesel Werte in eine Datenbank einfügen

Sie verwenden eine Struktur, die Ihrem SQL-Schema entspricht, um Werte in Ihre Datenbank einzufügen.

Hier ist eine Struktur, die mit der übereinstimmt menschlich Tabellenschema:

#[ableiten (abfragbar)]
KneipeStrukturMenschlich {
Kneipe Ausweis: i32,
Kneipe Vorname: Zeichenfolge,
Kneipe Familienname, Nachname: Zeichenfolge,
Kneipe Alter: i32,
}

Die Einfügefunktion gibt eine Instanz von zurück Menschlich Typ für andere Operationen.

Sie benötigen eine Struktur für Ihre Einfügefunktion; Die Struktur implementiert zwei Makroattribute, eines für die Einfügefunktion und das andere, das die Tabelle für die Operation identifiziert.

Hier ist die Struktur für den Einfügevorgang:

#[ableiten (einfügbar)]
#[Tabellenname = "menschlich"]
StrukturNeuer Mensch<'A> {
 Vorname: &'Astr,
 Familienname, Nachname: &'Astr,
 Alter: i32,
}

Ihre Einfügefunktion übernimmt eine Verbindungsinstanz und die Daten, die Sie in die Datenbank einfügen möchten. Geben Sie die Daten ein und drucken Sie eine Nachricht basierend auf dem Status des Vorgangs.

fneinfügen in<'A>(conn: &SqliteConnection, Vorname: &'Astr, Familienname, Nachname: &'Astr, Alter: i32) -> Mensch {
verwenden Kiste:: Schema:: Mensch;
lassen new_human = NewHuman {
 Vorname,
 Familienname, Nachname,
 Alter,
 };
 diesel:: insert_into (human:: table).values(&new_human).execute (conn).expect(„Fehler beim Einfügen eines neuen Menschen“);
 human:: table.order (human:: id.desc()).first (conn).unwrap()
}

Der einfügen in Die Funktion übernimmt die Parameter und fügt die Werte mit Diesel in die Datenbank ein einfügen in Funktion, die die Tabelle und die übernimmt Werte Funktion, die eine Strukturinstanz aufnimmt. Die Funktion vergibt die ID in absteigender Reihenfolge mit dem absteigend Funktion, bevor Sie den Vorgang ausführen.

Hier ist die hauptsächlich Funktion, die die aufruft einfügen in Funktion:

fnhauptsächlich() {
lassen conn = Establish_connection();
lassen new_human = insert_into(&conn, "John", "Damhirschkuh", 25);
println!(„Neuer Mensch mit ID eingefügt: {}“, new_human.id);

}

Der Anschl Variable ist eine Verbindungsinstanz und die neuer_mensch Variable ist der Funktionsaufruf. Der hauptsächlich Die Funktion gibt die ID nach einem erfolgreichen Vorgang aus.

Abfragen von Datenbanken mit Diesel

Alternativ implementiert Ihre Abfragefunktionsstruktur das Abfragbar Attribut mit a ableiten Makro.

Hier ist die Struktur für den Abfragevorgang:

// Definieren Sie eine Struktur, die eine Zeile in Ihrer Tabelle darstellt
#[ableiten (abfragbar)]
StrukturMenschlich {
 Ausweis: i32,
 Vorname: Zeichenfolge,
 Familienname, Nachname: Zeichenfolge,
 Alter: i32,
}

Die Abfragefunktion nimmt eine Verbindungsinstanz auf und gibt eine zurück Menschlich Struktur wie folgt:

fnquery_db(conn: &SqliteConnection) -> Human {
 human.filter (age.eq(25)).first (conn).expect(„Fehler beim Abfragen der Datenbank“)
}

Der query_db Die Funktion filtert die menschliche Tabelle nach der Zeile, in der die Alter entspricht 25 und gibt das erste Vorkommen als Strukturinstanz zurück.

fnhauptsächlich() {
lassen conn = Establish_connection();
lassen person = query_db(&conn);
println!("AUSWEIS: {}", person.id);
println!("Vorname: {}", person.vorname);
println!("Familienname, Nachname: {}", person.last_name);
println!("Alter: {}", Person.Alter);
}

Im hauptsächlich Funktion, die Person Variable ruft die auf query_db Funktion und druckt die Felder der Zeile mit einem Alterswert von 25.

Sie können Webserver mit Rust erstellen

Rust erfreut sich in der Webentwicklung als serverseitige Sprache mit Bibliotheken immer größerer Beliebtheit Actix-web Und Rakete die es einfacher machen, Server einzurichten und APIs und Websites zu erstellen, indem sie komplexe Funktionen abstrahieren.

Die meisten Webserver müssen mit Datenbanken interagieren, um Daten zu speichern und abzurufen. Sie können Ihre Diesel-basierten Apps weiter mit Actix-web oder Rocket integrieren, um anspruchsvolle Webanwendungen zu erstellen.