Arbeide med SQL-databaser i Rust

Etter hvert som du bygger flere Rust-programmer, må du kanskje samhandle med databaser for datalagring og gjenfinning.

Rusts sterke skriving, minnesikkerhet og ytelse, kombinert med støtte for asynkrone operasjoner, ORM-er og migreringer, muliggjør effektiv og skalerbar databehandling, noe som gjør Rust til et utmerket valg for å bygge database applikasjoner.

Introduksjon til bruk av SQL-databaser i Rust

Det er mange databasekasser og biblioteker i Rust-økosystemet som gir støtte for de ulike databaseparadigmene.

For SQL-databaser kan du velge mellom databasedrivere som Libpq, Mysql-kobling, og SQLite3 som gir et grensesnitt for Rust-programmer for å samhandle med databaser direkte uten noe abstraksjonslag på SQL og ORM-er (Object-Relational Mappers) som Diesel, Sqlx, og Rust-postgres som gir en praktisk måte å jobbe med database over Rustdatatyper som strukturer og funksjoner.

Diesel ORM er en av de mest populære databasepakkene i Rust-økosystemet. Som en ORM tilbyr Diesel funksjoner fra oppbygging og utførelse av spørringer til modelldefinisjon og migrering av databaseskjemaer, noe som gjør det enklere for deg å samhandle med databaser og

skrive effektiv, ren og enkel å vedlikeholde kode.

Diesel støtter også flere databasemotorer inkludert PostgreSQL, MySQL og SQLite, og gir et robust sett med funksjoner for å håndtere komplekse databaseoperasjoner som transaksjoner, sammenføyninger og aggregerte funksjoner.

Med kraftige verktøy, funksjoner og utmerket dokumentasjon har Diesel blitt et godt valg for mange Rust-utviklere som ønsker å bygge robuste og skalerbare datadrevne applikasjoner.

Komme i gang med diesel

Du må legge til diesel og dotenv kasser til prosjektets avhengigheter i avhengighetsdelen av din cargo.toml fil.

[avhengigheter]
diesel = { versjon = "1.4.4", funksjoner = ["sqlite"] }
dotenv = "0.15.0"

Etter å ha lagt til kassene som avhengigheter, må du installere diesel_cli CLI-verktøy for å samhandle med Diesel.

Kjør denne kommandoen for å installere diesel_cli verktøy:

last installer diesel_cli

Du kan ringe CLI-verktøyet med diesel kommandoen etter installasjon av verktøyet.

Deretter oppretter du en fil med miljøvariabler og spesifiserer databasens URL.

Kjør denne kommandoen for å opprette og sette inn database-URLen for en SQLite-database i minnet.

echo DATABASE_URL=database.db > .env

For å jobbe med Diesel må du installere sqlite3 eller din foretrukne database på datamaskinen din.

Til slutt, kjør oppsett kommando for Diesel for å sette opp en database for prosjektet ditt:

diesel oppsett

De oppsett kommandoen oppretter en migrasjoner katalogen, oppretter databasen spesifisert i DATABASE_URL, og kjører eksisterende migreringer.

Sette opp migreringer med diesel

Etter å ha satt opp databasen din med Diesel, vil du bruke migrasjon generere kommando for å generere migreringsfiler. Du legger til navnet på filen som et argument:

diesel migrasjon generere create_humans

Kommandoen genererer to SQL-filer i migrasjoner katalog: up.sql og down.sql.

Du vil skrive SQL for databasetabelldefinisjonene i up.sql fil:

-- SQL-en din kommer her
SKAPEBORD"menneskelig"
(
 "id" INTEGER IKKE NULL PRIMÆR NØKKEL AUTOKREMENT,
 "first_name" TEXT NOT NULL,
 "last_name" TEXT NOT NULL,
 "alder" HELTAL IKKE NULL
);

Du skriver SQL-kode for å slippe databasetabeller i down.sql fil:

-- down.sql
-- Denne filen bør angre alt i `up.sql`
MISTEBORD"menneskelig"

Etter å ha skrevet SQL-filene, kjør migrasjonskjøring kommando for å bruke ventende migreringer.

diesel migrering kjøre

I tillegg kan du bruke migrering på nytt kommando for å tilbakestille migreringer:

diesel migrering gjøre om

Du kan også bruke print-skjema kommando for å skrive ut skjemaet. Kommandoen skriver ut innholdet i schema.rs fil.

diesel print-skjema

Utgangen til print_schema kommandoen er rustkode som samsvarer med SQL-skjemaet ditt:

Koble til SQL-databasen din med diesel

Først legger du til disse importene og direktivene til filen din:

mod skjema;
#[makro_bruk]
eksternkasse diesel;
bruk dotenv:: dotenv;
bruk diesel:: forspill::*;
bruk std:: env;
bruk Diesel::{Connection, ExpressionMethods, QueryDsl, RunQueryDsl, SqliteConnection};
bruk kasse:: skjema:: menneske;

Du vil bruke importene og direktivene for å koble til databasen og utføre operasjoner.

