วิธีตั้งค่าและใช้งาน Diesel ORM กับ SQLite ในโครงการ Rust อย่างปลอดภัยบน macOS/ Linux

ภาพรวม — Overview

การใช้ Diesel ORM ร่วมกับ SQLite ในโครงการ Rust ทำให้คุณได้ฐานข้อมูลเบา ๆ พร้อมระบบ type‑safe ที่คอมไพล์เช็คข้อผิดพลาดทั้งหมดบน macOS หรือ Linux บทความนี้จะอธิบายวิธีตั้งค่าอย่างปลอดภัยและใช้งานขั้นพื้นฐานโดยไม่ต้องลำบาก

• Rust ให้ประสิทธิภาพระดับ system‑level
• Diesel ตรวจสอบคิวรีในช่วง compile time
• SQLite เหมาะกับแอปพลิเคชันเดสก์ท็อปหรือบริการขนาดเล็ก

**Tip: ใช้ Rust เวอร์ชันล่าสุด (stable) เพื่อรับการปรับปรุงความปลอดภัยของคอมไพเลอร์โดยอัตโนมัติ

การเตรียมสภาพแวดล้อม — Setup

ก่อนเริ่มต้องติดตั้งเครื่องมือพื้นฐานบน macOS หรือ Linux ให้เรียบร้อย

• ติดตั้ง Rust toolchain (`rustup install stable`)
• ติดตั้ง SQLite development headers
• macOS: `brew install sqlite3`
• Linux (Ubuntu/Debian): `sudo apt-get install libsqlite3-dev`
• สร้างโฟลเดอร์โปรเจกต์ใหม่ด้วย Cargo (`cargo new my_diesel_app`)

**Tip: ตรวจสอบเวอร์ชัน SQLite ด้วย `sqlite3 --version` เพื่อให้แน่ใจว่าเป็น 3.35+ (รองรับฟีเจอร์ใหม่)

เพิ่ม Diesel ลงในโครงการ — Add Diesel

การตั้งค่า Cargo.toml ให้เชื่อมต่อกับ Diesel และ SQLite อย่างปลอดภัย

• เปิดไฟล์ `Cargo.toml` แล้วเพิ่ม dependencies

```toml [dependencies] diesel = { version = "2.1", features = ["sqlite"] } dotenvy = "0.15" ```

• เพิ่ม dev‑dependency สำหรับ migration tool (`diesel_cli`)

```toml [dev-dependencies] diesel_cli = { version = "2.1", default-features = false, features = ["sqlite"] } ```

• รัน `cargo install diesel_cli --no-default-features --features sqlite` เพื่อทำให้เครื่องมือ CLI พร้อมใช้งาน

**Tip: ใช้ `--locked` เมื่อรัน `cargo build` ใน CI/CD เพื่อป้องกันการเปลี่ยนแปลงเวอร์ชันโดยไม่ได้ตั้งใจ

สร้างไฟล์ .env และกำหนดฐานข้อมูล — Configure Database

ใช้ `.env` เก็บเส้นทางของไฟล์ SQLite ทำให้โค้ดไม่ต้อง hard‑code

• สร้างไฟล์ `.env` ที่รูทโปรเจกต์

``` DATABASE_URL=sqlite://my_database.db ```

• เพิ่มการโหลด env ใน `src/main.rs`

```rust use dotenvy::dotenv; use std::env;

fn main() { dotenv().ok(); let database_url = env::var("DATABASE_URL") .expect("DATABASE_URL must be set in .env"); // เริ่มเชื่อมต่อที่นี่... } ```

• สร้างไฟล์ฐานข้อมูลเปล่าด้วย `touch my_database.db`

**Tip: อย่าให้ไฟล์ `.env` ถูกคอมมิทเข้า Git; เพิ่มลงใน `.gitignore`

กำหนด Schema ด้วย Diesel Migration — Migrations

