PricingLoginStart free
Belajar Pengaturcaraan Rust · Pelajaran

Integrasi Pangkalan Data

Kekalkan data

Pelajaran 3 daripada 413 langkah

Integrasi Pangkalan Data ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 4 pelajaran.

Menyimpan Data secara Berterusan

Setakat ini, API kami menyimpan data dalam memori, yang hilang apabila dimulakan semula. Perkhidmatan sebenar memerlukan pangkalan data. Dalam pelajaran ini, kami menyambungkan API Axum kepada PostgreSQL menggunakan sqlx, iaitu kit alat SQL tak segerak untuk Rust yang disemak pada masa kompilasi.

Anda akan mempelajari kumpulan sambungan, pertanyaan, pemetaan baris kepada struct dan penggunaan kumpulan sebagai keadaan yang dikongsi.

Menambah sqlx

Tambahkan sqlx dengan ciri yang anda perlukan: runtime, TLS dan pemacu pangkalan data. Berikut ialah persediaan Postgres menggunakan Tokio.

// Cargo.toml
// [dependencies]
// sqlx = { version = "0.7", features = [
//   "runtime-tokio", "tls-rustls", "postgres", "macros"
// ] }

Kumpulan Sambungan

Membuka sambungan baharu untuk setiap permintaan adalah perlahan. Kumpulan sambungan menyimpan sekumpulan sambungan yang boleh digunakan semula. PgPoolOptions membina satu kumpulan daripada URL pangkalan data. Kumpulan ini murah untuk diklon (kerana kiraan rujukan dikendalikan secara dalaman), menjadikannya sesuai sebagai keadaan yang dikongsi.

use sqlx::postgres::PgPoolOptions;

async fn make_pool(url: &str) -> sqlx::PgPool {
    PgPoolOptions::new()
        .max_connections(5)
        .connect(url)
        .await
        .expect("failed to connect")
}

Kumpulan sebagai Keadaan Aplikasi

Hantar kumpulan kepada Axum dengan .with_state(pool). Pengendali kemudiannya menerima State(pool): State<PgPool>. Oleh sebab kumpulan murah untuk diklon, setiap permintaan berkongsi sambungan asas yang sama.

use axum::{routing::get, Router};
use sqlx::PgPool;

fn build(pool: PgPool) -> Router {
    Router::new()
        .route("/todos", get(list_todos))
        .with_state(pool)
}

Menjalankan Pertanyaan

Fungsi sqlx::query menjalankan SQL mentah. Ikat parameter dengan .bind(value) untuk mengelakkan suntikan SQL; Postgres menggunakan ruang letak $1, $2. Gunakan .execute(&pool) untuk penulisan yang tidak mengembalikan baris.

use sqlx::PgPool;

async fn insert_todo(pool: &PgPool, title: &str) -> Result<(), sqlx::Error> {
    sqlx::query("INSERT INTO todos (title, done) VALUES ($1, $2)")
        .bind(title)
        .bind(false)
        .execute(pool)
        .await?;
    Ok(())
}

Memetakan Baris kepada Struct

Turunkan sqlx::FromRow pada model anda supaya hasil pertanyaan boleh dipetakan terus kepadanya. Gunakan query_as::<_, Todo> bersama fetch_all untuk mendapatkan Vec<Todo>, atau fetch_one untuk satu baris.

use sqlx::{PgPool, FromRow};

#[derive(FromRow, serde::Serialize)]
struct Todo { id: i32, title: String, done: bool }

async fn all_todos(pool: &PgPool) -> Result<Vec<Todo>, sqlx::Error> {
    let rows = sqlx::query_as::<_, Todo>("SELECT id, title, done FROM todos")
        .fetch_all(pool)
        .await?;
    Ok(rows)
}

Pengendali yang Membaca Pangkalan Data

Gabungkan bahagian-bahagian tersebut: pengendali mengambil kumpulan daripada keadaan, menjalankan pertanyaan dan mengembalikan JSON. Petakan ralat pangkalan data kepada status 500 supaya klien menerima respons yang kemas dan bukannya kepanikan.

use axum::{extract::State, Json, http::StatusCode};
use sqlx::PgPool;

