e
sv

Diesel ve SQLx kullanarak Rust'ta veritabanlarıyla etkileşim kurma

avatar

Yazılım Method

  • e 0

    Mutlu

  • e 0

    Eğlenmiş

  • e 0

    Şaşırmış

  • e 0

    Kızgın

  • e 0

    Üzgün

Bu öğreticide, Rust’ta ilişkisel veritabanlarıyla etkileşim kurarken kullanılan iki kitaplığı inceleyeceğiz: Diesel ve SQLx.

Bu makale, her bir yaklaşımı göstermek için öğrencilerle birlikte basit bir sınıf veritabanını kullanacaktır. CRUD işlemlerini Diesel ORM ve SQLx kullanarak gerçekleştireceğiz.

Neleri ele alacağız:

Bu öğreticiyi takip etmek için, Rust’a, Rust’ın yapı sistemi ve paket yöneticisi Cargo’ya ve bir MySQL sunucu örneğine erişme ve kullanma yeteneğinin yanı sıra Rust hakkında çalışma bilgisine ihtiyacınız olacak.

Dizel nedir?

Diesel, PostgreSQL, MySQL, SQLite’ı destekleyen bir ORM’dir. ORM, nesne ilişkisel eşleme anlamına gelir. ORM’ler, nesne yönelimli programcıların ilişkisel veritabanlarının ayrıntılarını soyutlamasına yardımcı olur.

ORM’ler sorgu oluşturucularla birlikte gönderilir, bu nedenle ham SQL sorguları yazma konusunda endişelenmenize gerek yoktur. ORM’leri kullanarak, ilişkisel veritabanları ile nesne yönelimliymiş gibi iletişim kurabilirsiniz.

Daha az deneyimli geliştiriciler için ORM’leri kullanmak daha iyi olabilir çünkü ORM’ler optimize edilmiş SQL sorguları oluşturur. ORM’ler ayrıca sizi SQL enjeksiyon saldırılarına daha az eğilimli hale getirir.

SQLx nedir?

Diesel’den farklı olarak, SQLx bir ORM değildir. SQLx, derleme zamanı SQL sorgu kontrollerini içeren eşzamansız bir Rust SQL kasasıdır . Hem veritabanı hem de çalışma zamanından bağımsızdır.

SQLx, bağlantı havuzu oluşturma, platformlar arası geliştirme, iç içe havuz oluşturma, eşzamansız bildirimler, aktarım katmanı güvenliği ve diğer heyecan verici özellikleri destekler. SQLx kullanırken, SQL sorgularını ve geçişlerini kendiniz oluşturmalısınız.

Yüzeyi çizdikten sonra, Diesel ve SQLx ile ilişkisel veritabanlarıyla nasıl etkileşime girileceğini keşfedelim.

Dizel ORM’ye Başlarken

Aşağıdaki adımlar, Dizel ORM kullanan Cargo ile bir Rust projesinin nasıl kurulacağını gösterir.

Diesel ORM ile yeni bir proje başlatma

İlk adımınız, aşağıdaki komutu çalıştırarak projeyi başlatmaktır:

 kargo yeni -- lib class_diesel
cd class_diesel

Yukarıdaki kodda projeyi kurduk ve classroom_diesel adını verdik. Yeni proje dizini şöyle görünmelidir:

 ./
│
├── kaynak/
│ └── lib.rs
│
├── .gitignore
└── Kargo.toml

Ayrıca Cargo.toml dosyasını projede ihtiyacımız olan bağımlılıklarla güncellememiz gerekiyor, şöyle:

 [bağımlılıklar]
dizel = { sürüm = "1.4.4", özellikler = ["mysql"] }
dotenv = "0.15.0"

dotenv bağımlılığı, projedeki ortam değişkenlerini yönetmemize yardımcı olur.

Dizel CLI Kurulumu

Diesel, ayrı bir CLI aracı kullanır . Bu bağımsız bir ikili dosyadır; Bunu cargo.toml dosyasına bağımlılık olarak eklememize gerek yok. Basitçe aşağıdaki komutla yükleyin:

 kargo kurulumu Diesel_cli

Dizel ortamımızı ayarlama

