Swift Academy · Aula

ORM Fluent e Modelos

Persista dados com o ORM Fluent do Vapor.

ORM Fluent e Modelos é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

O que é Fluent?

Fluent é o ORM do Vapor. Ele mapeia classes Swift para linhas do banco de dados, oferecendo suporte a PostgreSQL, MySQL, SQLite e MongoDB por meio de uma única API. Você escreve Swift; o Fluent escreve SQL.

import Fluent
import Vapor

Definindo um modelo

Um modelo do Fluent é uma final class em conformidade com Model e geralmente com Content. Ele declara um schema (nome da tabela) e uma propriedade @ID para a chave primária.

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

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

    init() {}
}

O wrapper de propriedade @Field

Mapeie uma coluna armazenada com @Field. A chave é o nome da coluna no banco de dados. Adicione uma propriedade para cada coluna que deseja persistir.

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

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

Um modelo completo

Os modelos também precisam de um inicializador membro a membro (além do init() vazio obrigatório) para que você possa criar instâncias no código.

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
    }
}

Migrações

Uma migração cria ou altera o esquema do banco de dados. Ela está em conformidade com AsyncMigration e implementa prepare (aplicar) e revert (desfazer).

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()
    }
}

Registrando migrações

Adicione as migrações a app.migrations na configuração e execute-as com app.autoMigrate() ou com o comando migrate.

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

Salvando um registro

Crie uma instância do modelo e chame save(on:) com o banco de dados da requisição. O Fluent executa um INSERT e preenche o identificador gerado.

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
}

Consultando registros

Use Model.query(on:) para criar consultas de forma encadeada. .all() retorna todas as linhas; encadeie filtros e ordenações conforme necessário.

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

Filtrando e encontrando por identificador

find(_:on:) busca pela chave primária e retorna um valor opcional. filter restringe os resultados com base nos valores das colunas.

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

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

Atualizando e excluindo

Altere as propriedades de um modelo obtido e chame update(on:) ou remova-o com delete(on:). Ambas as operações são executadas de forma assíncrona no banco de dados.

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)
}

Relacionamentos

O Fluent modela relacionamentos com wrappers de propriedade: @Parent e @Child para relações um para um ou um para muitos, e @Siblings para relações muitos para muitos. Eles definem chaves estrangeiras e permitem o carregamento antecipado com .with(...).

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

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

Verificação rápida: Fluent

Teste seus conhecimentos sobre ORM.

Recapitulação: ORM e modelos do Fluent

Agora você já pode persistir dados com o Fluent:

Defina uma final class Model com wrappers de propriedade @ID e @Field e um schema.
Crie tabelas por meio de AsyncMigration e execute-as com autoMigrate().
Faça operações CRUD com save, query(on:), find, update e delete.
Modele relacionamentos com @Parent, @Child e @Siblings, usando carregamento antecipado por meio de .with.

Perguntas Frequentes

A aula “ORM Fluent e Modelos” é grátis?

Sim — o texto completo de “ORM Fluent e Modelos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “ORM Fluent e Modelos”?

Persista dados com o ORM Fluent do Vapor. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “ORM Fluent e Modelos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy