Relacionamentos e Fetch Descriptors
Modele relacionamentos um-para-muitos e faça consultas com FetchDescriptor.
Relacionamentos e Fetch Descriptors é 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.
Relacionamentos no SwiftData
Declare relacionamentos entre classes @Model usando propriedades do Swift. O SwiftData infere o tipo de relacionamento.
@Model
class Author {
var name: String
@Relationship(deleteRule: .cascade) var books: [Book] = []
init(name: String) { self.name = name }
}Atributo @Relationship
Use @Relationship para especificar explicitamente regras de exclusão e relacionamentos inversos.
@Model
class Book {
var title: String
var author: Author?
init(title: String) { self.title = title }
}Regras de exclusão
As regras de exclusão controlam o que acontece com os objetos relacionados quando o objeto pai é excluído: .nullify, .cascade, .deny.
// .cascade: deleting Author deletes all Books
// .nullify: deleting Author sets book.author to nil
// .deny: prevents deletion if related objects exist
@Relationship(deleteRule: .cascade) var books: [Book] = []Relacionamento um para muitos
Um relacionamento um para muitos é declarado como uma propriedade de matriz no lado que representa o elemento único.
@Model class Department {
var name: String
@Relationship(deleteRule: .cascade) var employees: [Employee] = []
init(name: String) { self.name = name }
}
@Model class Employee {
var name: String
var department: Department?
init(name: String) { self.name = name }
}Relacionamentos muitos para muitos
Declare matrizes nos dois lados para criar um relacionamento muitos para muitos.
@Model class Student {
var name: String
var courses: [Course] = []
init(name: String) { self.name = name }
}
@Model class Course {
var title: String
var students: [Student] = []
init(title: String) { self.title = title }
}FetchDescriptor
FetchDescriptor substitui NSFetchRequest no SwiftData. Configure-o com predicado, ordenação e limite de busca.
var descriptor = FetchDescriptor<Book>(
predicate: #Predicate { $0.title.contains("Swift") },
sortBy: [SortDescriptor(\Book.title)]
)
descriptor.fetchLimit = 10
let books = try context.fetch(descriptor)Ordenando com SortDescriptor
Passe uma matriz de SortDescriptor para FetchDescriptor para fazer uma ordenação por várias colunas.
let descriptor = FetchDescriptor<Item>(
sortBy: [
SortDescriptor(\Item.priority, order: .reverse),
SortDescriptor(\Item.name)
]
)Contando sem buscar
Use context.fetchCount para contar os registros correspondentes sem carregar todos os objetos na memória.
let descriptor = FetchDescriptor<Book>(
predicate: #Predicate { $0.rating > 4 }
)
let count = try context.fetchCount(descriptor)
print("High-rated books: \(count)")Pré-carregando relacionamentos
Defina relationshipKeyPathsForPrefetching em um FetchDescriptor para carregar antecipadamente os objetos relacionados.
var descriptor = FetchDescriptor<Author>()
descriptor.relationshipKeyPathsForPrefetching = [\Author.books]
let authors = try context.fetch(descriptor)@Query com opções semelhantes às de FetchDescriptor
A macro @Query oferece as mesmas opções de ordenação e predicado que FetchDescriptor.
@Query(
filter: #Predicate<Book> { $0.author?.name == "Apple" },
sort: \Book.title
)
var books: [Book]Operações em lote
O SwiftData oferece exclusões em lote por meio de context.delete(model:where:) para operações em massa eficientes.
try context.delete(model: Book.self, where: #Predicate { $0.rating < 2 })Verificação rápida
Qual tipo do SwiftData substitui NSFetchRequest para buscar objetos @Model com filtros e ordenação?
Recapitulação da lição
Declare relacionamentos com @Relationship(deleteRule:) nas classes @Model. Use FetchDescriptor com #Predicate e SortDescriptor para consultar dados. Use fetchCount para fazer contagens e a exclusão em lote para remoções em massa.
Aprenda Swift com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 122
- Aulas
- 409
Perguntas Frequentes
A aula “Relacionamentos e Fetch Descriptors” é grátis?
Sim — o texto completo de “Relacionamentos e Fetch Descriptors” é 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 “Relacionamentos e Fetch Descriptors”?
Modele relacionamentos um-para-muitos e faça consultas com FetchDescriptor. 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 “Relacionamentos e Fetch Descriptors”?
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
- Pilha do Core Data: configuração de NSPersistentContainer
- SwiftData @Model e ModelContext
- Relacionamentos e Fetch Descriptors
- Migrações leves e sincronização com CloudKit