Sheldon Wang

Sheldon Wang

Seasoned iOS Veteran, Mentor

iOS Advanced Core Data: Complex Relationships and Performance Optimization

14 minute read

Published:

Core Data is a powerful framework for managing persistent data in iOS applications. However, building complex data models with multiple relationships while maintaining performance requires careful design and optimization. This guide explores advanced Core Data techniques, complex relationship management, and performance optimization strategies.

1. Complex Data Model Design

import CoreData
import Foundation

// MARK: - Core Data Stack
class CoreDataStack {
    static let shared = CoreDataStack()
    
    lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "ComplexDataModel")
        
        // Configure persistent store
        let description = NSPersistentStoreDescription()
        description.type = NSSQLiteStoreType
        description.shouldMigrateAutomatically = true
        description.shouldInferMappingModelAutomatically = true
        
        // Enable WAL mode for better performance
        description.setOption(true as NSNumber, forKey: NSPersistentHistoryTrackingKey)
        description.setOption(true as NSNumber, forKey: NSPersistentStoreRemoteChangeNotificationPostOptionKey)
        
        container.persistentStoreDescriptions = [description]
        
        container.loadPersistentStores { _, error in
            if let error = error {
                fatalError("Core Data failed to load: \(error)")
            }
        }
        
        // Configure contexts
        container.viewContext.automaticallyMergesChangesFromParent = true
        container.viewContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
        
        return container
    }()
    
    var context: NSManagedObjectContext {
        return persistentContainer.viewContext
    }
    
    func newBackgroundContext() -> NSManagedObjectContext {
        let context = persistentContainer.newBackgroundContext()
        context.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
        return context
    }
    
    func save() {
        if context.hasChanges {
            do {
                try context.save()
            } catch {
                print("Failed to save context: \(error)")
            }
        }
    }
}

// MARK: - Complex Data Models
@objc(User)
public class User: NSManagedObject {
    @NSManaged public var id: UUID
    @NSManaged public var name: String
    @NSManaged public var email: String
    @NSManaged public var createdAt: Date
    @NSManaged public var posts: Set<Post>
    @NSManaged public var comments: Set<Comment>
    @NSManaged public var followers: Set<User>
    @NSManaged public var following: Set<User>
    @NSManaged public var profile: UserProfile?
    
    // Computed properties for convenience
    var postsArray: [Post] {
        return Array(posts).sorted { $0.createdAt > $1.createdAt }
    }
    
    var followersCount: Int {
        return followers.count
    }
    
    var followingCount: Int {
        return following.count
    }
}

@objc(Post)
public class Post: NSManagedObject {
    @NSManaged public var id: UUID
    @NSManaged public var title: String
    @NSManaged public var content: String
    @NSManaged public var createdAt: Date
    @NSManaged public var updatedAt: Date
    @NSManaged public var author: User
    @NSManaged public var comments: Set<Comment>
    @NSManaged public var likes: Set<Like>
    @NSManaged public var tags: Set<Tag>
    @NSManaged public var category: Category?
    
    // Computed properties
    var commentsArray: [Comment] {
        return Array(comments).sorted { $0.createdAt < $1.createdAt }
    }
    
    var likesCount: Int {
        return likes.count
    }
    
    var tagsArray: [Tag] {
        return Array(tags).sorted { $0.name < $1.name }
    }
}

@objc(Comment)
public class Comment: NSManagedObject {
    @NSManaged public var id: UUID
    @NSManaged public var content: String
    @NSManaged public var createdAt: Date
    @NSManaged public var author: User
    @NSManaged public var post: Post
    @NSManaged public var parentComment: Comment?
    @NSManaged public var replies: Set<Comment>
    @NSManaged public var likes: Set<Like>
}

@objc(Tag)
public class Tag: NSManagedObject {
    @NSManaged public var id: UUID
    @NSManaged public var name: String
    @NSManaged public var posts: Set<Post>
    @NSManaged public var category: Category?
}

