Learn Rust Coding · Lekcja

Łączenie z bazą danych

Pule sqlx

Łączenie z bazą danych to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Czym jest sqlx?

sqlx to asynchroniczny zestaw narzędzi SQL napisany w czystym Rust. Nie jest to ORM — piszesz prawdziwy SQL, ale otrzymujesz sprawdzanie podczas kompilacji i bezpieczne typowo wyniki.

Obsługuje Postgres, MySQL i SQLite
Działa na asynchronicznych środowiskach wykonawczych, takich jak Tokio

Dodawanie sqlx

Należy zadeklarować sqlx wraz ze środowiskiem wykonawczym i funkcjami obsługi bazy danych, których potrzebujesz. Ta czynność modyfikuje Cargo.toml i uruchamia polecenie w terminalu.

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

Łańcuchy połączeń

Łańcuch połączenia (DSN) informuje sqlx, jak dotrzeć do bazy danych.

Postgres: postgres://user:pass@host:5432/dbname
SQLite: sqlite://app.db

Dlaczego pula połączeń?

Otwieranie połączenia dla każdego zapytania jest powolne. Pula przechowuje zestaw połączeń wielokrotnego użytku, udostępnia je w razie potrzeby, a następnie zwraca do puli.

Ogranicza współbieżność
Rozkłada koszt nawiązywania połączeń

Tworzenie puli

Użyj PgPoolOptions, aby skonfigurować i połączyć pulę. Zwykle wykonuje się to raz podczas uruchamiania aplikacji.

use sqlx::postgres::PgPoolOptions;

async fn connect() -> sqlx::Pool<sqlx::Postgres> {
    PgPoolOptions::new()
        .max_connections(5)
        .connect("postgres://user:pass@localhost/app")
        .await
        .unwrap()
}

Konfigurowanie puli

Dostosuj pulę za pomocą opcji takich jak maksymalna liczba połączeń i limit czasu uzyskania połączenia, aby odpowiadała obciążeniu.

use sqlx::postgres::PgPoolOptions;
use std::time::Duration;

fn options() -> PgPoolOptions {
    PgPoolOptions::new()
        .max_connections(10)
        .acquire_timeout(Duration::from_secs(3))
}

Proste zapytanie za pośrednictwem puli

Przekaż pulę lub odwołanie do niej jako executor, aby wykonać zapytanie. Pula automatycznie pobierze połączenie.

use sqlx::Pool;
use sqlx::Postgres;

async fn ping(pool: &Pool<Postgres>) -> i32 {
    let row: (i32,) = sqlx::query_as("SELECT 1")
        .fetch_one(pool)
        .await
        .unwrap();
    row.0
}

Modelowanie puli w czystym Rust

Pula jest koncepcyjnie ograniczonym zbiorem zasobów wielokrotnego użytku. Ten uruchamialny przykład pokazuje pobieranie i zwracanie zasobów.

struct Pool { available: u32, max: u32 }

impl Pool {
    fn acquire(&mut self) -> bool {
        if self.available > 0 { self.available -= 1; true } else { false }
    }
    fn release(&mut self) { self.available += 1; }
}

fn main() {
    let mut p = Pool { available: 2, max: 2 };
    println!("{}", p.acquire());
    println!("{}", p.acquire());
    println!("{}", p.acquire());
    p.release();
    println!("{}", p.acquire());
}

Odczytywanie DSN ze zmiennych środowiskowych

Nie przechowuj sekretów w kodzie źródłowym. Odczytaj DATABASE_URL ze środowiska podczas uruchamiania.

use sqlx::postgres::PgPoolOptions;

async fn connect() -> sqlx::Pool<sqlx::Postgres> {
    let url = std::env::var("DATABASE_URL").unwrap();
    PgPoolOptions::new().connect(&url).await.unwrap()
}

Klonowanie jest tanie

Pool jest wewnętrznie zarządzany za pomocą zliczania odwołań. Klonowanie udostępnia te same połączenia bazowe, więc możesz swobodnie przekazywać klony do zadań.

use sqlx::{Pool, Postgres};

async fn spawn_work(pool: Pool<Postgres>) {
    let p2 = pool.clone();
    tokio::spawn(async move {
        let _ = sqlx::query("SELECT 1").execute(&p2).await;
    });
}

Zamykanie puli

Podczas zamykania aplikacji wywołaj close().await, aby łagodnie opróżnić pulę i zamknąć wszystkie połączenia.

use sqlx::{Pool, Postgres};

async fn shutdown(pool: Pool<Postgres>) {
    pool.close().await;
}

Szybki test

Sprawdź swoją wiedzę na temat nawiązywania połączeń za pomocą sqlx.

Podsumowanie

Nauczyłeś się nawiązywać połączenia za pomocą sqlx:

sqlx to asynchroniczny, bezpieczny typowo zestaw narzędzi SQL, a nie ORM
DSN opisuje lokalizację bazy danych
Użyj PgPoolOptions, aby utworzyć pulę z limitami i limitami czasu
Pule można tanio klonować i należy je zamykać podczas wyłączania aplikacji

Następnie: zapytania sprawdzane podczas kompilacji.

Często zadawane pytania

Czy lekcja „Łączenie z bazą danych” jest bezpłatna?

Tak — pełny tekst „Łączenie z bazą danych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „Łączenie z bazą danych”?

Pule sqlx Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Łączenie z bazą danych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding