Trabalhando com bancos de dados SQL em Rust

À medida que você cria mais programas Rust, pode ser necessário interagir com bancos de dados para armazenamento e recuperação de dados.

A forte digitação, segurança de memória e desempenho de Rust, combinados com seu suporte para operações assíncronas, ORMs e migrações, permitem processamento de dados eficiente e escalável, tornando o Rust uma excelente escolha para a construção de banco de dados formulários.

Introdução ao uso de bancos de dados SQL em Rust

Existem muitas caixas de banco de dados e bibliotecas no ecossistema Rust que fornecem suporte para os vários paradigmas de banco de dados.

Para bancos de dados SQL, você pode escolher entre drivers de banco de dados como LibpqName, conector Mysql, e SQLite3 que fornecem uma interface para programas Rust interagirem com bancos de dados diretamente sem nenhuma camada de abstração no SQL e ORMs (Object-Relational Mappers) como Diesel, Sqlx, e Rust-postgres que fornecem uma maneira conveniente de trabalhar com banco de dados sobre

Tipos de dados de ferrugem como estruturas e funções.

O Diesel ORM é um dos pacotes de banco de dados mais populares no ecossistema Rust. Como um ORM, o Diesel fornece recursos desde a criação e execução de consultas até a definição de modelo e migrações de esquema de banco de dados, facilitando a interação com bancos de dados e escrever código eficiente, limpo e fácil de manter.

Diesel também suporta vários mecanismos de banco de dados, incluindo PostgreSQL, MySQL e SQLite, e fornece um conjunto robusto de recursos para lidar com operações de banco de dados complexas, como transações, junções e funções agregadas.

Com ferramentas poderosas, recursos e excelente documentação, o Diesel se tornou uma escolha obrigatória para muitos desenvolvedores Rust que buscam criar aplicativos robustos e escaláveis ​​baseados em dados.

Começando com Diesel

Você terá que adicionar o diesel e dotenv caixas para as dependências do seu projeto na seção de dependências do seu cargo.toml arquivo.

[dependências]
diesel = { versão = "1.4.4", características = ["sqlite"] }
dotenv = "0.15.0"

Depois de adicionar as caixas como dependências, você deve instalar o diesel_cli Ferramenta CLI para interagir com Diesel.

Execute este comando para instalar o diesel_cli ferramenta:

instalação de carga diesel_cli

Você pode chamar a ferramenta CLI com o diesel comando depois de instalar a ferramenta.

Em seguida, crie um arquivo de variáveis ​​de ambiente e especifique a URL do banco de dados.

Execute este comando para criar e inserir a URL do banco de dados para um banco de dados SQLite na memória.

echo DATABASE_URL=database.db > .env

Para trabalhar com Diesel, você deve instalar o sqlite3 ou seu banco de dados preferido em seu computador.

Por fim, execute o configurar comando para Diesel configurar um banco de dados para seu projeto:

configuração diesel

O configurar comando cria um migrações diretório, cria o banco de dados especificado no DATABASE_URLe executa as migrações existentes.

Configurando migrações com diesel

Depois de configurar seu banco de dados com Diesel, você usará o migração gerar comando para gerar arquivos de migração. Você adicionará o nome do arquivo como um argumento:

migração a diesel gerar create_humans

O comando gera dois arquivos SQL no migrações diretório: up.sql e down.sql.

Você escreverá SQL para suas definições de tabela de banco de dados no up.sql arquivo:

-- Seu SQL vai aqui
CRIARMESA"humano"
(
 "id" INTEIRO NÃO NULO AUTOINCREMENTO DE CHAVE PRIMÁRIA,
 "first_name" TEXTO NÃO NULO,
 "last_name" TEXTO NÃO NULO,
 "idade" INTEIRO NÃO NULO
);

Você escreverá código SQL para descartar tabelas de banco de dados no down.sql arquivo:

-- down.sql
-- Este arquivo deve desfazer qualquer coisa em `up.sql`
DERRUBARMESA"humano"

Depois de gravar os arquivos SQL, execute o execução de migração comando para aplicar migrações pendentes.

corrida de migração a diesel

Além disso, você pode usar o migração refazer comando para reverter migrações:

migração a diesel refazer

Além disso, você pode usar o esquema de impressão comando para imprimir o esquema. O comando imprime o conteúdo do esquema.rs arquivo.

esquema de impressão diesel

A saída do print_schema O comando é o código Rust que corresponde ao seu esquema SQL:

Conectando-se ao seu banco de dados SQL com Diesel

Primeiro, adicione essas importações e diretivas ao seu arquivo:

mod esquema;
#[macro_use]
externocaixote diesel;
usar dotenv:: dotenv;
usar diesel:: prelúdio::*;
usar padrão:: env;
usar Diesel::{Connection, ExpressionMethods, QueryDsl, RunQueryDsl, SqliteConnection};
usar engradado:: esquema:: humano;

