Lavorare con i database SQL in Rust

Man mano che crei più programmi Rust, potresti dover interagire con i database per l'archiviazione e il recupero dei dati.

La forte tipizzazione, la sicurezza della memoria e le prestazioni di Rust, combinate con il suo supporto per operazioni asincrone, ORM e migrazioni, consentono un'elaborazione dei dati efficiente e scalabile, rendendo Rust una scelta eccellente per la creazione di database applicazioni.

Introduzione all'uso dei database SQL in Rust

Ci sono molti database crate e librerie nell'ecosistema Rust che forniscono supporto per i vari paradigmi di database.

Per i database SQL, puoi scegliere tra driver di database come Lippq, Mysql-connector, E SQLite3 che forniscono un'interfaccia per i programmi Rust per interagire direttamente con i database senza alcun livello di astrazione su SQL e ORM (Object-Relational Mapper) come Diesel, Sqlx, E Postgres ruggine che forniscono un modo conveniente per lavorare con il database Tipi di dati Rust come struct e funzioni.

Diesel ORM è uno dei pacchetti di database più popolari nell'ecosistema Rust. Come ORM, Diesel fornisce funzionalità dalla creazione ed esecuzione di query alla definizione del modello e alle migrazioni dello schema del database, semplificando l'interazione con i database e scrivere codice efficiente, pulito e di facile manutenzione.

Anche Diesel supporta più motori di database tra cui PostgreSQL, MySQL e SQLitee fornisce un solido set di funzionalità per la gestione di complesse operazioni di database come transazioni, join e funzioni di aggregazione.

Con potenti strumenti, funzionalità e un'eccellente documentazione, Diesel è diventata una scelta di riferimento per molti sviluppatori Rust che desiderano creare applicazioni basate sui dati robuste e scalabili.

Iniziare con il diesel

Dovrai aggiungere il diesel E dotenv casse alle dipendenze del tuo progetto nella sezione delle dipendenze del tuo cargo.toml file.

[dipendenze]
diesel = { versione = "1.4.4", caratteristiche = ["sqlite"] }
dotenv = "0.15.0"

Dopo aver aggiunto le casse come dipendenze, è necessario installare il file diesel_cli Strumento CLI per interagire con Diesel.

Eseguire questo comando per installare il file diesel_cli attrezzo:

carico installare diesel_cli

Puoi chiamare lo strumento CLI con l'estensione diesel comando dopo aver installato lo strumento.

Successivamente, crea un file delle variabili di ambiente e specifica l'URL del tuo database.

Eseguire questo comando per creare e inserire l'URL del database per un database SQLite in memoria.

echo DATABASE_URL=database.db > .env

Per lavorare con Diesel, devi installare sqlite3 o il tuo database preferito sul tuo computer.

Infine, esegui il file impostare comando per Diesel per impostare un database per il tuo progetto:

allestimento diesel

IL impostare comando crea un migrazioni directory, crea il database specificato nella DATABASE_URLed esegue le migrazioni esistenti.

Impostazione delle migrazioni con Diesel

Dopo aver impostato il tuo database con Diesel, utilizzerai il file la migrazione genera comando per generare i file di migrazione. Aggiungerai il nome del file come argomento:

la migrazione diesel genera create_humans

Il comando genera due file SQL nel formato migrazioni rubrica: up.sql E down.sql.

Scriverai SQL per le definizioni della tabella del tuo database nel file up.sql file:

-- Il tuo SQL va qui
CREARETAVOLO"umano"
(
 "id" INTERO NON NULL AUTOINCREMENTO DELLA CHIAVE PRIMARIA,
 "first_name" TEXT NOT NULL,
 "cognome" TEXT NOT NULL,
 "età" INTERO NON NULL
);

Scriverai il codice SQL per eliminare le tabelle del database nel file down.sql file:

--down.sql
-- Questo file dovrebbe annullare qualsiasi cosa in `up.sql`
GOCCIOLARETAVOLO"umano"

Dopo aver scritto i file SQL, eseguire il file corsa di migrazione comando per applicare le migrazioni in sospeso.

corsa di migrazione diesel

Inoltre, puoi utilizzare il migrazione rifatta comando per annullare le migrazioni:

migrazione diesel rifatta

Inoltre, puoi usare il schema di stampa comando per stampare lo schema. Il comando stampa il contenuto del file schema.rs file.

schema di stampa diesel

L'uscita del print_schema comando è il codice Rust che corrisponde al tuo schema SQL:

Connessione al database SQL con Diesel

Innanzitutto, aggiungi queste importazioni e direttive al tuo file:

mod schema;
#[macro_uso]
esternocassa diesel;
utilizzo dotenv:: dotenv;
utilizzo diesel:: preludio::*;
utilizzo std:: env;
utilizzo Diesel::{Connection, ExpressionMethods, QueryDsl, RunQueryDsl, SqliteConnection};
utilizzo cassa:: schema:: umano;

Utilizzerai le importazioni e le direttive per connetterti al tuo database ed eseguire operazioni.

