SQL-adatbázisok használata Rustban

Ahogy egyre több Rust-programot épít, előfordulhat, hogy adatbázisokkal kell kölcsönhatásba lépnie az adatok tárolása és visszakeresése céljából.

A Rust erős gépelése, memóriabiztonsága és teljesítménye az aszinkron műveletek, ORM-ek és A migráció lehetővé teszi a hatékony és méretezhető adatfeldolgozást, így a Rust kiváló választás adatbázis-építéshez alkalmazások.

Bevezetés az SQL-adatbázisok használatába a Rustban

A Rust ökoszisztémában számos adatbázis-láda és könyvtár található, amelyek támogatják a különféle adatbázis-paradigmákat.

SQL-adatbázisok esetén választhat az adatbázis-illesztőprogramok közül, mint például Libpq, Mysql-csatlakozó, és Sqlite3 amelyek interfészt biztosítanak a Rust programok számára, hogy közvetlenül, az SQL-en és az ORM-eken (Object-Relational Mappers) lévő absztrakciós réteg nélkül interakcióba lépjenek az adatbázisokkal, mint pl. Dízel, Sqlx, és Rust-postgres amelyek kényelmes módot biztosítanak az adatbázisokkal való munkavégzéshez

Rozsda adattípusok mint például a struktúrák és a függvények.

A Diesel ORM az egyik legnépszerűbb adatbáziscsomag a Rust ökoszisztémában. ORM-ként a Diesel funkciókat kínál a lekérdezések felépítésétől és végrehajtásától a modelldefinícióig és az adatbázisséma-migrációig, megkönnyítve az adatbázisokkal való interakciót és hatékony, tiszta és könnyen karbantartható kódot írhat.

A dízel is támogatja több adatbázismotor, köztük a PostgreSQL, a MySQL és az SQLite, és robusztus szolgáltatáskészletet biztosít összetett adatbázis-műveletek, például tranzakciók, csatlakozások és összesítő funkciók kezelésére.

Hatékony eszközeivel, szolgáltatásaival és kiváló dokumentációjával a Diesel számos Rust fejlesztő kedvenc választásává vált, akik robusztus és méretezhető adatvezérelt alkalmazásokat szeretnének építeni.

Kezdő lépések a dízellel

Hozzá kell adnia a dízel és dotenv ládákat a projekt függőségeihez a függőségek szakaszában rakomány.toml fájlt.

[függőségek]
dízel = { verzió = "1.4.4", funkciók = ["sqlite"] }
dotenv = "0.15.0"

A ládák függőségként történő hozzáadása után telepítenie kell a diesel_cli CLI-eszköz a Dieselrel való interakcióhoz.

Futtassa ezt a parancsot a diesel_cli eszköz:

rakomány telepítés diesel_cli

A CLI eszközt a dízel parancsot az eszköz telepítése után.

Ezután hozzon létre egy környezeti változófájlt, és adja meg az adatbázis URL-címét.

Futtassa ezt a parancsot az adatbázis URL-címének létrehozásához és beszúrásához egy memóriában lévő SQLite adatbázishoz.

echo DATABASE_URL=adatbázis.db > .env

A Diesel használatához telepítenie kell az sqlite3-at vagy a kívánt adatbázist a számítógépére.

Végül futtassa a beállít parancs a Diesel számára, hogy adatbázist állítson be a projekthez:

dízel beállítás

A beállít parancs létrehozza a vándorlások könyvtárban, létrehozza a megadott adatbázist DATABASE_URL, és futtatja a meglévő migrációkat.

Migrációk beállítása dízellel

Miután beállította az adatbázist a Diesel-lel, használja a migráció generál parancsot a migrációs fájlok generálásához. Hozzá kell adnia a fájl nevét argumentumként:

diesel migration generál create_humans

A parancs két SQL fájlt generál a vándorlások Könyvtár: fel.sql és le.sql.

Az adatbázistábla definícióihoz SQL-t kell írnia a fel.sql fájl:

-- Ide kerül az SQL-je
TEREMTASZTAL"emberi"
(
 "id" INTEGER NEM NULL ELSŐDLEGES KULCS AUTOMATIKUS NÖVELÉSE,
 "first_name" TEXT NOT NULL,
 "last_name" TEXT NOT NULL,
 "életkor" INTEGER NOT NULL
);

SQL kódot kell írnia az adatbázistáblák eldobásához a le.sql fájl:

-- le.sql
-- Ennek a fájlnak bármit vissza kell vonnia az `up.sql` fájlból
CSEPPASZTAL"emberi"

Az SQL fájlok írása után futtassa a migrációs futás parancs a függőben lévő migrációk alkalmazásához.

dízel migrációs futás

Ezenkívül használhatja a migráció újra parancs az áttelepítések visszaállításához:

diesel migration redo

Ezenkívül használhatja a print-séma parancsot a séma kinyomtatásához. A parancs kiírja a tartalmát schema.rs fájlt.

diesel print-séma

A kimenet a print_schema parancs egy Rust kód, amely megfelel az SQL-sémának:

Csatlakozás az SQL-adatbázishoz Diesel segítségével

Először adja hozzá ezeket az importálásokat és direktívákat a fájlhoz:

mod séma;
#[makró_használat]
külsőláda dízel;
használat dotenv:: dotenv;
használat diesel:: előjáték::*;
használat std:: env;
használat Diesel::{Kapcsolat, ExpressionMethods, QueryDsl, RunQueryDsl, SqliteConnection};
használat láda:: séma:: ember;

Az importálást és az utasításokat használja az adatbázishoz való csatlakozáshoz és a műveletek végrehajtásához.

