0Pricing
Learn Rust Coding · Pelajaran

Integrasi Basis Data (SQLx/Diesel)

Integrasikan layanan web Rust Anda dengan basis data menggunakan ORM atau pembangun kueri populer seperti SQLx atau Diesel.

Integrasi Basis Data (SQLx/Diesel) adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 2 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Mengapa Basis Data untuk Web?

Layanan web sering kali perlu menyimpan dan mengambil data secara persisten. Pikirkan profil pengguna, katalog produk, atau kiriman blog—data ini perlu berada di suatu tempat di luar memori program Anda.

Basis data menyediakan cara terstruktur untuk mengelola data ini, serta memastikan data tetap aman, konsisten, dan dapat diakses. Mengintegrasikan layanan web Rust Anda dengan basis data merupakan tugas inti bagi sebagian besar aplikasi dunia nyata.

SQLx: Rekan Basis Data Asinkron Anda

Dalam Rust, kita memiliki alat yang sangat baik untuk berinteraksi dengan basis data. Dua pilihan yang populer adalah SQLx dan Diesel.

  • SQLx: Crate SQL murni Rust yang asinkron dengan kueri yang diperiksa pada waktu kompilasi. SQLx sering dipilih untuk layanan web asinkron yang dibangun dengan kerangka kerja seperti Tokio.
  • Diesel: ORM (Pemetaan Relasional Objek) yang kuat dan menyediakan cara yang lebih abstrak untuk berinteraksi dengan basis data Anda, dengan memetakan struct Rust langsung ke tabel basis data. Diesel biasanya bersifat sinkron.

Dalam pelajaran ini, kita akan berfokus pada SQLx karena dukungan asinkronnya yang kuat, yang sangat sesuai dengan pengembangan layanan web Rust modern.

Penyiapan SQLx: Dependensi

Sebelum menulis kode, Anda perlu menambahkan sqlx dan tokio ke Cargo.toml proyek Anda. tokio menyediakan waktu proses asinkron yang diperlukan oleh sqlx.

Misalnya, untuk menggunakan SQLite (basis data berbasis file yang mudah digunakan untuk pengembangan lokal) dengan SQLx, Cargo.toml Anda mungkin terlihat seperti berikut:

[dependencies] sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "sqlite"] } tokio = { version = "1", features = ["full"] }

Anda juga biasanya menggunakan variabel lingkungan DATABASE_URL untuk mengonfigurasi string koneksi basis data.

Terhubung ke Basis Data Pertama Anda

Mari buat koneksi ke basis data SQLite dalam memori. SQLx menggunakan kumpulan koneksi yang mengelola beberapa koneksi basis data secara efisien untuk menangani permintaan konkuren dalam layanan web Anda.

Cobalah menjalankan contoh berikut:

use sqlx::SqlitePool;
use tokio;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    // Use an in-memory SQLite database for simplicity
    let database_url = "sqlite::memory:"; 
    let pool = SqlitePool::connect(&database_url).await?;
    println!("Successfully connected to the database!");

    // In a real web app, 'pool' would be passed around or stored in app state.

    Ok(())
}

Menyusun Data dengan Tabel

Sebelum dapat menyimpan data, kita perlu mendefinisikan skema basis data menggunakan DDL (Bahasa Definisi Data). Mari buat tabel tasks sederhana.

Makro sqlx::query! memungkinkan Anda menyematkan SQL langsung ke dalam kode Rust. Makro ini bahkan melakukan pemeriksaan SQL pada waktu kompilasi!

use sqlx::{SqlitePool, query};
use tokio;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = "sqlite::memory:";
    let pool = SqlitePool::connect(&database_url).await?;

    // Create a 'tasks' table if it doesn't exist
    query!(
        "CREATE TABLE IF NOT EXISTS tasks (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            description TEXT NOT NULL,
            completed BOOLEAN NOT NULL DEFAULT FALSE
        )"
    ).execute(&pool).await?;

    println!("Table 'tasks' created successfully!");
    Ok(())
}

Menambahkan Rekaman Baru

Sekarang setelah memiliki tabel, mari tambahkan beberapa data! Kita akan menggunakan pernyataan INSERT dengan pengikatan parameter. Cara ini melindungi dari injeksi SQL dan membuat kueri Anda lebih aman.

Perhatikan bahwa tempat penampung ? digunakan untuk parameter, dan nilainya diteruskan ke .bind().

use sqlx::{SqlitePool, query};
use tokio;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = "sqlite::memory:";
    let pool = SqlitePool::connect(&database_url).await?;

    query!(
        "CREATE TABLE IF NOT EXISTS tasks (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            description TEXT NOT NULL,
            completed BOOLEAN NOT NULL DEFAULT FALSE
        )"
    ).execute(&pool).await?;

    // Insert a new task
    let description = "Learn SQLx";
    let completed = false;
    query!(
        "INSERT INTO tasks (description, completed) VALUES (?, ?)",
        description,
        completed
    ).execute(&pool).await?;

    println!("Task '{}' inserted successfully!", description);
    Ok(())
}

Mengambil Data dengan SELECT

Untuk mengambil data dari tabel tasks, kita menggunakan pernyataan SELECT. SQLx menyediakan metode seperti .fetch_all() atau .fetch_one() untuk memperoleh hasil.

Anda dapat melakukan iterasi pada baris yang dikembalikan dan mengakses kolom berdasarkan nama atau indeks.

