Arbeta med SQL-databaser i Rust

När du bygger fler Rust-program kan du behöva interagera med databaser för datalagring och hämtning.

Rusts starka maskinskrivning, minnessäkerhet och prestanda, kombinerat med dess stöd för asynkrona operationer, ORMs och migrationer, möjliggör effektiv och skalbar databehandling, vilket gör Rust till ett utmärkt val för att bygga databas applikationer.

Introduktion till att använda SQL-databaser i Rust

Det finns många databaslådor och bibliotek i Rust-ekosystemet som ger stöd för olika databasparadigm.

För SQL-databaser får du välja mellan databasdrivrutiner som Libpq, Mysql-kontakt, och SQLite3 som tillhandahåller ett gränssnitt för Rust-program att interagera med databaser direkt utan något abstraktionslager på SQL och ORM (Object-Relational Mappers) som Diesel, Sqlx, och Rost-postgres som ger ett bekvämt sätt att arbeta med databas över Rostdatatyper såsom strukturer och funktioner.

Diesel ORM är ett av de mest populära databaspaketen i Rust-ekosystemet. Som en ORM tillhandahåller Diesel funktioner från frågebyggnad och exekvering till modelldefinition och databasschemamigrering, vilket gör det lättare för dig att interagera med databaser och

skriva effektiv, ren och enkel att underhålla kod.

Diesel stödjer också flera databasmotorer inklusive PostgreSQL, MySQL och SQLite, och tillhandahåller en robust uppsättning funktioner för att hantera komplexa databasoperationer som transaktioner, kopplingar och aggregerade funktioner.

Med kraftfulla verktyg, funktioner och utmärkt dokumentation har Diesel blivit ett bra val för många Rust-utvecklare som vill bygga robusta och skalbara datadrivna applikationer.

Komma igång med diesel

Du måste lägga till diesel och dotenv lådor till ditt projekts beroenden i beroendesektionen i din cargo.toml fil.

[beroenden]
diesel = { version = "1.4.4", funktioner = ["sqlite"] }
dotenv = "0.15.0"

Efter att ha lagt till lådorna som beroenden måste du installera diesel_cli CLI-verktyg för att interagera med Diesel.

Kör det här kommandot för att installera diesel_cli verktyg:

last installera diesel_cli

Du kan anropa CLI-verktyget med diesel kommandot efter installation av verktyget.

Skapa sedan en miljövariabelfil och ange din databas-URL.

Kör det här kommandot för att skapa och infoga databasens URL för en SQLite-databas i minnet.

echo DATABASE_URL=databas.db > .env

För att arbeta med Diesel måste du installera sqlite3 eller din föredragna databas på din dator.

Slutligen, kör uppstart kommando för Diesel för att skapa en databas för ditt projekt:

dieseluppställning

De uppstart kommandot skapar en migrationer katalogen, skapar databasen som anges i DATABASE_URL, och kör befintliga migreringar.

Ställa in migrering med diesel

När du har ställt in din databas med Diesel kommer du att använda migration generera kommando för att generera migreringsfiler. Du lägger till namnet på filen som ett argument:

diesel migration genererar create_humans

Kommandot genererar två SQL-filer i migrationer katalog: up.sql och down.sql.

Du kommer att skriva SQL för dina databastabelldefinitioner i up.sql fil:

-- Din SQL kommer hit
SKAPATABELL"mänsklig"
(
 "id" INTEGER INTE NULL PRIMARY KEY AUTOINCREMENT,
 "first_name" TEXT INTE NULL,
 "last_name" TEXT INTE NULL,
 "ålder" HELTAL INTE NULL
);

Du kommer att skriva SQL-kod för att släppa databastabeller i down.sql fil:

-- down.sql
-- Den här filen bör ångra allt i `up.sql`
SLÄPPATABELL"mänsklig"

Efter att ha skrivit SQL-filerna kör du migreringskörning kommando för att tillämpa pågående migrering.

diesel migration köra

Dessutom kan du använda migration gör om kommando för att återställa migrering:

diesel migration gör om

Du kan också använda print-schema kommando för att skriva ut schemat. Kommandot skriver ut innehållet i schema.rs fil.

diesel print-schema

Utgången av print_schema kommandot är Rustkod som matchar ditt SQL-schema:

Ansluta till din SQL-databas med diesel

Lägg först till dessa importer och direktiv till din fil:

mod schema;
#[makro_use]
externspjällåda diesel;
använda sig av dotenv:: dotenv;
använda sig av diesel:: förspel::*;
använda sig av std:: env;
använda sig av Diesel::{Connection, ExpressionMethods, QueryDsl, RunQueryDsl, SqliteConnection};
använda sig av låda:: schema:: människa;

Du kommer att använda importerna och direktiven för att ansluta till din databas och utföra operationer.

