SwiftData vs Core Data 2026: Performans Benchmark ve Production Testler

1import SwiftData
2import Foundation
3 
4// SwiftData model — @Model macro
5@Model
6final class BlogPost {
7    var title: String
8    var slug: String
9    var publishedAt: Date
10    var viewCount: Int
11 
12    @Attribute(.unique) var id: UUID
13 
14    // İlişki tanımı
15    @Relationship(deleteRule: .cascade)
16    var comments: [Comment] = []
17 
18    // Indexleme
19    @Attribute(.indexed) var category: String
20 
21    // Geçici — persist edilmez
22    @Transient var isHighlighted: Bool = false
23 
24    init(title: String, slug: String, category: String) {
25        self.id = UUID()
26        self.title = title
27        self.slug = slug
28        self.category = category
29        self.publishedAt = Date()
30        self.viewCount = 0
31    }
32}
33 
34@Model
35final class Comment {
36    var text: String
37    var createdAt: Date
38    var authorName: String
39 
40    @Attribute(.unique) var id: UUID
41 
42    // Inverse ilişki
43    var post: BlogPost?
44 
45    init(text: String, authorName: String) {
46        self.id = UUID()
47        self.text = text
48        self.authorName = authorName
49        self.createdAt = Date()
50    }
51}

1// Core Data eşdeğeri (kısaltılmış)
2class BlogPostEntity: NSManagedObject {
3    @NSManaged var title: String
4    @NSManaged var slug: String
5    @NSManaged var publishedAt: Date
6    @NSManaged var viewCount: Int64
7    @NSManaged var id: UUID
8    @NSManaged var category: String
9    @NSManaged var comments: NSSet
10 
11    // Ayrıca: xcdatamodeld dosyası, entity tanımı,
12    // relationship tanımı, fetch request static fonksiyonlar...
13}

1// ModelContainer kurulumu
2@main
3struct BlogApp: App {
4    let container: ModelContainer
5 
6    init() {
7        do {
8            let schema = Schema([BlogPost.self, Comment.self])
9            let config = ModelConfiguration(
10                schema: schema,
11                isStoredInMemoryOnly: false,
12                cloudKitDatabase: .automatic
13            )
14            container = try ModelContainer(for: schema, configurations: [config])
15        } catch {
16            fatalError("ModelContainer kurulamadı: (error)")
17        }
18    }
19 
20    var body: some Scene {
21        WindowGroup {
22            ContentView()
23        }
24        .modelContainer(container)
25    }
26}
27 
28// ModelActor — Swift 6 concurrency ile background işlemler
29@ModelActor
30actor BlogDataActor {
31    // Background thread'de güvenli SwiftData erişimi
32 
33    func importPosts(from json: [PostJSON]) async throws {
34        for postData in json {
35            let post = BlogPost(
36                title: postData.title,
37                slug: postData.slug,
38                category: postData.category
39            )
40            modelContext.insert(post)
41        }
42        try modelContext.save()
43    }
44 
45    func fetchPostsByCategory(_ category: String) throws -> [BlogPost] {
46        let descriptor = FetchDescriptor<BlogPost>(
47            predicate: #Predicate { $0.category == category },
48            sortBy: [SortDescriptor(.publishedAt, order: .reverse)]
49        )
50        return try modelContext.fetch(descriptor)
51    }
52}

1// SwiftData @Query — SwiftUI ile sıfır boilerplate
2struct BlogListView: View {
3    @Query(
4        filter: #Predicate<BlogPost> { $0.viewCount > 100 },
5        sort: .publishedAt,
6        order: .reverse
7    )
8    private var popularPosts: [BlogPost]
9 
10    // iOS 26 yeni: pagination
11    @Query(
12        filter: #Predicate<BlogPost> { $0.category == "iOS" },
13        sort: .publishedAt,
14        fetchLimit: 20,
15        fetchOffset: 0
16    )
17    private var iosPosts: [BlogPost]
18 
19    var body: some View {
20        List(popularPosts) { post in
21            PostRowView(post: post)
22        }
23    }
24}
25 
26// Dinamik predicate — iOS 18 ile geldi
27struct FilteredBlogList: View {
28    let selectedCategory: String
29 
30    var body: some View {
31        FilteredListContent(category: selectedCategory)
32    }
33}
34 
35struct FilteredListContent: View {
36    let category: String
37 
38    @Query private var posts: [BlogPost]
39 
40    init(category: String) {
41        _posts = Query(
42            filter: #Predicate<BlogPost> { $0.category == category },
43            sort: .publishedAt,
44            order: .reverse
45        )
46    }
47 
48    var body: some View {
49        List(posts) { post in
50            PostRowView(post: post)
51        }
52    }
53}