@objc(Category)
public class Category: NSManagedObject {
    @NSManaged public var id: UUID
    @NSManaged public var name: String
    @NSManaged public var posts: Set<Post>
    @NSManaged public var tags: Set<Tag>
}

@objc(UserProfile)
public class UserProfile: NSManagedObject {
    @NSManaged public var id: UUID
    @NSManaged public var bio: String?
    @NSManaged public var avatarURL: String?
    @NSManaged public var user: User
    @NSManaged public var preferences: UserPreferences?
}

@objc(UserPreferences)
public class UserPreferences: NSManagedObject {
    @NSManaged public var id: UUID
    @NSManaged public var notificationsEnabled: Bool
    @NSManaged public var theme: String
    @NSManaged public var language: String
    @NSManaged public var profile: UserProfile
}

@objc(Like)
public class Like: NSManagedObject {
    @NSManaged public var id: UUID
    @NSManaged public var createdAt: Date
    @NSManaged public var user: User
    @NSManaged public var post: Post?
    @NSManaged public var comment: Comment?
}

2. Advanced Relationship Management

// MARK: - Relationship Manager
class RelationshipManager {
    private let context: NSManagedObjectContext
    
    init(context: NSManagedObjectContext) {
        self.context = context
    }
    
    // MARK: - User Relationships
    func followUser(_ follower: User, _ following: User) {
        context.performAndWait {
            follower.following.insert(following)
            following.followers.insert(follower)
            
            try? context.save()
        }
    }
    
    func unfollowUser(_ follower: User, _ following: User) {
        context.performAndWait {
            follower.following.remove(following)
            following.followers.remove(follower)
            
            try? context.save()
        }
    }
    
    // MARK: - Post Relationships
    func addComment(to post: Post, content: String, author: User, parentComment: Comment? = nil) {
        context.performAndWait {
            let comment = Comment(context: context)
            comment.id = UUID()
            comment.content = content
            comment.createdAt = Date()
            comment.author = author
            comment.post = post
            comment.parentComment = parentComment
            
            post.comments.insert(comment)
            author.comments.insert(comment)
            
            if let parentComment = parentComment {
                parentComment.replies.insert(comment)
            }
            
            try? context.save()
        }
    }
    
    func likePost(_ post: Post, by user: User) {
        context.performAndWait {
            // Check if already liked
            let existingLike = post.likes.first { $0.user == user }
            guard existingLike == nil else { return }
            
            let like = Like(context: context)
            like.id = UUID()
            like.createdAt = Date()
            like.user = user
            like.post = post
            
            post.likes.insert(like)
            user.likes.insert(like)
            
            try? context.save()
        }
    }
    
    func unlikePost(_ post: Post, by user: User) {
        context.performAndWait {
            if let like = post.likes.first(where: { $0.user == user }) {
                post.likes.remove(like)
                user.likes.remove(like)
                context.delete(like)
                
                try? context.save()
            }
        }
    }
    
    // MARK: - Tag Management
    func addTags(_ tagNames: [String], to post: Post) {
        context.performAndWait {
            for tagName in tagNames {
                let tag = getOrCreateTag(name: tagName)
                post.tags.insert(tag)
                tag.posts.insert(post)
            }
            
            try? context.save()
        }
    }
    
    private func getOrCreateTag(name: String) -> Tag {
        let fetchRequest: NSFetchRequest<Tag> = Tag.fetchRequest()
        fetchRequest.predicate = NSPredicate(format: "name == %@", name)
        fetchRequest.fetchLimit = 1
        
        if let existingTag = try? context.fetch(fetchRequest).first {
            return existingTag
        } else {
            let newTag = Tag(context: context)
            newTag.id = UUID()
            newTag.name = name
            return newTag
        }
    }
}

// MARK: - Batch Operations
class BatchOperationManager {
    private let context: NSManagedObjectContext
    
    init(context: NSManagedObjectContext) {
        self.context = context
    }
    