Ortamımızda bir DATABASE_URL değişkeni ayarlamamız gerekiyor. Diesel, hangi MySQL veritabanına bağlanacağını şu şekilde bilir:

 echo DATABASE_URL=mysql://<kullanıcı adı>:<parola>@localhost/<veritabanı> > .env

Yerel veritabanı kimlik bilgilerinizle eşleşmesi için bağlantı dizesini düzenleyin.

Proje dizininiz şimdi şöyle görünecek:

 ./
│
├── kaynak/
│ └── lib.rs
│
├── .env
├── .gitignore
└── Kargo.toml

Şimdi aşağıdaki komutu çalıştırın:

 dizel kurulum

Bu komut, veritabanını kurmamıza ve veritabanı şemasını yönetmek için boş bir geçiş dizini oluşturmamıza yardımcı olacaktır.

Dizel geçişlerini ayarlama

Geçişler, ORM’nin alan ekleme veya tablo silme gibi veritabanı işlemlerini izlemesine yardımcı olur. Bunları veritabanınız için bir sürüm kontrol sistemi olarak düşünebilirsiniz.

İlk olarak, Diesel CLI kullanarak sınıf uygulaması için bazı migrasyonlar oluşturalım. İdeal olarak, sınıf öğrencileri hakkında veri içeren bir tablomuz olmalıdır.
Boş geçiş dosyaları oluşturmamız ve ardından bir tablo oluşturmak için bunları SQL ile doldurmamız gerekiyor.

 dizel geçişi create_students oluşturur

Dosya ağacınız şuna benzer:

 ./
│
├── göçler/
│ │
│ ├── 2022-07-04-062521_create_students/
│ │ ├── down.sql
│ │ └── up.sql
│ │
│ └── .gitkeep
│
├── kaynak/
│ └── lib.rs
│
├── .env
├── .gitignore
├── Kargo.toml
└── dizel.toml

up.sql dosyası bir geçiş oluşturmak içindir, down.sql dosyası ise bunu tersine çevirmek içindir.

up.sql dosyasını geçiş için SQL ile güncelleyin:

 sql
TABLO OLUŞTUR öğrenciler (
  id INTEGER AUTO_INCREMENT BİRİNCİL ANAHTAR,
  ad VARCHAR(255) NULL DEĞİL,
  soyadı METİN NULL DEĞİL,
  yaş INTEGER NULL DEĞİL
);

down.sql dosyasını, geçişi tersine çevirebilecek SQL ile değiştirin:

 sql
DROP TABLO öğrencileri;

up ve down geçişleri oluşturduktan sonra, veritabanında SQL’i çalıştırmamız gerekiyor:

 dizel geçiş çalıştırması

Masa üzerinde sorgulama yapmak için Rust yazmaya başlayabiliriz.

Diesel ORM ile satır oluşturma

.env dosyasında ayarlanan bağlantı dizesini kullanarak MySQL sunucusuna bağlantı kurmak için kod yazalım.

 #[makro_kullanımı]
dış kasa dizel;
dış sandık dotenv;

pub mod modelleri;
pub mod şeması;

dizel kullanın::prelude::*;
dotenv::dotenv kullanın;
std::env kullanın;

pub fn create_connection() -> MysqlConnection {
    dotenv().ok();

    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL ayarlanmalıdır");
    MysqlConnection::install(&database_url)
        .unwrap_or_else(|_| panik!("{}'a bağlanma hatası", database_url))
}

Ardından, Students tablosu için bir model yazmalıyız. Modeller, nesne-ilişkisel eşlemenin gerçekleştiği yerdir. Model, Students tablosundaki bir satırı veya satırları Rust’ta bir Student yapısına dönüştürmek için gereken kodu üretecektir.

 cd./src
dokunmatik model.rs

Az önce oluşturduğumuz yeni model.rs dosyasına aşağıdakileri ekleyin:

 super::schema::students;

#[türet(Sorgulanabilir)]
pub yapısı Öğrenci {
    yayın kimliği: i32,
    pub adı: Dize,
    pub soyadı: Dize,
    pub yaşı: i32,
}

#[derive(Eklenebilir)]
#[table_name = "öğrenciler"]
pub struct NewStudent<'a> {
    pub adı: &'a str,
    pub soyadı: &'a str,
    pub yaşı: &'a i32,
}