Ecco come puoi connetterti a un database SQLite con una funzione e restituire un'istanza di connessione:

utilizzo std:: env;
utilizzo diesel::{Connessione, SqliteConnection};
fnstabilire_connessione() -> SqliteConnection {
 dotenv().ok();
permettere database_url = env:: var("URL_DATABASE")
 .aspettarsi("DATABASE_URL deve essere impostato");
 SqliteConnection:: stabilire(&database_url)
 .unwrap_or_else(|_| panico!("Errore durante la connessione a {}", database_url))
}

IL stabilire_connessione la funzione restituisce la struttura dell'istanza di connessione (SqliteConnection). IL stabilire_connessione carica le variabili di ambiente con il file OK funzione, accede all'URL del database con il var funzione e stabilisce una connessione con il database tramite l'URL con il stabilire funzione.

Dopo una connessione riuscita, puoi eseguire query e inserirle nel tuo database.

Inserimento di valori in un database con Diesel

Utilizzerai una struttura che corrisponda al tuo schema SQL per inserire i valori nel tuo database.

Ecco una struttura che corrisponde a umano schema della tabella:

#[derivare (interrogabile)]
pubstructUmano {
pub id: i32,
pub nome di battesimo: Corda,
pub cognome: Corda,
pub età: i32,
}

La funzione di inserimento restituirà un'istanza di Umano digitare per altre operazioni.

Avrai bisogno di una struttura per la tua funzione di inserimento; la struct implementerà due macro attributi, uno per la funzionalità di inserimento e l'altro che identifica la tabella per l'operazione.

Ecco la struttura per l'operazione di inserimento:

#[deriva (Inseribile)]
#[nome_tabella = "umano"]
structNewHuman<'UN> {
 nome di battesimo: &'UNstr,
 cognome: &'UNstr,
 età: i32,
}

La tua funzione di inserimento prenderà un'istanza di connessione e i dati che vuoi inserire nel database. Inserisci i dati e stampa un messaggio in base allo stato dell'operazione.

fninserire<'UN>(conn: &SqliteConnection, first_name: &'UNstr, cognome: &'UNstr, età: i32) -> Umano {
utilizzo cassa:: schema:: umano;
permettere new_human = NewHuman {
 nome di battesimo,
 cognome,
 età,
 };
 diesel:: insert_into (human:: table).values(&new_human).execute (conn).expect("Errore durante l'inserimento di un nuovo essere umano");
 umano:: table.order (umano:: id.desc()).first (conn).unwrap()
}

IL inserire la funzione prende i parametri e inserisce i valori nel database con Diesel inserire funzione che accetta la tabella e il valori funzione che accetta un'istanza struct. La funzione assegna l'ID in ordine decrescente con il desc funzione prima di eseguire l'operazione.

Ecco il principale funzione che chiama il inserire funzione:

fnprincipale() {
permettere conn = stabilire_connessione();
permettere new_human = insert_into(&conn, "John", "Dai", 25);
stampa!("Nuovo essere umano inserito con ID: {}", nuovo_umano.id);

}

IL conn variabile è un'istanza di connessione e la nuovo_umano variabile è la chiamata alla funzione. IL principale funzione stampa l'ID dopo un'operazione riuscita.

Interrogazione di database con Diesel

In alternativa, la tua funzione di query struct implementerà il Interrogabile attributo con a derivare macro.

Ecco la struttura per l'operazione di query:

// Definisci una struttura che rappresenta una riga nella tua tabella
#[derivare (interrogabile)]
structUmano {
 id: i32,
 nome di battesimo: Corda,
 cognome: Corda,
 età: i32,
}

La funzione di query prenderà in un'istanza di connessione e restituirà a Umano strutturare come segue:

fnquery_db(conn: &SqliteConnection) -> Umano {
 filtro.umano (età.eq(25)).first (conn).expect("Errore durante l'interrogazione del database")
}

IL query_db funzione filtra la tabella umana per la riga in cui il file età è uguale a 25 e restituisce la prima occorrenza come istanza di struct.

fnprincipale() {
permettere conn = stabilire_connessione();
permettere persona = query_db(&conn);
stampa!("ID: {}", persona.id);
stampa!("Nome di battesimo: {}", persona.nome_nome);
stampa!("Cognome: {}", persona.cognome);
stampa!("Età: {}", persona.età);
}

Nel principale funzione, il persona variabile chiama il query_db funzione e stampa i campi della riga con un valore di età pari a 25.

Puoi creare server Web con Rust

Rust continua a guadagnare popolarità nello sviluppo web come linguaggio lato server con librerie come Actix-web E Razzo che semplificano la configurazione dei server e la creazione di API e siti Web astraendo funzionalità complesse.

La maggior parte dei server Web deve interagire con i database per l'archiviazione e il recupero dei dati. Puoi integrare ulteriormente le tue app basate su Diesel con Actix-web o Rocket per creare sofisticate applicazioni web.