    func batchInsertUsers(_ userData: [[String: Any]]) async throws {
        try await context.perform {
            for userInfo in userData {
                let user = User(context: self.context)
                user.id = UUID()
                user.name = userInfo["name"] as? String ?? ""
                user.email = userInfo["email"] as? String ?? ""
                user.createdAt = Date()
                
                // Create profile
                let profile = UserProfile(context: self.context)
                profile.id = UUID()
                profile.bio = userInfo["bio"] as? String
                profile.avatarURL = userInfo["avatarURL"] as? String
                profile.user = user
                user.profile = profile
            }
            
            try self.context.save()
        }
    }
    
    func batchUpdatePostLikes() async throws {
        try await context.perform {
            let fetchRequest: NSFetchRequest<Post> = Post.fetchRequest()
            let posts = try self.context.fetch(fetchRequest)
            
            for post in posts {
                // Update like count or other computed properties
                // This is just an example - you might want to update different properties
                post.updatedAt = Date()
            }
            
            try self.context.save()
        }
    }
    
    func batchDeleteOldComments(olderThan date: Date) async throws {
        try await context.perform {
            let fetchRequest: NSFetchRequest<Comment> = Comment.fetchRequest()
            fetchRequest.predicate = NSPredicate(format: "createdAt < %@", date as NSDate)
            
            let oldComments = try self.context.fetch(fetchRequest)
            
            for comment in oldComments {
                self.context.delete(comment)
            }
            
            try self.context.save()
        }
    }
}

3. Performance Optimization Strategies

// MARK: - Optimized Fetch Requests
class OptimizedFetchManager {
    private let context: NSManagedObjectContext
    
    init(context: NSManagedObjectContext) {
        self.context = context
    }
    
    // MARK: - Paginated Fetching
    func fetchPosts(page: Int, pageSize: Int = 20) async throws -> [Post] {
        return try await context.perform {
            let fetchRequest: NSFetchRequest<Post> = Post.fetchRequest()
            fetchRequest.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]
            fetchRequest.fetchOffset = page * pageSize
            fetchRequest.fetchLimit = pageSize
            
            // Prefetch relationships
            fetchRequest.relationshipKeyPathsForPrefetching = [
                "author",
                "author.profile",
                "tags",
                "category"
            ]
            
            return try self.context.fetch(fetchRequest)
        }
    }
    
    // MARK: - Aggregation Queries
    func getUserStats(userId: UUID) async throws -> UserStats {
        return try await context.perform {
            let userFetchRequest: NSFetchRequest<User> = User.fetchRequest()
            userFetchRequest.predicate = NSPredicate(format: "id == %@", userId as CVarArg)
            userFetchRequest.fetchLimit = 1
            
            guard let user = try self.context.fetch(userFetchRequest).first else {
                throw CoreDataError.userNotFound
            }
            
            // Get post count
            let postCount = user.posts.count
            
            // Get total likes received
            let totalLikes = user.posts.reduce(0) { $0 + $1.likes.count }
            
            // Get comment count
            let commentCount = user.comments.count
            
            // Get follower count
            let followerCount = user.followers.count
            
            return UserStats(
                postCount: postCount,
                totalLikes: totalLikes,
                commentCount: commentCount,
                followerCount: followerCount
            )
        }
    }
    
    // MARK: - Complex Queries with Subqueries
    func getPopularPosts(limit: Int = 10) async throws -> [Post] {
        return try await context.perform {
            let fetchRequest: NSFetchRequest<Post> = Post.fetchRequest()
            
            // Sort by like count and creation date
            fetchRequest.sortDescriptors = [
                NSSortDescriptor(key: "likes.@count", ascending: false),
                NSSortDescriptor(key: "createdAt", ascending: false)
            ]
            
            fetchRequest.fetchLimit = limit
            
            // Only include posts with at least 5 likes
            fetchRequest.predicate = NSPredicate(format: "likes.@count >= 5")
            
            // Prefetch relationships
            fetchRequest.relationshipKeyPathsForPrefetching = [
                "author",
                "author.profile",
                "tags"
            ]
            
            return try self.context.fetch(fetchRequest)
        }
    }
    
    // MARK: - Search with Full-Text Search
    func searchPosts(query: String) async throws -> [Post] {
        return try await context.perform {
            let fetchRequest: NSFetchRequest<Post> = Post.fetchRequest()
            
            // Use CONTAINS for simple text search
            let titlePredicate = NSPredicate(format: "title CONTAINS[cd] %@", query)
            let contentPredicate = NSPredicate(format: "content CONTAINS[cd] %@", query)
            
            fetchRequest.predicate = NSCompoundPredicate(
                type: .or,
                subpredicates: [titlePredicate, contentPredicate]
            )
            
            fetchRequest.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]
            
            return try self.context.fetch(fetchRequest)
        }
    }
}