Bu modelle, Students tablosundaki bilgiler, Rust’taki karşılık gelen Student yapısıyla eşlenir. src klasörü şimdi şöyle görünmelidir:

 kaynak/
├── lib.rs
├── modeller.rs
└── schema.rs

Şimdi bir öğrenci eklemek için bir komut dosyası yazabiliriz:

 cd kaynağı
mkdir kutusu
cd kutusu
create_students.rs'ye dokunun

create_students.rs dosyasında, yeni bir öğrenci oluşturmak için daha önce yazılmış modelleri ve işlevleri çağırabiliriz:

 harici sandık class_diesel;
dış kasa dizel;

kendini kullan::classroom_diesel::*;
fn ana() {
    let bağlantı = create_connection();
    let ad = "John";
    let soyadı = "Doe";
    yaş olsun: i32 = 64;

    let öğrenci = create_post(&bağlantı, ad, soyad, &yaş);
    yazdır!(
        "{} kimlikli kayıtlı öğrenci {}",
        öğrenci.ad, öğrenci.kimliği
    );
}

Projenin yapısı şimdi şuna benzer:

 ./
│
├── göçler/
│ │
│ ├── 2022-07-04-062521_create_students/
│ │ ├── down.sql
│ │ └── up.sql
│ │
│ └── .gitkeep
│
├── kaynak/
│ │
│ ├── çöp kutusu/
│ │ └── create_students.rs
│ │
│ ├── lib.rs
│ ├── modeller.rs
│ └── schema.rs
│
├── .env
├── .gitignore
├── Kargo kilidi
├── Kargo.toml
└── dizel.toml

Aşağıdaki komutu kullanarak yeni komut dosyasını yürütün:

 kargo çalıştırma --bin create_students

Aşağıdaki resimde görebileceğiniz gibi, John için yeni öğrenci dosyası 1 id ile kaydedilmiştir. Bir sonraki bölümde inceleyeceğimiz Rust veritabanlarını sorgulamak için bu id kullanabiliriz.

Dizel ORM'de Yeni Öğrenci Dosyası Oluşturmak İçin Öğrenci Tablosunu Bir Yapıya Eşleştirme Sonucu

Diesel ORM ile Rust veritabanı sorgulama

Bir önceki bölümde, Diesel ORM kullanarak Rust’ta veri tabanına nasıl yazılacağını inceledik. Sorgulamanın veya okumanın nasıl çalıştığını anlamak da önemlidir.

id 1 olan bir öğrenciyi sorgulamak için bir script yazalım. Bir query_students.rs dosyası oluşturarak başlayın:

 cd kutusu
query_students.rs'ye dokunun

Ardından, az önce oluşturduğumuz query_students.rs dosyasına aşağıdakileri ekleyin:

 harici sandık class_diesel;
dış kasa dizel;

self::models::*;
class_diesel::*;
dizel kullanın::prelude::*;

fn ana() {
    self::schema::students::dsl::*;

    let bağlantı = create_connection();
    olsun sonuç = öğrenciler
        .filter(id.eq(1))
        .load::<Öğrenci>(&bağlantı)
        .expect("Öğrenciler yüklenirken hata oluştu");

    yazdır!(
        "Öğrenci: {} {} {} yıl",
        sonuç[0].ad, sonuç[0].soyad, sonuç[0].yaş
    );
}

Komut dosyasını yürütün:

 kargo çalıştırma --bin query_students

Aşağıdaki resimde de görebileceğiniz gibi, veritabanından sorguladığımız öğrenci dosyasının adını, soyadını ve yaşını içeren bir satır çıktı:

Diesel ORM Kullanarak Bir Rust Veritabanından Öğrenci Dosyasını Sorgulamanın Sonucu

SQLx’i kullanmaya başlama

Artık Rust’ta veritabanlarıyla etkileşim kurmak için Diesel ORM kullanan bir projenin nasıl oluşturulacağını bildiğimize göre, bunun yerine SQLx kullanan bir projenin nasıl oluşturulacağına bir göz atalım.

SQLx ile yeni bir proje başlatma

Aşağıdaki komutu çalıştırarak başlayın:

 kargo yeni class_sqlx --bin

Ardından, cargo.toml dosyasına gerekli bağımlılıkları ekleyin:

 [bağımlılıklar]
sqlx = { version = "0.5", özellikler = [ "runtime-async-std-native-tls", "mysql" ] }
async-std = {sürüm = "1", özellikler = [ "nitelikler" ] }

Kurulum için ihtiyacınız olan tek şey bu. Basit, değil mi?

SQLx’i Rust’ta veritabanlarıyla etkileşimde bulunmak için kullanmak için tek yapmamız gereken bazı SQL sorguları ve Rust kodu yazmak. Diesel ORM bölümünde öğrenci kaydı oluşturup okuduk; Bu bölümde bir kaydı güncellemek ve silmek için sorgular yazacağız.

Veritabanı kayıtlarını güncellemek veya silmek için SQLx ve Rust kullanma

İlk olarak, SQLx’i MySQL sunucusuna bağlamak için biraz Rust kodu yazmamız gerekiyor:

 //main.rs

sqlx::mysql::MySqlPoolOptions kullanın;

#[async_std::ana]
async fn main() -> Sonuç<(), sqlx::Error> {
    havuza izin ver = MySqlPoolOptions::new()
        .max_connections(7)
        .connect("mysql://root:@localhost/classroom_diesel")
        .bekliyor musun?;

    Tamam(())
}

SQLx, hem hazırlanmış hem de hazırlıksız SQL sorgularını destekler. Hazırlanan SQL sorguları, SQL enjeksiyonuna karşıdır.

Birincil anahtar 1 olan bir kaydın adını ve soyadını nasıl güncelleyeceğinizi görelim:

 sqlx::mysql::MySqlPoolOptions kullanın;

#[async_std::ana]
async fn main() -> Sonuç<(), sqlx::Error> {
    havuza izin ver = MySqlPoolOptions::new()
        .max_connections(5)
        .connect("mysql://root:@localhost/classroom_diesel")
        .bekliyor musun?;

    sqlx::query("Öğrencilerin SET adı=?, soyadı=? WHERE id=?")
        .bind("Richard")
        .bind("Karaca")
        .bağlama(1)
        .execute(&havuz)
        .bekliyor musun?;
    Tamam(())
}

Komut dosyasını aşağıdaki komutla yürütün:

 kargo koşusu

Kaydı silmek de benzer bir yol izler; tek fark SQL sorgusudur:

 sqlx::mysql::MySqlPoolOptions kullanın;

#[async_std::ana]
async fn main() -> Sonuç<(), sqlx::Error> {
    havuza izin ver = MySqlPoolOptions::new()
        .max_connections(5)
        .connect("mysql://root:@localhost/classroom_diesel")
        .bekliyor musun?;

    sqlx::query("Öğrencilerden SİL NEREDE id=?")
        .bağlama(1)
        .execute(&havuz)
        .bekliyor musun?;
    Tamam(())
}

Komut dosyasını aşağıdaki komutla yürütün:

 kargo koşusu

Artık Rust’ta Diesel veya SQLx kullanarak veritabanlarıyla etkileşime girebilirsiniz.

Çözüm

Dizel gibi ORM’ler yeterlidir; ihtiyacınız olan SQL’in bir kısmını oluşturmanıza yardımcı olurlar. Çoğu zaman, uygulamalarınızda ihtiyacınız olan tek şey yeterlidir.

Ancak, daha kapsamlı uygulamalarda ORM’lerin doğru çalışması ve performanslı SQL sorguları oluşturması için daha fazla “sihir” – başka bir deyişle, zamanınız ve çabanız – gerekebilir.

Yüksek hacimli ve düşük gecikme gereksinimleri olan daha karmaşık sorgular oluşturma ihtiyacı ortaya çıkarsa, ham SQL sorgularını yürütmek için SQLx gibi kitaplıkları kullanmak daha iyi olabilir.

etiketlerETİKETLER
Üzgünüm, bu içerik için hiç etiket bulunmuyor.

Sıradaki içerik:

Diesel ve SQLx kullanarak Rust'ta veritabanlarıyla etkileşim kurma