1// Core Data FetchRequest eşdeğeri
2struct CoreDataBlogList: View {
3    @FetchRequest(
4        sortDescriptors: [SortDescriptor(.publishedAt, order: .reverse)],
5        predicate: NSPredicate(format: "viewCount > %d", 100)
6    )
7    private var popularPosts: FetchedResults<BlogPostEntity>
8 
9    var body: some View {
10        List(popularPosts) { post in
11            CoreDataPostRow(post: post)
12        }
13    }
14}
15 
16// Dinamik predicate — NSPredicate string tabanlı
17struct DynamicCoreDataList: View {
18    let category: String
19 
20    @FetchRequest private var posts: FetchedResults<BlogPostEntity>
21 
22    init(category: String) {
23        self.category = category
24        _posts = FetchRequest(
25            sortDescriptors: [NSSortDescriptor(key: "publishedAt", ascending: false)],
26            predicate: NSPredicate(format: "category == %@", category)
27        )
28    }
29 
30    var body: some View {
31        List(posts) { post in
32            CoreDataPostRow(post: post)
33        }
34    }
35}

1// SwiftData — #Predicate macro (Swift native, compile-time check)
2let swiftDataPredicate = #Predicate<BlogPost> {
3    $0.category == "iOS" &&
4    $0.viewCount > 500 &&
5    $0.publishedAt > Calendar.current.date(byAdding: .month, value: -3, to: Date())!
6}
7 
8// Core Data — NSPredicate (runtime string, no compile-time check)
9let coreDataPredicate = NSPredicate(
10    format: "category == %@ AND viewCount > %d AND publishedAt > %@",
11    "iOS",
12    500,
13    Calendar.current.date(byAdding: .month, value: -3, to: Date())! as NSDate
14)
15 
16// Karmaşık predicate — SwiftData sınırları
17// SwiftData #Predicate bazı SQL fonksiyonlarını desteklemiyor:
18// BEGINSWITH, CONTAINS, ENDSWITH, IN — hepsi destekli
19// SUBQUERY, FUNCTION, AGGREGATE — desteklenmiyor
20 
21// Aggregate için Core Data zorunlu
22let aggregatePredicate = NSPredicate(
23    format: "comments.@count > %d", 10
24)
25// SwiftData'da eşdeğer yok — workaround gerekiyor

1// SwiftData — batch insert yok, kayıt kayıt insert
2func swiftDataBatchInsert(count: Int) async throws {
3    let actor = BlogDataActor(modelContainer: container)
4    try await actor.importPosts(from: generateTestData(count: count))
5    // 100K kayıt için: ~8 saniye
6}
7 
8// Core Data — NSBatchInsertRequest ile
9func coreDataBatchInsert(count: Int) throws {
10    let context = container.newBackgroundContext()
11    try context.performAndWait {
12        var objects: [[String: Any]] = []
13        for i in 0..<count {
14            objects.append([
15                "id": UUID(),
16                "title": "Post (i)",
17                "slug": "post-(i)",
18                "category": "iOS",
19                "publishedAt": Date(),
20                "viewCount": 0
21            ])
22        }
23 
24        let insertRequest = NSBatchInsertRequest(
25            entityName: "BlogPostEntity",
26            objects: objects
27        )
28        insertRequest.resultType = .statusOnly
29 
30        let result = try context.execute(insertRequest) as? NSBatchInsertResult
31        guard result?.result as? Bool == true else {
32            throw PersistenceError.batchInsertFailed
33        }
34    }
35    // 100K kayıt için: ~6 saniye
36}

