Diesel Rust: पूरी गाइड उदाहरणों के साथ

Diesel क्या है और इसकी आवश्यकता क्यों है?

Diesel, Rust प्रोग्रामिंग भाषा के लिए एक शक्तिशाली, सुरक्षित और विस्तार योग्य ORM (Object-Relational Mapping) लाइब्रेरी है। यह PostgreSQL, MySQL और SQLite जैसे रिलेशनल डेटाबेस के साथ टाइप-सेफ तरीके से इंटरैक्ट करने का एक तरीका प्रदान करता है। कई अन्य ORM के विपरीत, Diesel रनटाइम के दौरान किसी जादू या रिफ्लेक्शन का उपयोग नहीं करता है। इसके बजाय, यह कंपाइलेशन के समय सभी आवश्यक कोड जनरेट करता है, जो गारंटी देता है कि आपके क्वेरी सही हैं और रनटाइम के दौरान त्रुटियाँ नहीं होंगी।

Diesel का उपयोग करने के मुख्य कारण:

• टाइप सुरक्षा: SQL क्वेरी में त्रुटियाँ (जैसे गलत कॉलम नाम या टाइप बेमेल) प्रोडक्शन के बजाय कंपाइलेशन के समय पकड़ी जाती हैं।
• प्रदर्शन: Diesel अत्यधिक अनुकूलित कोड जनरेट करता है जो हाथ से लिखे SQL क्वेरी के स्तर पर काम करता है।
• विस्तारशीलता: आप आसानी से नए डेटा प्रकारों, ऑपरेटरों और फ़ंक्शनों के लिए समर्थन जोड़ सकते हैं।
• माइग्रेशन: बिल्ट-इन माइग्रेशन सिस्टम आपको डेटाबेस स्कीमा को कोड की तरह प्रबंधित करने की अनुमति देता है।
• सुरक्षा: Diesel स्वचालित रूप से क्वेरी पैरामीटर को एस्केप करता है, जिससे SQL इंजेक्शन को रोका जा सकता है।

Diesel उन प्रोजेक्ट्स के लिए आदर्श है जहाँ विश्वसनीयता, प्रदर्शन और डेटा सुरक्षा महत्वपूर्ण है। इसका व्यापक रूप से वेब एप्लिकेशन, API सेवाओं, डेटा प्रोसेसिंग टूल और किसी भी अन्य Rust प्रोजेक्ट में उपयोग किया जाता है जिसमें डेटाबेस के साथ इंटरैक्शन की आवश्यकता होती है।

Diesel की स्थापना (Installation)

Diesel की स्थापना में दो भाग शामिल हैं: प्रोजेक्ट में लाइब्रेरी जोड़ना और माइग्रेशन के लिए CLI टूल स्थापित करना।

1. Cargo.toml में जोड़ना

अपने प्रोजेक्ट की Cargo.toml फ़ाइल खोलें और डिपेंडेंसी जोड़ें। अपने डेटाबेस बैकएंड के अनुसार चुनें (या एक से अधिक):

[dependencies]
diesel = { version = "2.1", features = ["postgres"] }  # PostgreSQL के लिए
# diesel = { version = "2.1", features = ["mysql"] }   # MySQL के लिए
# diesel = { version = "2.1", features = ["sqlite"] }  # SQLite के लिए

2. CLI (Command Line Interface) स्थापित करना

diesel_cli टूल का उपयोग माइग्रेशन बनाने और चलाने के लिए किया जाता है। इसे cargo के माध्यम से स्थापित करें:

# PostgreSQL के लिए
cargo install diesel_cli --no-default-features --features postgres

# MySQL के लिए
cargo install diesel_cli --no-default-features --features mysql

# SQLite के लिए
cargo install diesel_cli --no-default-features --features sqlite

# सभी बैकएंड के लिए
cargo install diesel_cli

3. कनेक्शन सेटअप करना

प्रोजेक्ट की रूट में कनेक्शन स्ट्रिंग स्टोर करने के लिए .env फ़ाइल बनाएँ:

DATABASE_URL=postgres://username:password@localhost/diesel_demo

