# SwiftData Deep Dive: Core Data'dan Geçiş Rehberi Core Data on yıllardır iOS ekosisteminin omurgası. Ama artık 2026'dayız ve Apple, WWDC23'te SwiftData'yı tanıttığından beri framework olgunlaştı. Peki gerçekten geçiş yapmalı mısın? Bu yazıda SwiftData'nın derinliklerine dalacağız: model tanımlama, ilişkiler, sorgular, migration stratejileri ve production'da ne beklemeniz gerektiği. ## SwiftData Nedir? SwiftData, Core Data'nın Swift-native hali. Xcode'un model editörüne veda ediyorsun. Artık her şey kod. `@Model` macro'su ile class'larını doğrudan persistence modeline dönüştürüyorsun. ```swift import SwiftData @Model class User { var name: String var email: String var createdAt: Date init(name: String, email: String) { self.name = name self.email = email self.createdAt = Date() } } ``` Bu kadar. `.xcdatamodeld` dosyası yok. Entity tanımı yok. Attribute'ları elle eşleştirmek yok. ## Core Data vs SwiftData: Mapping Tablosu Geçiş yaparken kafan karışmasın diye eşleştirme tablosu: | Core Data | SwiftData | |-----------|-----------| | `NSPersistentContainer` | `ModelContainer` | | `NSManagedObjectContext` | `ModelContext` | | `NSManagedObject` | `@Model` macro + `PersistentModel` protocol | | `NSPredicate` | `#Predicate` macro | | `NSFetchRequest` | `FetchDescriptor` | | `NSSortDescriptor` | `SortDescriptor` | | `NSEntityMigrationPolicy` | `SchemaMigrationPlan` | En büyük fark: Xcode'un model editörü artık yok. Tamamen kod-bazlı. ## Model Tanımlama: @Attribute ve Özellikler ### Unique Constraint ```swift @Model class User { @Attribute(.unique) var email: String var name: String init(email: String, name: String) { self.email = email self.name = name } } ``` ### Transient Property (Persist Edilmez) ```swift @Model class Article { var title: String var content: String @Transient var wordCount: Int { content.split(separator: " ").count } } ``` ### External Storage (Büyük Data için) ```swift @Model class Photo { var name: String @Attribute(.externalStorage) var imageData: Data } ``` ## Relationships: İlişki Tanımlama SwiftData ilişkileri otomatik çıkarım yapabiliyor. Ama cascade delete gibi davranışlar için explicit tanımlaman gerekiyor. ### One-to-Many İlişki ```swift @Model class Author { var name: String @Relationship(deleteRule: .cascade) var books: [Book] = [] init(name: String) { self.name = name } } @Model class Book { var title: String var author: Author? init(title: String, author: Author? = nil) { self.title = title self.author = author } } ``` `deleteRule: .cascade` diyorsun ki: "Author silindiğinde tüm kitapları da sil." Diğer delete rule'lar: - `.nullify`: İlişkiyi nil yap (default) - `.deny`: İlişkili objeler varsa silmeyi engelle - `.cascade`: Hepsini sil ### Lazy Loading SwiftData relationship'leri lazy load ediyor. `author.books`'a erişene kadar kitaplar yüklenmiyor. Bu performans için iyi haber. ## Sorgular: @Query ve #Predicate SwiftUI ile entegrasyon mükemmel. `@Query` property wrapper'ı ile reactive data çekiyorsun. ### Basit Query ```swift struct BookListView: View { @Query var books: [Book] var body: some View { List(books) { book in Text(book.title) } } } ``` ### Filtreleme ve Sıralama ```swift struct RecentBooksView: View { @Query( filter: #Predicate { book in book.publishedAt > Date.now.addingTimeInterval(-86400 * 30) }, sort: \.publishedAt, order: .reverse ) var recentBooks: [Book] } ``` ### #Predicate Dikkat Edilecekler `#Predicate` macro'su compile-time type safety sağlıyor. Ama bazı tuzaklar var: ```swift // ✅ Çalışır #Predicate { movie in movie.cast.isEmpty } // ❌ Runtime crash! #Predicate { movie in movie.cast.isEmpty == false } // ✅ Çalışır (! kullan) #Predicate { movie in !movie.cast.isEmpty } ``` Case-insensitive arama için: ```swift #Predicate { book in book.title.localizedStandardContains("swift") } ``` `uppercased()` veya `lowercased()` desteklenmiyor. `localizedStandardContains` kullan. ## Migration: VersionedSchema ile Versiyon Yönetimi Simple değişiklikler (yeni property eklemek) otomatik. Ama complex migration için `VersionedSchema` kullanman gerekiyor. ### Adım 1: Schema Versiyonlarını Tanımla ```swift enum UsersSchemaV1: VersionedSchema { static var versionIdentifier = Schema.Version(1, 0, 0) static var models: [any PersistentModel.Type] { [User.self] } @Model class User { var name: String var age: Int init(name: String, age: Int) { self.name = name self.age = age } } } enum UsersSchemaV2: VersionedSchema { static var versionIdentifier = Schema.Version(2, 0, 0) static var models: [any PersistentModel.Type] { [User.self] } @Model class User { @Attribute(.unique) var name: String // Yeni: unique constraint var age: Int init(name: String, age: Int) { self.name = name self.age = age } } } // Type alias ile her zaman son versiyonu kullan typealias User = UsersSchemaV2.User ``` ### Adım 2: Migration Plan ```swift enum UsersMigrationPlan: SchemaMigrationPlan { static var schemas: [any VersionedSchema.Type] { [UsersSchemaV1.self, UsersSchemaV2.self] } static let migrateV1toV2 = MigrationStage.custom( fromVersion: UsersSchemaV1.self, toVersion: UsersSchemaV2.self, willMigrate: { context in // Duplicate name'leri temizle let users = try context.fetch( FetchDescriptor() ) var seenNames = Set() for user in users { if seenNames.contains(user.name) { context.delete(user) } seenNames.insert(user.name) } try context.save() }, didMigrate: nil ) static var stages: [MigrationStage] { [migrateV1toV2] } } ``` ### Adım 3: Container'ı Configure Et ```swift @main struct MyApp: App { let container: ModelContainer init() { do { container = try ModelContainer( for: User.self, migrationPlan: UsersMigrationPlan.self ) } catch { fatalError("Failed to initialize model container: \(error)") } } var body: some Scene { WindowGroup { ContentView() } .modelContainer(container) } } ``` ## Core Data'dan SwiftData'ya Geçiş Stratejisi ### Gradual Migration (Önerilen) Her ikisini aynı anda kullanabilirsin. Aynı SQLite store'u paylaşıyorlar. 1. SwiftData modellerini oluştur (class isimleri aynı olmalı) 2. Yeni view'lerde SwiftData kullan 3. Eski view'leri adım adım migrate et 4. Her şey geçince Core Data kodunu temizle ```swift // Core Data ve SwiftData aynı store'u kullanabilir let container = try ModelContainer( for: User.self, configurations: ModelConfiguration( url: existingCoreDataStoreURL ) ) ``` ### Model Naming Core Data entity isimlerini SwiftData class isimleriyle eşleştir. Entity adı `User` ise, SwiftData class'ı da `User` olmalı. ## Production'da SwiftData: Gerçek Deneyimler ### Ne Zaman SwiftData Kullanmalı? **✅ SwiftData için uygun:** - Yeni projeler (iOS 17+) - Basit/orta karmaşıklıkta veri modelleri - SwiftUI-first uygulamalar - CloudKit senkronizasyonu istiyorsan **❌ Core Data'da kal:** - iOS 17 öncesi destek gerekiyorsa - Complex batch operations - Fine-grained context kontrolü - Spotlight indexing (SwiftData'da hala sorunlu) - NSCompoundPredicate benzeri karmaşık sorgular ### Bilinen Sorunlar ve Workaround'lar **1. @Query Performans Sorunları** Bazı geliştiriciler @Query ile performans sorunları yaşıyor. Alternatif olarak manuel FetchDescriptor kullanabilirsin: ```swift class BooksViewModel: ObservableObject { @Published var books: [Book] = [] func fetchBooks(context: ModelContext) { let descriptor = FetchDescriptor( sortBy: [SortDescriptor(\.title)] ) do { books = try context.fetch(descriptor) } catch { print("Fetch failed: \(error)") } } } ``` **2. Relationship Insert Sırası** Relationship'li objeleri insert ederken sıraya dikkat et. Önce parent'ı insert et, sonra child'ları: ```swift // ✅ Doğru yol let author = Author(name: "Stephen King") context.insert(author) let book = Book(title: "It", author: author) context.insert(book) ``` **3. Concurrent Operations** `@ModelActor` macro'sunu kullan: ```swift @ModelActor actor DataHandler { func importBooks(_ data: [BookDTO]) throws { for dto in data { let book = Book(title: dto.title) modelContext.insert(book) } try modelContext.save() } } ``` ### Performans İpuçları 1. **Batch Size Kullan:** Büyük listeler için `fetchLimit` set et 2. **Lazy Loading'i Anla:** Relationship'ler lazy. Explicit prefetch için özel bir API yok 3. **Background Context:** Ağır işler için `@ModelActor` kullan 4. **Undo/Redo:** `isUndoEnabled: true` ile aktive et ## Nasıl Test Ederim? ### In-Memory Store ile Unit Test ```swift import Testing import SwiftData @Test func testUserCreation() throws { // In-memory container let config = ModelConfiguration(isStoredInMemoryOnly: true) let container = try ModelContainer( for: User.self, configurations: config ) let context = container.mainContext // Test let user = User(name: "Test User", email: "test@example.com") context.insert(user) try context.save() // Verify let users = try context.fetch(FetchDescriptor()) #expect(users.count == 1) #expect(users.first?.name == "Test User") } ``` ### Migration Test ```swift @Test func testV1toV2Migration() throws { // V1 store hazırla (test fixture) let v1StoreURL = Bundle.module.url( forResource: "TestStore_v1", withExtension: "sqlite" )! // V2 container'ı migration plan ile aç let container = try ModelContainer( for: User.self, migrationPlan: UsersMigrationPlan.self, configurations: ModelConfiguration(url: v1StoreURL) ) // Verify migration succeeded let users = try container.mainContext.fetch( FetchDescriptor() ) // Check unique constraint is enforced let names = users.map(\.name) #expect(Set(names).count == names.count) // No duplicates } ``` ### Preview Provider ```swift #Preview { let config = ModelConfiguration(isStoredInMemoryOnly: true) let container = try! ModelContainer( for: Book.self, configurations: config ) // Sample data let context = container.mainContext context.insert(Book(title: "Sample Book")) return BookListView() .modelContainer(container) } ``` ## Sonuç SwiftData 2026'da production-ready mı? Evet, ama koşullu. iOS 17+ hedefliyorsan, SwiftUI-first bir uygulama yapıyorsan ve veri modelin çok karmaşık değilse: SwiftData güzel bir seçim. Syntax temiz, SwiftUI entegrasyonu mükemmel, type-safe predicate'ler hayat kurtarıyor. Ama karmaşık batch operations, fine-grained context kontrolü veya iOS 17 öncesi destek gerekiyorsa: Core Data hala senin dostun. İkisini aynı anda kullanabildiğini de unutma. Tavsiyem: Yeni view'lerde SwiftData'yı dene. Gradual migration yap. Sorun yaşarsan geri dönmek kolay.