SwiftData中按关联对象数量排序获取Top N Tag的实现问题

Hey there, let's break down what's going on here and work through better solutions for your problem.

First off, you're spot-on about the core issue: as of Swift 6 and Xcode 16, SwiftData doesn't support sorting or filtering directly on the count of a relationship using a SortDescriptor like you tried. The runtime crash happens because SwiftData can't translate \Tag.employees.count into a valid persistent store query—it just doesn't recognize relationship counts as a sortable field out of the box, which mirrors some of Core Data's historical limitations here.

Let's go through your options, from the simplest to the more scalable, while avoiding fragile manual work as much as possible:

1. In-memory sorting (your workaround, polished up) #

Your current approach of fetching all tags and sorting locally is totally valid for small datasets (hundreds of tags, like you mentioned). It's way less fragile than maintaining a manual count, and it works reliably without extra overhead. Here's a cleaned-up version:

guard let allTags = try? modelContext.fetch(FetchDescriptor<Tag>()) else { return nil }
let topTags = allTags.sorted(by: { $0.employees.count > $1.employees.count })
                     .prefix(5)
                     .map { $0 }

This is straightforward, requires no extra model properties, and avoids the headache of syncing counts manually. For your use case, this is probably the most idiomatic solution right now.

2. Make a manual count property less fragile (for large datasets) #

If you ever need to scale to millions of tags and can't fetch all of them at once, a stored numberOfUses property on Tag is the way to go—but we can make it way less fragile than ad-hoc manual updates. Since didSet doesn't work with @Model properties, here are two better approaches:

Option A: Centralize relationship changes with a model actor

Wrap all modifications to the Tag.employees relationship in a @ModelActor to ensure the count is updated automatically every time the relationship changes:

@ModelActor
actor TagRelationshipManager {
    func addEmployee(_ employee: Employee, to tag: Tag) async throws {
        tag.employees.append(employee)
        tag.numberOfUses += 1
        try modelContext.save()
    }

    func removeEmployee(_ employee: Employee, from tag: Tag) async throws {
        guard let index = tag.employees.firstIndex(of: employee) else { return }
        tag.employees.remove(at: index)
        tag.numberOfUses -= 1
        try modelContext.save()
    }
}

By forcing all relationship changes through this actor, you eliminate the risk of forgetting to update the count somewhere in your codebase.

Option B: Observe context save events

If centralizing changes isn't feasible, you can listen to ModelContext save notifications to automatically recalculate counts for affected tags whenever the data changes:

NotificationCenter.default.addObserver(
    forName: .NSManagedObjectContextDidSave,
    object: modelContext,
    queue: .main
) { notification in
    // Collect all tags that might have had their employee count changed
    var tagsToUpdate = Set<Tag>()
    
    // Check updated employees and their tags
    if let updatedEmployees = notification.userInfo?[NSUpdatedObjectsKey] as? Set<Employee> {
        updatedEmployees.forEach { employee in
            employee.tags.forEach { tagsToUpdate.insert($0) }
        }
    }
    
    // Check updated tags directly
    if let updatedTags = notification.userInfo?[NSUpdatedObjectsKey] as? Set<Tag> {
        updatedTags.forEach { tagsToUpdate.insert($0) }
    }
    
    // Recalculate counts
    for tag in tagsToUpdate {
        tag.numberOfUses = tag.employees.count
    }
    
    try? modelContext.save()
}

This is a simplified version—you'd want to extend it to handle inserted/deleted objects too, but it's a solid foundation for automatic count syncing.

3. The "wait for Apple to fix it" option #

It's frustrating, but SwiftData is still a young framework compared to Core Data. Apple has been iterating quickly on it, so support for relationship count sorting/filtering might land in a future Xcode update. For now, though, we have to work with the tools we have.

To wrap up:

• For small datasets, in-memory sorting is the simplest, least fragile solution.
• For large datasets, use a stored numberOfUses property paired with centralized changes or context observation to keep it in sync.
• Unfortunately, there's no built-in "magic" way to sort by relationship counts in SwiftData as of today.

备注：内容来源于stack exchange，提问作者Bryan