A következőképpen kapcsolódhat egy SQLite adatbázishoz egy függvény segítségével, és hogyan adhat vissza egy kapcsolatpéldányt:

használat std:: env;
használat diesel::{Connection, SqliteConnection};
fnkapcsolat létrehozása() -> SqliteConnection {
 dotenv().ok();
hagyja adatbázis_url = env:: var("DATABASE_URL")
 .expect("A DATABASE_URL-t be kell állítani");
 SqliteConnection:: create(&adatbázis_url)
 .unwrap_or_else(|_| pánik!("Hiba a következőhöz való csatlakozáskor: {}", adatbázis_url))
}

A kapcsolat létrehozása függvény visszaadja a kapcsolatpéldány struktúrát (SqliteConnection). A kapcsolat létrehozása betölti a környezeti változókat a rendben függvény eléri az adatbázis URL-jét a var függvényt, és kapcsolatot létesít az adatbázissal az URL-en keresztül a létrehozni funkció.

Sikeres csatlakozás után lekérdezéseket hajthat végre, és beillesztheti őket az adatbázisba.

Értékek beszúrása egy adatbázisba Diesel segítségével

Az SQL-sémának megfelelő struktúrát használjon értékek beszúrásához az adatbázisba.

Itt van egy struktúra, amely megfelel a emberi táblázat séma:

#[derive (lekérdezhető)]
kocsmastructEmberi {
kocsma azonosító: i32,
kocsma keresztnév: Húr,
kocsma vezetéknév: Húr,
kocsma kor: i32,
}

A beszúrási függvény a Emberi típust az egyéb műveletekhez.

Szüksége lesz egy struktúrára a beillesztési funkcióhoz; a struktúra két makróattribútumot valósít meg, az egyik a beillesztési funkcióhoz, a másik pedig a művelet tábláját azonosítja.

Íme a beillesztési művelet szerkezete:

#[derive (Beszúrható)]
#[tábla_neve = "emberi"]
structNewHuman<'a> {
 keresztnév: &'astr,
 vezetéknév: &'astr,
 kor: i32,
}

Az Ön beszúrási funkciója bevesz egy kapcsolatpéldányt és az adatbázisba beszúrni kívánt adatokat. Illessze be az adatokat és nyomtasson egy üzenetet a művelet állapota alapján.

fnbeszúrás_be<'a>(conn: &SqliteConnection, keresztnév: &'astr, vezetéknév: &'astr, életkor: i32) -> Ember {
használat láda:: séma:: ember;
hagyja new_human = ÚjEmber {
 keresztnév,
 vezetéknév,
 kor,
 };
 diesel:: insert_into (human:: table).values(&new_human).execute (conn).expect("Hiba az új ember beszúrásakor");
 human:: table.order (human:: id.desc()).first (conn).unwrap()
}

A beszúrás_be függvény beveszi a paramétereket és beszúrja az értékeket az adatbázisba a Diesel segítségével beszúrás_be függvény, amely beveszi a táblázatot és a értékeket függvény, amely egy struct példányt vesz fel. A funkció az azonosítót a következővel csökkenő sorrendben rendeli hozzá desc funkciót a művelet végrehajtása előtt.

Íme a fő- függvény, amely meghívja a beszúrás_be funkció:

fnfő-() {
hagyja conn = kapcsolat_létesítése();
hagyja new_human = insert_into(&conn, "János", "Dámvadtehén", 25);
println!("Új ember beszúrva a következő azonosítóval: {}", new_human.id);

}

A konn változó egy kapcsolatpéldány, és a new_human változó a függvényhívás. A fő- funkció sikeres művelet után kinyomtatja az azonosítót.

Adatbázisok lekérdezése Diesel segítségével

Alternatív megoldásként a lekérdezési függvénystruktúrája megvalósítja a Lekérdezhető attribútum a származik makró.

Íme a lekérdezési művelet struktúrája:

// Határozzon meg egy struktúrát, amely egy sort reprezentál a táblázatban
#[derive (lekérdezhető)]
structEmberi {
 azonosító: i32,
 keresztnév: Húr,
 vezetéknév: Húr,
 kor: i32,
}

A lekérdező függvény felvesz egy kapcsolatpéldányt, és a következőt adja vissza Emberi a következőképpen építsd fel:

fnquery_db(csatlakozás: &SqliteConnection) -> Human {
 human.filter (age.eq(25)).first (conn).expect("Hiba az adatbázis lekérdezésekor")
}

A query_db függvény szűri a humán táblázatot arra a sorra, ahol a kor egyenlő 25-tel, és az első előfordulást struct példányként adja vissza.

fnfő-() {
hagyja conn = kapcsolat_létesítése();
hagyja személy = query_db(&conn);
println!("azonosító: {}", személy.azonosító);
println!("Keresztnév: {}", személy.utónév);
println!("Vezetéknév: {}", személy.vezetéknév);
println!("Kor: {}", személy.kor);
}

Ban,-ben fő- funkció, a személy változó a query_db függvényt, és kiírja a sor mezőit 25-ös korértékkel.

Webszervereket készíthet rozsdával

A Rust továbbra is egyre népszerűbb a webfejlesztésben, mint szerveroldali nyelv, olyan könyvtárakkal, mint például Actix-web és Rakéta amelyek megkönnyítik a szerverek beállítását, valamint az API-k és webhelyek létrehozását az összetett funkciók elvonásával.

A legtöbb webszervernek kölcsönhatásba kell lépnie az adatbázisokkal az adatok tárolása és visszakeresése céljából. Tovább integrálhatja dízelmotoros alkalmazásait az Actix-web vagy a Rocket szolgáltatással kifinomult webalkalmazások létrehozásához.