Você usará as importações e diretivas para se conectar ao seu banco de dados e executar operações.

Veja como você pode se conectar a um banco de dados SQLite com uma função e retornar uma instância de conexão:

usar padrão:: env;
usar diesel::{Conexão, SqliteConnection};
fnestabelecer_conexão() -> SqliteConnection {
 dotenv().ok();
deixar database_url = env:: var("DATABASE_URL")
 .esperar("DATABASE_URL deve ser definido");
 SqliteConnection:: estabelecer(&database_url)
 .unwrap_or_else(|_| pânico!("Erro ao conectar a {}", banco de dados_url))
}

O estabelecer_conexão função retorna a instância de conexão struct (SqliteConnection). O estabelecer_conexão carrega as variáveis ​​de ambiente com o OK função, acessa a URL do banco de dados com o var função, e estabelece uma conexão com o banco de dados através da URL com o estabelecer função.

Após uma conexão bem-sucedida, você pode executar consultas e inseri-las em seu banco de dados.

Inserindo valores em um banco de dados com Diesel

Você usará uma estrutura que corresponde ao seu esquema SQL para inserir valores em seu banco de dados.

Aqui está uma estrutura que corresponde ao humano esquema da tabela:

#[derive (queryable)]
barestruturaHumano {
bar eu ia: i32,
bar primeiro nome: Corda,
bar sobrenome: Corda,
bar idade: i32,
}

A função de inserção retornará uma instância do Humano tipo para outras operações.

Você precisará de uma estrutura para sua função de inserção; a struct irá implementar dois atributos de macro, um para a funcionalidade de inserção e outro que identifica a tabela para a operação.

Aqui está a estrutura para a operação de inserção:

#[derivar (inserível)]
#[table_name = "humano"]
estruturaNovoHumano<'a> {
 primeiro nome: &'astr,
 sobrenome: &'astr,
 idade: i32,
}

Sua função de inserção receberá uma instância de conexão e os dados que você deseja inserir no banco de dados. Insira os dados e imprima uma mensagem com base no status da operação.

fninsira dentro de<'a>(conn: &SqliteConnection, first_name: &'astr, sobrenome: &'astr, idade: i32) -> Humano {
usar engradado:: esquema:: humano;
deixar novo_humano = NovoHumano {
 primeiro nome,
 sobrenome,
 idade,
 };
 diesel:: insert_into (humano:: tabela).values(&new_human).execute (conn).expect("Erro ao inserir novo humano");
 humano:: table.order (humano:: id.desc()).first (conn).unwrap()
}

O insira dentro de A função recebe os parâmetros e insere os valores no banco de dados com o Diesel's insira dentro de função que recebe a tabela e o valores função que recebe uma instância struct. A função atribui o ID em ordem decrescente com o descrição função antes de executar a operação.

Aqui está o principal função que chama o insira dentro de função:

fnprincipal() {
deixar conn = estabelecer_conexão();
deixar novo_humano = insert_into(&conn, "John", "Corça", 25);
println!("Novo humano inserido com ID: {}", new_human.id);

}

O conn variável é uma instância de conexão, e o novo_humano variável é a chamada de função. O principal A função imprime o ID após uma operação bem-sucedida.

Consultando bancos de dados com Diesel

Como alternativa, sua estrutura de função de consulta implementará o Pesquisável atributo com um derivar macro.

Aqui está a estrutura para a operação de consulta:

// Define uma struct que representa uma linha em sua tabela
#[derive (queryable)]
estruturaHumano {
 eu ia: i32,
 primeiro nome: Corda,
 sobrenome: Corda,
 idade: i32,
}

A função de consulta receberá uma instância de conexão e retornará um Humano estrutura da seguinte forma:

fnquery_db(conn: &SqliteConnection) -> Humano {
 humano.filtro (idade.eq(25)).first (conn).espera("Erro ao consultar o banco de dados")
}

O query_db A função filtra a tabela humana para a linha onde o idade é igual a 25 e retorna a primeira ocorrência como uma instância de struct.

fnprincipal() {
deixar conn = estabelecer_conexão();
deixar pessoa = query_db(&conn);
println!("EU IA: {}", person.id);
println!("Primeiro nome: {}", person.first_name);
println!("Sobrenome: {}", pessoa.último_nome);
println!("Idade: {}", pessoa.idade);
}

No principal função, o pessoa variável chama o query_db função e imprime os campos da linha com um valor de idade igual a 25.

Você pode construir servidores Web com Rust

Rust continua a ganhar popularidade no desenvolvimento web como uma linguagem do lado do servidor com bibliotecas como Actix-web e Foguete que facilitam a configuração de servidores e a criação de APIs e sites, abstraindo funcionalidades complexas.

A maioria dos servidores da Web precisa interagir com bancos de dados para armazenamento e recuperação de dados. Você pode integrar ainda mais seus aplicativos movidos a diesel com Actix-web ou Rocket para criar aplicativos da web sofisticados.