Diesel ใช้ migration เพื่อสร้างและอัปเดต schema อย่างเป็นระบบ

• สร้างโฟลเดอร์ migration เริ่มต้น

``` diesel migration generate create_users ```

• แก้ไขไฟล์ `up.sql` ในโฟลเดอร์ใหม่

```sql CREATE TABLE users ( id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT UNIQUE NOT NULL, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); ```

• ไฟล์ `down.sql` ควรระบุการลบตารางเพื่อให้ rollback ทำงานได้

```sql DROP TABLE users; ```

• รัน migration ด้วย `diesel migration run`

**Tip: ตรวจสอบผลลัพธ์ด้วย `sqlite3 my_database.db ".schema"` เพื่อยืนยันโครงสร้าง

สร้างโมเดล Rust — Models

โมเดลใน Diesel จะเป็น struct ที่เชื่อมกับตาราง SQLite ผ่าน macro

• เปิดไฟล์ `src/schema.rs` (Diesel จะ generate ให้เมื่อรัน `diesel migration run`)

```rust diesel::table! { users (id) { id -> Integer, name -> Text, email -> Text, created_at -> Timestamp, } } ```

• สร้าง struct ในไฟล์ `src/models.rs`

```rust use super::schema::users; use diesel::{Insertable, Queryable};

#[derive(Queryable, Debug)] pub struct User { pub id: i32, pub name: String, pub email: String, pub created_at: chrono::NaiveDateTime, }

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

**Tip: ใช้ `chrono` เวอร์ชัน 0.4+ เพื่อจัดการกับ timestamp อย่างปลอดภัย

การเชื่อมต่อและทำ CRUD — CRUD Operations

ตัวอย่างฟังก์ชั่นพื้นฐานสำหรับเพิ่ม, อ่าน, แก้ไข, ลบข้อมูล

• เพิ่มผู้ใช้ใหม่

```rust use diesel::prelude::*; use crate::models::{NewUser};

fn create_user(conn: &SqliteConnection, name: &str, email: &str) -> QueryResult<usize> { let new_user = NewUser { name, email }; diesel::insert_into(crate::schema::users::table) .values(&new_user) .execute(conn) } ```

• ดึงรายชื่อผู้ใช้ทั้งหมด

```rust use crate::models::User;

fn list_users(conn: &SqliteConnection) -> QueryResult<Vec<User>> { crate::schema::users::dsl::users.load::<User>(conn) } ```

• อัปเดตอีเมลของผู้ใช้โดย id

```rust fn update_email(conn: &SqliteConnection, user_id: i32, new_email: &str) -> QueryResult<usize> { diesel::update(crate::schema::users::dsl::users.find(user_id)) .set(crate::schema::users::dsl::email.eq(new_email)) .execute(conn) } ```

• ลบผู้ใช้

```rust fn delete_user(conn: &SqliteConnection, user_id: i32) -> QueryResult<usize> { diesel::delete(crate::schema::users::dsl::users.find(user_id)).execute(conn) } ```

**Tip: ทุกการทำงานกับฐานข้อมูลต้องห่อด้วย `conn.transaction::<_, _, _>(|| { … })` หากต้องการให้หลายขั้นตอนเป็น atomic

การจัดการข้อผิดพลาดอย่างปลอดภัย — Error Handling

Diesel ส่งคืน `Result<T, diesel::result::Error>` ควรจับและแปลงเป็นข้อความที่ผู้ใช้เข้าใจได้

• ตัวอย่างฟังก์ชั่นที่แปลง error ให้เป็น `anyhow::Error`

```rust use anyhow::{Context, Result};