Slik kan du koble til en SQLite-database med en funksjon og returnere en tilkoblingsforekomst:

bruk std:: env;
bruk diesel::{Connection, SqliteConnection};
fnetablere_tilkobling() -> SqliteConnection {
 dotenv().ok();
la database_url = env:: var("DATABASE_URL")
 .forvent("DATABASE_URL må angis");
 SqliteConnection:: establish(&database_url)
 .unwrap_or_else(|_| panikk!("Feil ved tilkobling til {}", database_url))
}

De etablere_tilkobling funksjonen returnerer tilkoblingsinstansstrukturen (SqliteConnection). De etablere_tilkobling laster miljøvariablene med ok funksjon, får tilgang til databasens URL med var funksjon, og etablerer en forbindelse med databasen via URL-en med etablere funksjon.

Etter en vellykket tilkobling kan du utføre spørringer og sette dem inn i databasen.

Sette inn verdier til en database med diesel

Du bruker en struktur som samsvarer med SQL-skjemaet ditt for å sette inn verdier i databasen.

Her er en struktur som samsvarer med menneskelig tabellskjema:

#[avlede (kan spørre)]
pubstrukturMenneskelig {
pub id: i32,
pub fornavn: String,
pub etternavn: String,
pub alder: i32,
}

Innsettingsfunksjonen vil returnere en forekomst av Menneskelig type for andre operasjoner.

Du trenger en struktur for innsettingsfunksjonen din; strukturen vil implementere to makroattributter, en for innsettingsfunksjonalitet og den andre som identifiserer tabellen for operasjonen.

Her er strukturen for innsettingsoperasjonen:

#[avlede (kan settes inn)]
#[tabellnavn = "menneskelig"]
strukturNewHuman<'en> {
 fornavn: &'enstr,
 etternavn: &'enstr,
 alder: i32,
}

Innsettingsfunksjonen din vil ta inn en tilkoblingsforekomst og dataene du vil sette inn i databasen. Sett inn dataene og skriv ut en melding basert på statusen til operasjonen.

fnsette inn_i<'en>(tilkobling: &SqliteConnection, fornavn: &'enstr, etternavn: &'enstr, alder: i32) -> Menneske {
bruk kasse:: skjema:: menneske;
la new_human = NewHuman {
 fornavn,
 etternavn,
 alder,
 };
 diesel:: insert_into (menneske:: tabell).verdier(&new_human).execute (conn).expect("Feil ved innsetting av nytt menneske");
 human:: table.order (human:: id.desc()).first (conn).unwrap()
}

De sette inn_i funksjonen tar inn parameterne og setter inn verdiene i databasen med Diesel's sette inn_i funksjon som tar inn tabellen og verdier funksjon som tar i en struct-forekomst. Funksjonen tildeler ID-en i synkende rekkefølge med desc funksjon før du utfører operasjonen.

Her er hoved- funksjon som kaller sette inn_i funksjon:

fnhoved-() {
la conn = etablere_tilkobling();
la new_human = insert_into(&conn, "John", "Doe", 25);
println!("Nytt menneske satt inn med ID: {}", new_human.id);

}

De tilk variabel er en tilkoblingsforekomst, og nytt_menneske variabel er funksjonskallet. De hoved- funksjonen skriver ut IDen etter en vellykket operasjon.

Spørre databaser med diesel

Alternativt vil spørringsfunksjonen struct implementere Spørrende attributt med en utlede makro.

Her er strukturen for spørringsoperasjonen:

// Definer en struktur som representerer en rad i tabellen din
#[avlede (kan spørre)]
strukturMenneskelig {
 id: i32,
 fornavn: String,
 etternavn: String,
 alder: i32,
}

Spørringsfunksjonen vil ta inn en tilkoblingsforekomst og returnere en Menneskelig struktur som følger:

fnquery_db(tilkobling: &SqliteConnection) -> Human {
 human.filter (age.eq(25)).first (conn).expect("Feil ved spørring i database")
}

De query_db funksjon filtrerer den menneskelige tabellen for raden der alder er lik 25 og returnerer den første forekomsten som en strukturforekomst.

fnhoved-() {
la conn = etablere_tilkobling();
la person = query_db(&conn);
println!("ID: {}", person.id);
println!("Fornavn: {}", person.fornavn);
println!("Etternavn: {}", person.etternavn);
println!("Alder: {}", person.alder);
}

I hoved- funksjon, den person variabelen kaller query_db funksjon og skriver ut feltene i raden med en aldersverdi lik 25.

Du kan bygge webservere med rust

Rust fortsetter å få popularitet innen webutvikling som et serversidespråk med biblioteker som Actix-web og Rakett som gjør det enklere å sette opp servere og bygge APIer og nettsteder ved å abstrahere kompleks funksjonalitet.

De fleste webservere må samhandle med databaser for datalagring og gjenfinning. Du kan videre integrere de dieseldrevne appene dine med Actix-web eller Rocket for å bygge sofistikerte nettapplikasjoner.