Swift Academy · Lezione

ORM Fluent e modelli

Persisti i dati con l’ORM Fluent di Vapor.

ORM Fluent e modelli è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Che cos'è Fluent?

Fluent è l'ORM di Vapor. Associa le classi Swift alle righe del database e supporta PostgreSQL, MySQL, SQLite e MongoDB tramite un'unica API. Lei scrive in Swift; Fluent scrive SQL.

import Fluent
import Vapor

Definizione di un modello

Un modello Fluent è una final class che conforma a Model e di solito anche a Content. Dichiara uno schema (il nome della tabella) e una proprietà @ID per la chiave primaria.

final class Planet: Model, Content {
    static let schema = "planets"

    @ID(key: .id)
    var id: UUID?

    init() {}
}

Il property wrapper @Field

Associare una colonna persistita con @Field. La chiave è il nome della colonna nel database. Aggiunga una proprietà per ogni colonna che desidera rendere persistente.

@Field(key: "name")
var name: String

@Field(key: "diameter_km")
var diameterKm: Int

Un modello completo

I modelli richiedono anche un inizializzatore memberwise, oltre al init() vuoto obbligatorio, per poter creare istanze nel codice.

final class Planet: Model, Content {
    static let schema = "planets"
    @ID(key: .id) var id: UUID?
    @Field(key: "name") var name: String
    init() {}
    init(id: UUID? = nil, name: String) {
        self.id = id
        self.name = name
    }
}

Migrazioni

Una migrazione crea o modifica lo schema del database. Conforma a AsyncMigration e implementa prepare (applicazione) e revert (annullamento).

struct CreatePlanet: AsyncMigration {
    func prepare(on db: Database) async throws {
        try await db.schema("planets")
            .id()
            .field("name", .string, .required)
            .create()
    }
    func revert(on db: Database) async throws {
        try await db.schema("planets").delete()
    }
}

Registrazione delle migrazioni

Aggiunga le migrazioni a app.migrations nella configurazione, quindi le esegua con app.autoMigrate() o con il comando migrate.

app.migrations.add(CreatePlanet())
try await app.autoMigrate()

Salvataggio di un record

Crei un'istanza del modello e chiami save(on:) con il database della richiesta. Fluent esegue un INSERT e compila l'id generato.

app.post("planets") { req async throws -> Planet in
    let planet = try req.content.decode(Planet.self)
    try await planet.save(on: req.db)
    return planet
}

Esecuzione di query sui record

Utilizzi Model.query(on:) per creare query in modo fluente. .all() restituisce tutte le righe; concateni filtri e ordinamenti secondo necessità.

app.get("planets") { req async throws -> [Planet] in
    try await Planet.query(on: req.db).all()
}

Filtraggio e ricerca per ID

find(_:on:) recupera un record tramite la chiave primaria e restituisce un valore facoltativo. filter restringe i risultati in base ai valori delle colonne.

let earth = try await Planet.query(on: req.db)
    .filter(\.$name == "Earth")
    .first()

let byId = try await Planet.find(someUUID, on: req.db)

Aggiornamento ed eliminazione

Modifichi le proprietà di un modello recuperato e chiami update(on:), oppure lo rimuova con delete(on:). Entrambe le operazioni vengono eseguite in modo asincrono sul database.

if let planet = try await Planet.find(id, on: req.db) {
    planet.name = "Renamed"
    try await planet.update(on: req.db)
    // or: try await planet.delete(on: req.db)
}

Relazioni

Fluent modella le relazioni con property wrapper: @Parent e @Child per relazioni uno-a-uno e uno-a-molti, e @Siblings per relazioni molti-a-molti. Questi definiscono chiavi esterne e consentono il caricamento eager con .with(...).

@Parent(key: "star_id")
var star: Star

// query eagerly loading the parent
Planet.query(on: req.db).with(\.$star).all()

Verifica rapida: Fluent

Verifichi la Sua comprensione dell'ORM.

Riepilogo: ORM Fluent e modelli

Ora è in grado di rendere persistenti i dati con Fluent:

Definisca una final class Model con i property wrapper @ID e @Field e uno schema.
Crei le tabelle tramite AsyncMigration ed esegua le migrazioni con autoMigrate().
Esegua operazioni CRUD con save, query(on:), find, update e delete.
Modelli le relazioni con @Parent, @Child e @Siblings, usando il caricamento eager tramite .with.

Domande Frequenti

La lezione «ORM Fluent e modelli» è gratuita?

Sì — il testo completo di «ORM Fluent e modelli» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «ORM Fluent e modelli»?

Persisti i dati con l’ORM Fluent di Vapor. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «ORM Fluent e modelli»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Swift Academy