फिर अपने प्रोजेक्ट में Diesel को इनिशियलाइज़ करें:

diesel setup

यह कमांड diesel.toml फ़ाइल, migrations फ़ोल्डर बनाएगा और यदि डेटाबेस मौजूद नहीं है तो उसे बनाने का प्रयास करेगा।

कोड उदाहरण के साथ त्वरित शुरुआत

आइए उपयोगकर्ताओं को प्रबंधित करने के लिए एक सरल एप्लिकेशन बनाएँ।

1. माइग्रेशन बनाना

हम users टेबल बनाएँगे:

diesel migration generate create_users

माइग्रेशन फ़ाइलों को संपादित करें:

up.sql:

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR NOT NULL,
    email VARCHAR NOT NULL UNIQUE,
    age INTEGER NOT NULL DEFAULT 0,
    created_at TIMESTAMP NOT NULL DEFAULT NOW()
);

down.sql:

DROP TABLE users;

माइग्रेशन लागू करें:

diesel migration run

2. Rust में मॉडल परिभाषित करना

अपने प्रोजेक्ट में src/models.rs फ़ाइल बनाएँ और निम्नलिखित कोड जोड़ें:

use diesel::prelude::*;
use chrono::NaiveDateTime;

#[derive(Queryable, Selectable)]
#[diesel(table_name = crate::schema::users)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct User {
    pub id: i32,
    pub name: String,
    pub email: String,
    pub age: i32,
    pub created_at: NaiveDateTime,
}

3. नया उपयोगकर्ता बनाना (INSERT)

डेटाबेस में एक नया उपयोगकर्ता जोड़ने के लिए:

use diesel::insert_into;
use crate::schema::users;

pub fn create_user(conn: &mut PgConnection, name: &str, email: &str, age: i32) -> User {
    let new_user = NewUser { name, email, age };
    
    insert_into(users::table)
        .values(&new_user)
        .returning(User::as_returning())
        .get_result(conn)
        .expect("उपयोगकर्ता बनाने में त्रुटि")
}

#[derive(Insertable)]
#[diesel(table_name = users)]
struct NewUser<'a> {
    name: &'a str,
    email: &'a str,
    age: i32,
}

4. उपयोगकर्ता पढ़ना (SELECT)

सभी उपयोगकर्ताओं को प्राप्त करने के लिए:

use crate::schema::users::dsl::*;

pub fn get_all_users(conn: &mut PgConnection) -> Vec {
    users
        .load::(conn)
        .expect("उपयोगकर्ता लोड करने में त्रुटि")
}

pub fn get_user_by_id(conn: &mut PgConnection, user_id: i32) -> Option {
    users
        .find(user_id)
        .first::(conn)
        .ok()
}

5. उपयोगकर्ता अपडेट करना (UPDATE)

उपयोगकर्ता का नाम बदलने के लिए:

use diesel::update;
use crate::schema::users::dsl::*;

pub fn update_user_name(conn: &mut PgConnection, user_id: i32, new_name: &str) -> User {
    update(users.find(user_id))
        .set(name.eq(new_name))
        .returning(User::as_returning())
        .get_result(conn)
        .expect("उपयोगकर्ता अपडेट करने में त्रुटि")
}

6. उपयोगकर्ता हटाना (DELETE)

उपयोगकर्ता को हटाने के लिए:

use diesel::delete;

pub fn delete_user(conn: &mut PgConnection, user_id: i32) -> usize {
    delete(users.find(user_id))
        .execute(conn)
        .expect("उपयोगकर्ता हटाने में त्रुटि")
}

निष्कर्ष

Diesel Rust के लिए एक उत्कृष्ट ORM है जो टाइप सुरक्षा, प्रदर्शन और सुरक्षा प्रदान करता है। इस गाइड में हमने Diesel की स्थापना, माइग्रेशन, और CRUD ऑपरेशन के बारे में सीखा। Diesel के साथ, आप अपने Rust एप्लिकेशन में डेटाबेस को आसानी से और सुरक्षित रूप से एकीकृत कर सकते हैं। अधिक जानकारी के लिए, Diesel की आधिकारिक दस्तावेज़ीकरण देखें।