// MARK: - User Stats Model
struct UserStats {
    let postCount: Int
    let totalLikes: Int
    let commentCount: Int
    let followerCount: Int
}

// MARK: - Core Data Error
enum CoreDataError: Error {
    case userNotFound
    case postNotFound
    case saveFailed
}

4. Background Processing and Concurrency

// MARK: - Background Processing Manager
class BackgroundProcessingManager {
    private let coreDataStack: CoreDataStack
    
    init(coreDataStack: CoreDataStack) {
        self.coreDataStack = coreDataStack
    }
    
    // MARK: - Background Import
    func importDataInBackground(_ data: [[String: Any]]) async throws {
        let backgroundContext = coreDataStack.newBackgroundContext()
        
        try await backgroundContext.perform {
            for item in data {
                // Process each item
                try self.processDataItem(item, in: backgroundContext)
            }
            
            // Save background context
            if backgroundContext.hasChanges {
                try backgroundContext.save()
            }
        }
    }
    
    private func processDataItem(_ item: [String: Any], in context: NSManagedObjectContext) throws {
        // Implementation for processing individual data items
        // This would depend on your specific data structure
    }
    
    // MARK: - Background Cleanup
    func performBackgroundCleanup() async throws {
        let backgroundContext = coreDataStack.newBackgroundContext()
        
        try await backgroundContext.perform {
            // Delete old posts (older than 1 year)
            let oneYearAgo = Calendar.current.date(byAdding: .year, value: -1, to: Date())!
            
            let fetchRequest: NSFetchRequest<Post> = Post.fetchRequest()
            fetchRequest.predicate = NSPredicate(format: "createdAt < %@", oneYearAgo as NSDate)
            
            let oldPosts = try backgroundContext.fetch(fetchRequest)
            
            for post in oldPosts {
                backgroundContext.delete(post)
            }
            
            // Delete orphaned likes
            let orphanedLikesFetchRequest: NSFetchRequest<Like> = Like.fetchRequest()
            orphanedLikesFetchRequest.predicate = NSPredicate(format: "post == nil AND comment == nil")
            
            let orphanedLikes = try backgroundContext.fetch(orphanedLikesFetchRequest)
            
            for like in orphanedLikes {
                backgroundContext.delete(like)
            }
            
            if backgroundContext.hasChanges {
                try backgroundContext.save()
            }
        }
    }
    
    // MARK: - Batch Processing
    func processBatchUpdates(_ updates: [BatchUpdate]) async throws {
        let backgroundContext = coreDataStack.newBackgroundContext()
        
        try await backgroundContext.perform {
            for update in updates {
                try self.applyBatchUpdate(update, in: backgroundContext)
            }
            
            if backgroundContext.hasChanges {
                try backgroundContext.save()
            }
        }
    }
    