1// Core Data lazy faulting — ilişkiler erişilene kadar yüklenmez
2let posts = try context.fetch(BlogPostEntity.fetchRequest())
3// comments ilişkisi henüz yüklü değil (fault)
4// posts[0].comments ile erişilince yükleniyor
5 
6// SwiftData da lazy yükleme yapıyor ama daha az belirgin
7let descriptor = FetchDescriptor<BlogPost>()
8let posts = try context.fetch(descriptor)
9// comments — lazy yüklü
10// Ancak fetch overhead Core Data'dan biraz yüksek
11 
12// Bellek optimizasyonu — her iki framework
13// Core Data: fetchBatchSize
14fetchRequest.fetchBatchSize = 50
15 
16// SwiftData: FetchDescriptor limit + offset
17var descriptor = FetchDescriptor<BlogPost>()
18descriptor.fetchLimit = 50
19descriptor.fetchOffset = page * 50

1// Lightweight migration — otomatik (schema versioning)
2enum BlogPostSchemaV1: VersionedSchema {
3    static var versionIdentifier = Schema.Version(1, 0, 0)
4    static var models: [any PersistentModel.Type] { [BlogPost.self] }
5 
6    @Model
7    final class BlogPost {
8        var title: String
9        var slug: String
10        // V1 schema
11        init(title: String, slug: String) {
12            self.title = title
13            self.slug = slug
14        }
15    }
16}
17 
18enum BlogPostSchemaV2: VersionedSchema {
19    static var versionIdentifier = Schema.Version(2, 0, 0)
20    static var models: [any PersistentModel.Type] { [BlogPost.self] }
21 
22    @Model
23    final class BlogPost {
24        var title: String
25        var slug: String
26        var viewCount: Int // Yeni alan — default değer ile lightweight
27        init(title: String, slug: String) {
28            self.title = title
29            self.slug = slug
30            self.viewCount = 0
31        }
32    }
33}
34 
35// Migration plan
36enum BlogPostMigrationPlan: SchemaMigrationPlan {
37    static var schemas: [any VersionedSchema.Type] {
38        [BlogPostSchemaV1.self, BlogPostSchemaV2.self]
39    }
40 
41    static var stages: [MigrationStage] {
42        [migrateV1toV2]
43    }
44 
45    // Lightweight: sadece schema belirt
46    static let migrateV1toV2 = MigrationStage.lightweight(
47        fromVersion: BlogPostSchemaV1.self,
48        toVersion: BlogPostSchemaV2.self
49    )
50}
51 
52// Custom migration gerekiyorsa
53static let migrateV1toV2 = MigrationStage.custom(
54    fromVersion: BlogPostSchemaV1.self,
55    toVersion: BlogPostSchemaV2.self,
56    willMigrate: { context in
57        // Migration öncesi işlem
58    },
59    didMigrate: { context in
60        // Migration sonrası: viewCount değerlerini hesapla
61        let posts = try context.fetch(FetchDescriptor<BlogPostSchemaV2.BlogPost>())
62        for post in posts {
63            post.viewCount = fetchViewCountFromAnalytics(slug: post.slug)
64        }
65        try context.save()
66    }
67)

1// Core Data lightweight migration — mapping model ile
2let options: [String: Any] = [
3    NSMigratePersistentStoresAutomaticallyOption: true,
4    NSInferMappingModelAutomaticallyOption: true
5]
6 
7let container = NSPersistentContainer(name: "BlogModel")
8container.persistentStoreDescriptions.first?.setOption(
9    true as NSNumber,
10    forKey: NSMigratePersistentStoresAutomaticallyOption
11)
12container.persistentStoreDescriptions.first?.setOption(
13    true as NSNumber,
14    forKey: NSInferMappingModelAutomaticallyOption
15)
16 
17// Custom migration — daha fazla kontrol
18class BlogV1toV2MigrationPolicy: NSEntityMigrationPolicy {
19    override func createDestinationInstances(
20        forSource sInstance: NSManagedObject,
21        in mapping: NSEntityMapping,
22        manager: NSMigrationManager
23    ) throws {
24        try super.createDestinationInstances(
25            forSource: sInstance,
26            in: mapping,
27            manager: manager
28        )
29 
30        guard let destination = manager.destinationInstances(
31            forEntityMappingName: mapping.name,
32            sourceInstances: [sInstance]
33        ).first else { return }
34 
35        // Custom transformation
36        destination.setValue(0, forKey: "viewCount")
37    }
38}

1// SwiftData CloudKit — ModelConfiguration ile
2let config = ModelConfiguration(
3    schema: schema,
4    cloudKitDatabase: .automatic // iCloud container otomatik algılanır
5)
6 
7// Conflict resolution — SwiftData otomatik yönetiyor
8// Last-write-wins (varsayılan) veya custom resolver
9 
10// Core Data CloudKit
11let description = NSPersistentStoreDescription()
12description.cloudKitContainerOptions = NSPersistentCloudKitContainerOptions(
13    containerIdentifier: "iCloud.com.yourapp.blog"
14)
15description.setOption(true as NSNumber, forKey: NSPersistentHistoryTrackingKey)
16description.setOption(true as NSNumber,
17                       forKey: NSPersistentStoreRemoteChangeNotificationPostOptionKey)
18 
19container.persistentStoreDescriptions = [description]

1// SwiftData — ModelActor ile clean background
2@ModelActor
3actor BackgroundImporter {
4    func processLargeDataset(_ items: [ItemData]) async throws -> Int {
5        var insertedCount = 0
6 
7        // Batch'ler halinde işle — memory kontrolü için
8        let batchSize = 500
9        for batch in items.chunked(into: batchSize) {
10            for item in batch {
11                let model = BlogPost(
12                    title: item.title,
13                    slug: item.slug,
14                    category: item.category
15                )
16                modelContext.insert(model)
17                insertedCount += 1
18            }
19            try modelContext.save()
20            // Her batch sonrası save — memory'i flush et
21        }
22 
23        return insertedCount
24    }
25}
26 
27// Core Data — performBackgroundTask
28func coreDataBackgroundImport(_ items: [ItemData]) {
29    container.performBackgroundTask { context in
30        context.automaticallyMergesChangesFromParent = true
31 
32        for item in items {
33            let post = BlogPostEntity(context: context)
34            post.id = UUID()
35            post.title = item.title
36            post.slug = item.slug
37            post.category = item.category
38            post.publishedAt = Date()
39        }
40 
41        do {
42            try context.save()
43        } catch {
44            // Error handling
45            context.rollback()
46        }
47    }
48}

1// SwiftData test setup
2import XCTest
3import SwiftData
4 
5@MainActor
6final class BlogRepositoryTests: XCTestCase {
7    var container: ModelContainer!
8    var context: ModelContext!
9 
10    override func setUp() async throws {
11        // In-memory store — disk yazmaz, her test izole
12        let config = ModelConfiguration(isStoredInMemoryOnly: true)
13        container = try ModelContainer(
14            for: BlogPost.self, Comment.self,
15            configurations: config
16        )
17        context = ModelContext(container)
18    }
19 
20    override func tearDown() async throws {
21        container = nil
22        context = nil
23    }
24 
25    func testFetchByCategory() throws {
26        // Arrange
27        let iosPost = BlogPost(title: "Swift Guide", slug: "swift", category: "iOS")
28        let designPost = BlogPost(title: "Design Tips", slug: "design", category: "Design")
29        context.insert(iosPost)
30        context.insert(designPost)
31        try context.save()
32 
33        // Act
34        let descriptor = FetchDescriptor<BlogPost>(
35            predicate: #Predicate { $0.category == "iOS" }
36        )
37        let results = try context.fetch(descriptor)
38 
39        // Assert
40        XCTAssertEqual(results.count, 1)
41        XCTAssertEqual(results.first?.title, "Swift Guide")
42    }
43 
44    func testDeleteCascade() throws {
45        let post = BlogPost(title: "Test Post", slug: "test", category: "iOS")
46        let comment = Comment(text: "Test comment", authorName: "User")
47        post.comments.append(comment)
48        context.insert(post)
49        try context.save()
50 
51        // Delete post — cascade should delete comment
52        context.delete(post)
53        try context.save()
54 
55        let comments = try context.fetch(FetchDescriptor<Comment>())
56        XCTAssertTrue(comments.isEmpty, "Comments should be cascade deleted")
57    }
58}