async fn list_todos(
    State(pool): State<PgPool>,
) -> Result<Json<Vec<Todo>>, StatusCode> {
    match all_todos(&pool).await {
        Ok(todos) => Ok(Json(todos)),
        Err(_) => Err(StatusCode::INTERNAL_SERVER_ERROR),
    }
}

Mengembalikan Baris yang Disisipkan

Postgres boleh mengembalikan baris yang baru disisipkan dengan RETURNING. Gabungkannya dengan query_as dan fetch_one untuk mendapatkan rekod baharu, termasuk id yang dijana, dalam satu perjalanan pergi balik.

use sqlx::PgPool;

async fn create(pool: &PgPool, title: &str) -> Result<Todo, sqlx::Error> {
    let todo = sqlx::query_as::<_, Todo>(
        "INSERT INTO todos (title, done) VALUES ($1, false) \
         RETURNING id, title, done")
        .bind(title)
        .fetch_one(pool)
        .await?;
    Ok(todo)
}

Migrasi

Skema anda mesti wujud sebelum pertanyaan dijalankan. sqlx menyokong migrasi: fail SQL dalam folder migrations/ yang digunakan mengikut urutan. Jalankannya semasa permulaan dengan sqlx::migrate!() supaya pangkalan data baharu disediakan secara automatik.

use sqlx::PgPool;

async fn run_migrations(pool: &PgPool) {
    sqlx::migrate!("./migrations")
        .run(pool)
        .await
        .expect("migrations failed");
}
// migrations/0001_init.sql contains the CREATE TABLE statements.

Transaksi

Apabila beberapa penulisan mesti berjaya bersama-sama, bungkus semuanya dalam transaksi. Mulakan dengan pool.begin(), jalankan pertanyaan terhadap pemegang transaksi, kemudian gunakan commit. Jika transaksi dibuang tanpa komit, sqlx akan melakukan rollback secara automatik untuk memastikan data kekal konsisten.

use sqlx::PgPool;

async fn transfer(pool: &PgPool) -> Result<(), sqlx::Error> {
    let mut tx = pool.begin().await?;
    sqlx::query("UPDATE accounts SET balance = balance - 10 WHERE id = 1")
        .execute(&mut *tx).await?;
    sqlx::query("UPDATE accounts SET balance = balance + 10 WHERE id = 2")
        .execute(&mut *tx).await?;
    tx.commit().await?;
    Ok(())
}

Konfigurasi dan Rahsia

Jangan sesekali menetapkan kelayakan pangkalan data secara terus dalam kod. Baca DATABASE_URL daripada persekitaran, yang lazimnya dimuatkan daripada fail .env menggunakan peti dotenvy semasa pembangunan. Dalam persekitaran pengeluaran, platform menyuntikkannya sebagai pemboleh ubah persekitaran.

use std::env;

async fn connect_from_env() -> sqlx::PgPool {
    let url = env::var("DATABASE_URL")
        .expect("DATABASE_URL must be set");
    make_pool(&url).await
}

Semakan Pantas

Uji pemahaman anda tentang integrasi pangkalan data.

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mengintegrasikan pangkalan data:

  • Gunakan kumpulan sambungan PgPool dan kongsikannya melalui .with_state.
  • Gunakan query/execute untuk penulisan; gunakan query_as dengan FromRow untuk pembacaan bertipe.
  • Sentiasa ikat parameter untuk mencegah suntikan SQL.
  • RETURNING mendapatkan baris yang dimasukkan; transaksi mengumpulkan penulisan secara atomik.
  • Jalankan migrasi semasa permulaan dan baca DATABASE_URL daripada persekitaran.
Percuma untuk bermula

Pelajari Rust dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
39
Pelajaran
144
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Integrasi Pangkalan Data” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Integrasi Pangkalan Data”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Integrasi Pangkalan Data”?

Kekalkan data Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Integrasi Pangkalan Data” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?

Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Persediaan Projek
  2. Titik Akhir dan Model
  3. Integrasi Pangkalan Data
  4. Menguji API
← Kembali ke Belajar Pengaturcaraan Rust