fn safe_create_user(conn: &SqliteConnection, name: &str, email: &str) -> Result<()> { create_user(conn, name, email) .with_context(|| format!("Failed to insert user {} <{}>", name, email))?; Ok(()) } ```

**Tip: อย่าแสดงข้อความ SQL ดิบต่อผู้ใช้ เพื่อลดความเสี่ยงจากข้อมูลรั่วไหล

การทดสอบด้วย In‑Memory SQLite — Testing

การทดสอบควรใช้ฐานข้อมูลในหน่วยความจำเพื่อให้เร็วและไม่ทำลายไฟล์จริง

• สร้าง connection สำหรับ test

```rust fn establish_test_connection() -> SqliteConnection { let conn = SqliteConnection::establish(":memory:") .expect("Failed to open in‑memory SQLite"); // รัน migration บน connection นี้ diesel_migrations::run_pending_migrations(&conn).unwrap(); conn } ```

• ตัวอย่าง unit test

```rust #[cfg(test)] mod tests { use super::*; #[test] fn test_create_and_fetch_user() { let conn = establish_test_connection(); safe_create_user(&conn, "Alice", "[email protected]").unwrap();

let users = list_users(&conn).unwrap(); assert_eq!(users.len(), 1); assert_eq!(users[0].name, "Alice"); } } ```

**Tip: ปิดการใช้งาน `debug_assertions` ใน release build เพื่อหลีกเลี่ยง overhead ของตรวจสอบเพิ่มเติม

การ Deploy บน macOS / Linux — Deployment

เมื่อแอปพร้อมทำงานแล้ว ขั้นตอนสุดท้ายคือการแพคเกจและจัดจำหน่าย

• ตรวจสอบว่าไฟล์ `my_database.db` อยู่ในตำแหน่งที่กำหนด หรือใช้ SQLite embedded file ที่รวมอยู่ใน binary ผ่าน `include_bytes!` (เหมาะกับเครื่องมือ CLI ขนาดเล็ก)
• ตั้งค่า permission ให้ executable (`chmod +x target/release/my_diesel_app`)

**Tip: หากต้องการรันเป็น service บน Linux ควรสร้าง systemd unit และกำหนด `EnvironmentFile=/path/to/.env` เพื่อให้แอปอ่านค่าตัวแปรสภาพแวดล้อมได้อย่างปลอดภัย

สรุป — Summary

• ตั้งค่า Rust, SQLite development headers, แล้วเพิ่ม Diesel ลงใน `Cargo.toml`
• ใช้ `.env` เก็บ URL ของฐานข้อมูลและโหลดด้วย `dotenvy`
• สร้าง migration ด้วย `diesel migration generate` และรันเพื่อสร้าง schema
• นิยามโมเดลด้วย `#[derive(Queryable, Insertable)]` เชื่อมกับ `schema.rs` ที่ Diesel สร้างให้
• ทำ CRUD ผ่านฟังก์ชั่นที่ห่อด้วย transaction เพื่อความ atomicity
• จัดการ error ด้วย `anyhow::Context` หรือโครงสร้าง error ของคุณเอง
• ทดสอบบน SQLite in‑memory เพื่อให้เร็วและปลอดภัย
• Build binary สำหรับ macOS / Linux แล้วจัดการ permission และ service ตามต้องการ

สิ่งที่ควรจำ

• **ความปลอดภัยของข้อมูล: อย่าเก็บค่า credentials ในโค้ด, ใช้ `.env` + `.gitignore`
• **ตรวจสอบ compile‑time: Diesel จะคอมไพล์เช็ค SQL ทั้งหมด ลดโอกาส runtime error
• **ทดสอบอย่างเต็มที่: In‑memory SQLite ทำให้คุณสามารถทำ unit test อย่างรวดเร็วโดยไม่กระทบไฟล์จริง
• **อัปเดต dependencies: ใช้ `cargo update` และตรวจสอบ CVE ของ Diesel, SQLite เป็นประจำ

ด้วยขั้นตอนเหล่านี้ คุณจะได้โครงการ Rust ที่ใช้ Diesel ORM กับ SQLite บน macOS หรือ Linux อย่างมั่นคงและปลอดภัย.