use sqlx::{SqlitePool, query};
use tokio;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = "sqlite::memory:";
    let pool = SqlitePool::connect(&database_url).await?;

    query!(
        "CREATE TABLE IF NOT EXISTS tasks (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            description TEXT NOT NULL,
            completed BOOLEAN NOT NULL DEFAULT FALSE
        )"
    ).execute(&pool).await?;

    query!(
        "INSERT INTO tasks (description, completed) VALUES (?, ?)",
        "Learn SQLx", false
    ).execute(&pool).await?;
    query!(
        "INSERT INTO tasks (description, completed) VALUES (?, ?)",
        "Build a web app", false
    ).execute(&pool).await?;

    // Fetch and print all tasks
    println!("\n--- All Tasks ---");
    let rows = query!("SELECT id, description, completed FROM tasks")
        .fetch_all(&pool).await?;

    for row in rows {
        println!("ID: {}, Desc: {}, Done: {}", 
            row.id, row.description, row.completed);
    }
    Ok(())
}

Data Aman Tipe dengan Struct

Mengekstrak data dari baris secara manual dapat menimbulkan kesalahan. Makro query_as! dari SQLx, yang dipadukan dengan #[derive(FromRow)], memungkinkan Anda memetakan hasil kueri langsung ke dalam struct Rust!

Hal ini memberikan keamanan tipe yang kuat dan membuat kode Anda jauh lebih bersih serta mudah digunakan.

use sqlx::{FromRow, SqlitePool, query, query_as};
use tokio;

#[derive(Debug, FromRow)]
struct Task {
    id: i64,
    description: String,
    completed: bool,
}

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = "sqlite::memory:";
    let pool = SqlitePool::connect(&database_url).await?;

    query!(
        "CREATE TABLE IF NOT EXISTS tasks (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            description TEXT NOT NULL,
            completed BOOLEAN NOT NULL DEFAULT FALSE
        )"
    ).execute(&pool).await?;

    query!(
        "INSERT INTO tasks (description, completed) VALUES (?, ?)",
        "Learn SQLx", false
    ).execute(&pool).await?;

    // Fetch tasks directly into our Task struct
    println!("\n--- Tasks as Structs ---");
    let tasks = query_as::<_, Task>("SELECT id, description, completed FROM tasks")
        .fetch_all(&pool).await?;

    for task in tasks {
        println!("{:?}", task);
    }
    Ok(())
}

Mengubah & Menghapus Rekaman

Memperbarui dan menghapus data mengikuti pola yang serupa dengan penyisipan. Anda menggunakan pernyataan SQL UPDATE dan DELETE dengan pengikatan parameter.

  • UPDATE: Mengubah baris yang ada berdasarkan klausa WHERE.
  • DELETE: Menghapus baris berdasarkan klausa WHERE.

Selalu berhati-hatilah dengan klausa WHERE dalam UPDATE dan DELETE untuk menghindari kehilangan data yang tidak disengaja!

use sqlx::{SqlitePool, query};
use tokio;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = "sqlite::memory:";
    let pool = SqlitePool::connect(&database_url).await?;

    query!(
        "CREATE TABLE IF NOT EXISTS tasks (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            description TEXT NOT NULL,
            completed BOOLEAN NOT NULL DEFAULT FALSE
        )"
    ).execute(&pool).await?;

    query!(
        "INSERT INTO tasks (description, completed) VALUES (?, ?)",
        "Finish lesson", false
    ).execute(&pool).await?;
    let task_id_to_update = 1;

    // Update a task
    query!(
        "UPDATE tasks SET completed = ? WHERE id = ?",
        true,
        task_id_to_update
    ).execute(&pool).await?;
    println!("Task {} updated.", task_id_to_update);

    // Delete a task (uncomment to run, careful with IDs after update)
    // let task_id_to_delete = 1;
    // query!(
    //     "DELETE FROM tasks WHERE id = ?",
    //     task_id_to_delete
    // ).execute(&pool).await?;
    // println!("Task {} deleted.", task_id_to_delete);

    Ok(())
}

Uji Keterampilan Basis Data Anda

Pernyataan manakah berikut yang TRUE mengenai SQLx dalam layanan web Rust?

Integrasi Basis Data: Inti Pembelajaran

Anda telah mengambil langkah penting dalam membangun layanan web Rust yang tangguh dengan mempelajari integrasi basis data!

  • Penyimpanan Persisten: Basis data sangat penting untuk menyimpan data aplikasi.
  • SQLx: Crate SQL asinkron yang diperiksa pada waktu kompilasi dan sangat cocok untuk layanan web.
  • Kumpulan Koneksi: Penting untuk akses basis data yang efisien dan konkuren.
  • CRUD: Kita telah membahas pembuatan (INSERT), pengambilan (SELECT), pembaruan (UPDATE), dan penghapusan (DELETE) data.
  • Keamanan Tipe: query_as! dan #[derive(FromRow)] memungkinkan pemetaan data yang aman dan praktis.

Selanjutnya, Anda dapat mempelajari cara mengintegrasikan operasi basis data ini ke dalam rute web yang sebenarnya!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Integrasi Basis Data (SQLx/Diesel)” gratis?

Ya — teks lengkap “Integrasi Basis Data (SQLx/Diesel)” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Integrasi Basis Data (SQLx/Diesel)”?

Integrasikan layanan web Rust Anda dengan basis data menggunakan ORM atau pembangun kueri populer seperti SQLx atau Diesel. Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 3.

Berapa lama pelajaran “Integrasi Basis Data (SQLx/Diesel)” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. API REST dengan Actix-web/Rocket
  2. Integrasi Basis Data (SQLx/Diesel)
  3. Autentikasi dan Otorisasi
← Kembali ke Learn Rust Coding