    private func applyBatchUpdate(_ update: BatchUpdate, in context: NSManagedObjectContext) throws {
        switch update {
        case .updatePost(let postId, let updates):
            let fetchRequest: NSFetchRequest<Post> = Post.fetchRequest()
            fetchRequest.predicate = NSPredicate(format: "id == %@", postId as CVarArg)
            
            if let post = try context.fetch(fetchRequest).first {
                for (key, value) in updates {
                    post.setValue(value, forKey: key)
                }
            }
            
        case .deletePost(let postId):
            let fetchRequest: NSFetchRequest<Post> = Post.fetchRequest()
            fetchRequest.predicate = NSPredicate(format: "id == %@", postId as CVarArg)
            
            if let post = try context.fetch(fetchRequest).first {
                context.delete(post)
            }
        }
    }
}

// MARK: - Batch Update Types
enum BatchUpdate {
    case updatePost(UUID, [String: Any])
    case deletePost(UUID)
}

5. Data Validation and Constraints

// MARK: - Data Validator
class DataValidator {
    static func validateUser(_ user: User) throws {
        // Validate required fields
        guard !user.name.isEmpty else {
            throw ValidationError.emptyName
        }
        
        guard !user.email.isEmpty else {
            throw ValidationError.emptyEmail
        }
        
        // Validate email format
        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
        let emailPredicate = NSPredicate(format: "SELF MATCHES %@", emailRegex)
        
        guard emailPredicate.evaluate(with: user.email) else {
            throw ValidationError.invalidEmail
        }
        
        // Validate name length
        guard user.name.count >= 2 && user.name.count <= 50 else {
            throw ValidationError.invalidNameLength
        }
    }
    
    static func validatePost(_ post: Post) throws {
        guard !post.title.isEmpty else {
            throw ValidationError.emptyTitle
        }
        
        guard post.title.count <= 200 else {
            throw ValidationError.titleTooLong
        }
        
        guard !post.content.isEmpty else {
            throw ValidationError.emptyContent
        }
        
        guard post.content.count <= 10000 else {
            throw ValidationError.contentTooLong
        }
    }
    
    static func validateComment(_ comment: Comment) throws {
        guard !comment.content.isEmpty else {
            throw ValidationError.emptyContent
        }
        
        guard comment.content.count <= 1000 else {
            throw ValidationError.contentTooLong
        }
    }
}

// MARK: - Validation Errors
enum ValidationError: Error, LocalizedError {
    case emptyName
    case emptyEmail
    case invalidEmail
    case invalidNameLength
    case emptyTitle
    case titleTooLong
    case emptyContent
    case contentTooLong
    
    var errorDescription: String? {
        switch self {
        case .emptyName:
            return "Name cannot be empty"
        case .emptyEmail:
            return "Email cannot be empty"
        case .invalidEmail:
            return "Invalid email format"
        case .invalidNameLength:
            return "Name must be between 2 and 50 characters"
        case .emptyTitle:
            return "Title cannot be empty"
        case .titleTooLong:
            return "Title cannot exceed 200 characters"
        case .emptyContent:
            return "Content cannot be empty"
        case .contentTooLong:
            return "Content cannot exceed 10000 characters"
        }
    }
}

6. SwiftUI Integration

import SwiftUI

// MARK: - Core Data Observable Object
class CoreDataObservable: ObservableObject {
    @Published var users: [User] = []
    @Published var posts: [Post] = []
    @Published var isLoading = false
    
    private let fetchManager: OptimizedFetchManager
    private let relationshipManager: RelationshipManager
    
    init(context: NSManagedObjectContext) {
        self.fetchManager = OptimizedFetchManager(context: context)
        self.relationshipManager = RelationshipManager(context: context)
    }
    
    func loadPosts() async {
        await MainActor.run { isLoading = true }
        
        do {
            let fetchedPosts = try await fetchManager.fetchPosts(page: 0)
            await MainActor.run {
                self.posts = fetchedPosts
                self.isLoading = false
            }
        } catch {
            print("Failed to load posts: \(error)")
            await MainActor.run { isLoading = false }
        }
    }
    