1// Core Data store üzerinden SwiftData model kullanımı
2// (Aynı SQLite dosyası)
3 
4// 1. Core Data container'ı oluştur
5let coreDataContainer = NSPersistentContainer(name: "BlogModel")
6coreDataContainer.loadPersistentStores { _, error in
7    if let error { fatalError("Core Data yüklenemedi: (error)") }
8}
9 
10// 2. SwiftData ModelContainer'ı aynı store URL ile
11let storeURL = coreDataContainer.persistentStoreDescriptions.first?.url
12 
13let swiftDataConfig = ModelConfiguration(
14    url: storeURL ?? URL.documentsDirectory.appending(path: "BlogModel.sqlite")
15)
16 
17let swiftDataContainer = try ModelContainer(
18    for: BlogPost.self,
19    configurations: swiftDataConfig
20)
21 
22// 3. Core Data context için batch operations
23// SwiftData context için reactive UI
24 
25// Bu pattern şunlar için ideal:
26// - Core Data ile mevcut bir projeyi SwiftData'ya kademeli migrate etmek
27// - Batch insert için Core Data, UI binding için SwiftData
28// - Legacy code Core Data, yeni feature SwiftData

1// Instruments'ta "SwiftData" template'ini aktifleştirmek için:
2// Product → Profile → SwiftData
3// (iOS 26 Simulator veya cihaz gerekli)
4 
5// Debug build'de SwiftData query log'larını görmek için:
6// Environment variable: SWIFTDATA_DEBUG_QUERIES=1
7// Xcode scheme → Run → Environment Variables
8 
9// Şunları gösteriyor:
10// - Her @Query için SQL query ve süre
11// - ModelContext save count
12// - Fault trigger count
13// - CloudKit sync events

1// Genel amaçlı SwiftData fetch helper
2struct DataStore {
3    let context: ModelContext
4 
5    // Paginated fetch
6    func fetchPaginated<T: PersistentModel>(
7        _ type: T.Type,
8        predicate: Predicate<T>? = nil,
9        sortBy: [SortDescriptor<T>] = [],
10        page: Int,
11        pageSize: Int = 20
12    ) throws -> [T] {
13        var descriptor = FetchDescriptor<T>(
14            predicate: predicate,
15            sortBy: sortBy
16        )
17        descriptor.fetchLimit = pageSize
18        descriptor.fetchOffset = page * pageSize
19        return try context.fetch(descriptor)
20    }
21 
22    // Count query (tüm kayıtları çekmeden)
23    func count<T: PersistentModel>(
24        _ type: T.Type,
25        predicate: Predicate<T>? = nil
26    ) throws -> Int {
27        var descriptor = FetchDescriptor<T>(predicate: predicate)
28        descriptor.includePendingChanges = false
29        return try context.fetchCount(descriptor)
30    }
31 
32    // Upsert pattern
33    func upsert<T: PersistentModel>(
34        _ object: T,
35        uniqueBy keyPath: KeyPath<T, some Equatable>
36    ) throws {
37        // SwiftData otomatik upsert yapmıyor — manual kontrol
38        // @Attribute(.unique) ile duplicate prevention tercih edin
39        context.insert(object)
40        try context.save()
41    }
42}
43 
44// Kullanım
45let store = DataStore(context: modelContext)
46let pageOneIosPosts = try store.fetchPaginated(
47    BlogPost.self,
48    predicate: #Predicate { $0.category == "iOS" },
49    sortBy: [SortDescriptor(.publishedAt, order: .reverse)],
50    page: 0
51)
52let totalCount = try store.count(BlogPost.self)