Så här kan du ansluta till en SQLite-databas med en funktion och returnera en anslutningsinstans:

använda sig av std:: env;
använda sig av diesel::{Connection, SqliteConnection};
fnupprätta_anslutning() -> SqliteConnection {
 dotenv().ok();
låta database_url = env:: var("DATABASE_URL")
 .förvänta("DATABASE_URL måste ställas in");
 SqliteConnection:: establish(&database_url)
 .unwrap_or_else(|_| panik!("Fel vid anslutning till {}", database_url))
}

De upprätta_anslutning funktion returnerar anslutningsinstansens struktur (SqliteConnection). De upprätta_anslutning laddar miljövariablerna med ok funktionen, kommer åt databasens URL med var funktion och upprättar en anslutning till databasen via URL: en med slå fast fungera.

Efter en lyckad anslutning kan du köra frågor och infoga dem i din databas.

Infoga värden till en databas med diesel

Du kommer att använda en struktur som matchar ditt SQL-schema för att infoga värden i din databas.

Här är en struktur som matchar mänsklig tabellschema:

#[härleda (frågebar)]
pubstrukturMänsklig {
pub id: i32,
pub förnamn: Sträng,
pub efternamn: Sträng,
pub ålder: i32,
}

Infogningsfunktionen returnerar en instans av Mänsklig typ för andra operationer.

Du behöver en struktur för din infogningsfunktion; strukturen kommer att implementera två makroattribut, en för infogningsfunktionalitet och den andra som identifierar tabellen för operationen.

Här är strukturen för infogningsoperationen:

#[härleda (insättningsbar)]
#[tabellnamn = "mänsklig"]
strukturNewHuman<'a> {
 förnamn: &'astr,
 efternamn: &'astr,
 ålder: i32,
}

Din infogningsfunktion kommer att ta in en anslutningsinstans och de data du vill infoga i databasen. Infoga data och skriv ut ett meddelande baserat på status för operationen.

fnSätt in i<'a>(anslutning: &SqliteConnection, förnamn: &'astr, efternamn: &'astr, ålder: i32) -> Människan {
använda sig av låda:: schema:: människa;
låta new_human = NewHuman {
 förnamn,
 efternamn,
 ålder,
 };
 diesel:: insert_into (mänsklig:: tabell).values(&new_human).exekvera (conn).expect("Fel vid insättning av ny människa");
 human:: table.order (human:: id.desc()).first (conn).unwrap()
}

De Sätt in i funktionen tar in parametrarna och infogar värdena i databasen med Diesels Sätt in i funktion som tar in tabellen och värden funktion som tar in en struct-instans. Funktionen tilldelar ID i fallande ordning med besk funktion innan åtgärden utförs.

Här är huvud funktion som anropar Sätt in i fungera:

fnhuvud() {
låta anslutning = upprätta_anslutning();
låta new_human = insert_into(&conn, "John", "Hind", 25);
println!("Ny människa infogat med ID: {}", new_human.id);

}

De anslutning variabel är en anslutningsinstans och ny_människa variabel är funktionsanropet. De huvud funktionen skriver ut ID: t efter en lyckad operation.

Söka databaser med diesel

Alternativt kommer din frågefunktion struct att implementera Frågande attribut med en härleda makro.

Här är strukturen för frågeoperationen:

// Definiera en struktur som representerar en rad i din tabell
#[härleda (frågebar)]
strukturMänsklig {
 id: i32,
 förnamn: Sträng,
 efternamn: Sträng,
 ålder: i32,
}

Frågefunktionen tar in en anslutningsinstans och returnerar en Mänsklig struktur enligt följande:

fnquery_db(anslutning: &SqliteConnection) -> Human {
 human.filter (age.eq(25)).first (conn).expect("Fel vid förfrågan av databasen")
}

De query_db funktionen filtrerar den mänskliga tabellen för raden där ålder är lika med 25 och returnerar den första förekomsten som en struct-instans.

fnhuvud() {
låta anslutning = upprätta_anslutning();
låta person = query_db(&conn);
println!("ID: {}", person.id);
println!("Förnamn: {}", person.first_name);
println!("Efternamn: {}", person.efternamn);
println!("Ålder: {}", person.ålder);
}

I den huvud funktion, den person variabeln anropar query_db funktion och skriver ut fälten i raden med ett åldersvärde lika med 25.

Du kan bygga webbservrar med rost

Rust fortsätter att vinna popularitet inom webbutveckling som ett språk på serversidan med bibliotek som Actix-webb och Raket som gör det lättare att konfigurera servrar och bygga API: er och webbplatser genom att abstrahera komplex funktionalitet.

De flesta webbservrar måste interagera med databaser för datalagring och hämtning. Du kan ytterligare integrera dina dieseldrivna appar med Actix-web eller Rocket för att bygga sofistikerade webbapplikationer.