    func loadMorePosts() async {
        let nextPage = posts.count / 20
        
        do {
            let morePosts = try await fetchManager.fetchPosts(page: nextPage)
            await MainActor.run {
                self.posts.append(contentsOf: morePosts)
            }
        } catch {
            print("Failed to load more posts: \(error)")
        }
    }
    
    func likePost(_ post: Post, by user: User) {
        relationshipManager.likePost(post, by: user)
        
        // Update local state
        if let index = posts.firstIndex(where: { $0.id == post.id }) {
            posts[index] = post
        }
    }
}

// MARK: - Posts List View
struct PostsListView: View {
    @StateObject private var dataManager: CoreDataObservable
    @State private var searchText = ""
    
    init(context: NSManagedObjectContext) {
        self._dataManager = StateObject(wrappedValue: CoreDataObservable(context: context))
    }
    
    var body: some View {
        NavigationView {
            List {
                ForEach(dataManager.posts, id: \.id) { post in
                    PostRowView(post: post)
                        .onAppear {
                            // Load more posts when reaching the end
                            if post.id == dataManager.posts.last?.id {
                                Task {
                                    await dataManager.loadMorePosts()
                                }
                            }
                        }
                }
            }
            .navigationTitle("Posts")
            .searchable(text: $searchText)
            .onChange(of: searchText) { newValue in
                // Implement search functionality
            }
            .refreshable {
                await dataManager.loadPosts()
            }
        }
        .task {
            await dataManager.loadPosts()
        }
    }
}

// MARK: - Post Row View
struct PostRowView: View {
    let post: Post
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text(post.title)
                .font(.headline)
            
            Text(post.content)
                .font(.body)
                .lineLimit(3)
            
            HStack {
                Text(post.author.name)
                    .font(.caption)
                    .foregroundColor(.secondary)
                
                Spacer()
                
                Text("\(post.likesCount) likes")
                    .font(.caption)
                    .foregroundColor(.secondary)
                
                Text("\(post.commentsArray.count) comments")
                    .font(.caption)
                    .foregroundColor(.secondary)
            }
        }
        .padding(.vertical, 4)
    }
}

Summary

Advanced Core Data implementation requires:

  1. Complex Data Models: Design relationships that reflect real-world data structures
  2. Performance Optimization: Use pagination, prefetching, and batch operations
  3. Background Processing: Handle data operations without blocking the UI
  4. Data Validation: Ensure data integrity with proper validation
  5. Concurrency Management: Use appropriate contexts for different operations
  6. SwiftUI Integration: Create reactive data layers for modern UI frameworks

By implementing these patterns, you can build robust, performant data management systems that scale with your application’s needs.

You May Also Enjoy

iOS Advanced UI Components: Custom Views and Complex Interactions

17 minute read

Published:

Creating sophisticated iOS applications requires building custom UI components that go beyond standard UIKit and SwiftUI controls. This guide explores advanced UI development techniques, custom view creation, complex gesture handling, and performance optimization for custom components.

iOS System Design: Building a Real-time Messaging System

16 minute read

Published:

Building a real-time messaging system within an iOS app requires careful consideration of network connectivity, message delivery, offline support, and user experience. This guide explores the architecture and implementation of a robust messaging system that handles real-time communication, message persistence, and seamless user interactions.

iOS System Design: Building a Complex Photo Editing System

12 minute read

Published:

Designing a complex photo editing system within an iOS app requires careful consideration of performance, memory management, and user experience. This guide explores the architecture and implementation of a professional-grade photo editing system that handles multiple filters, real-time previews, and efficient memory usage.

iOS Advanced Memory Management: ARC, Weak References, and Memory Leaks

9 minute read

Published:

Memory management is crucial for iOS app performance and stability. While Swift’s Automatic Reference Counting (ARC) handles most memory management automatically, understanding weak references, retain cycles, and memory leaks is essential for building robust applications. This guide explores advanced memory management techniques with real, working code examples.