SwiftUI中解决@FetchRequest与NSDictionaryResultType冲突的聚合查询方案

我有一个简化的CoreData模型，包含Category和Transaction两个实体，二者为一对多关系（一个Category对应多个Transaction）：

Category
--------
title: String
transactions: Transaction[]

Transaction
-----------
title: String
amount: Double
date: Date
category: Category

我需要计算指定分类、指定时间范围内所有Transaction的金额总和，例如查询2022年3月“Food”分类下的所有交易总额。当前我已实现一个查询逻辑（目前仅查询过去30天的数据）：

let sumExpression = NSExpressionDescription()
let keypathAmount = NSExpression(forKeyPath: "amount")
sumExpression.expression = NSExpression(forFunction: "sum:", arguments: [keypathAmount])
sumExpression.name = "sum"
sumExpression.expressionResultType = .doubleAttributeType

let request = NSFetchRequest<NSFetchRequestResult>(entityName: "Transaction")
let adjustedDate = Calendar.current.date(byAdding: .day, value: -30, to: Date()) ?? Date()
let datePredicate = NSPredicate(format: "date > %@", adjustedDate as CVarArg)
request.predicate = NSCompoundPredicate(
  type: .and,
  subpredicates: [datePredicate, NSPredicate(format: "category == %@", category)]
)
request.propertiesToFetch = [sumExpression]
request.includesPendingChanges = false 
request.returnsObjectsAsFaults = false
request.resultType = .dictionaryResultType
request.returnsDistinctResults = true

do {
  let results = try moc.fetch(request)
  let resultMap = results[0] as! [String:Double]
  return resultMap["sum"] ?? 0.0
} catch let error as NSError {
  NSLog("Error when summing amounts: \(error.localizedDescription)")
}

由于我使用了@Environment(\.managedObjectContext) var moc，无法在init()中执行该查询（环境变量此时不可用），因此目前将查询逻辑放在视图的onAppear()方法中。视图中存在一个当前选中Category的@ObservedObject对象，但当交易数据发生变化（例如新增交易）时，查询结果不会自动更新。同时，我无法将上述NSFetchRequest用于@FetchRequest属性，因为Xcode会报错：

'NSFetchedResultsController does not support both change tracking and fetch request's with NSDictionaryResultType'

请问如何解决该问题？在SwiftUI中获取关联属性过滤后的总和的最佳方式是什么？如何利用已有的@ObservedObject category在数据变化时重新执行查询？

方案1：直接利用关联集合过滤求和（简单场景首选） #

既然你已经持有@ObservedObject var selectedCategory: Category，可以直接对其关联的transactions集合做过滤和求和，这种方式会自动响应数据变化：

// 在视图内定义计算属性
private var totalAmount: Double {
    guard let transactions = selectedCategory.transactions as? Set<Transaction> else { return 0.0 }
    let adjustedDate = Calendar.current.date(byAdding: .day, value: -30, to: Date()) ?? Date()
    return transactions
        .filter { $0.date > adjustedDate }
        .reduce(0.0) { $0 + $1.amount }
}

• 优势：无需额外CoreData查询，代码简洁；selectedCategory是@ObservedObject，其关联交易的新增/删除/修改都会自动触发视图更新，总和实时同步。
• 局限性：如果交易数量极大（上万级），内存过滤会有性能损耗，适合日常中小数据量场景。

方案2：自定义ObservableObject封装聚合查询（大数据量场景） #

如果需要保持数据库层面的聚合查询效率，可封装一个专门的计算器对象，监听CoreData上下文变化自动重新计算：

class SumCalculator: ObservableObject {
    @Published var total: Double = 0.0
    private let moc: NSManagedObjectContext
    private var category: Category
    private var dateRange: ClosedRange<Date>
    private var notificationToken: NSObjectProtocol?
    
    init(moc: NSManagedObjectContext, category: Category, dateRange: ClosedRange<Date>) {
        self.moc = moc
        self.category = category
        self.dateRange = dateRange
        updateTotal()
        
        // 监听上下文保存事件，自动刷新总和
        notificationToken = NotificationCenter.default.addObserver(
            forName: NSManagedObjectContext.didSaveObjectsNotification,
            object: moc,
            queue: .main
        ) { [weak self] _ in
            self?.updateTotal()
        }
    }
    
    deinit {
        if let token = notificationToken {
            NotificationCenter.default.removeObserver(token)
        }
    }
    
    // 支持动态修改日期范围
    func updateDateRange(_ newRange: ClosedRange<Date>) {
        dateRange = newRange
        updateTotal()
    }
    
    private func updateTotal() {
        let sumExpression = NSExpressionDescription()
        let keypathAmount = NSExpression(forKeyPath: "amount")
        sumExpression.expression = NSExpression(forFunction: "sum:", arguments: [keypathAmount])
        sumExpression.name = "sum"
        sumExpression.expressionResultType = .doubleAttributeType
        
        let request = NSFetchRequest<NSFetchRequestResult>(entityName: "Transaction")
        request.predicate = NSCompoundPredicate(
            type: .and,
            subpredicates: [
                NSPredicate(format: "date BETWEEN %@", [dateRange.lowerBound, dateRange.upperBound]),
                NSPredicate(format: "category == %@", category)
            ]
        )
        request.propertiesToFetch = [sumExpression]
        request.resultType = .dictionaryResultType
        
        do {
            let results = try moc.fetch(request)
            total = (results.first as? [String: Double])?["sum"] ?? 0.0
        } catch {
            NSLog("Error calculating sum: \(error.localizedDescription)")
            total = 0.0
        }
    }
}

在视图中使用：

struct TransactionSumView: View {
    @Environment(\.managedObjectContext) var moc
    @ObservedObject var selectedCategory: Category
    @StateObject private var sumCalculator: SumCalculator
    
    init(selectedCategory: Category) {
        self.selectedCategory = selectedCategory
        let startDate = Calendar.current.date(byAdding: .day, value: -30, to: Date()) ?? Date()
        let dateRange = startDate...Date()
        _sumCalculator = StateObject(wrappedValue: SumCalculator(moc: moc, category: selectedCategory, dateRange: dateRange))
    }
    
    var body: some View {
        Text("Total: $\(sumCalculator.total, specifier: "%.2f")")
        // 如果需要动态修改日期范围，可添加控件调用sumCalculator.updateDateRange()
    }
}

• 优势：利用数据库聚合查询，大数据量下性能更优；自动响应上下文数据变更，无需手动触发。

方案3：扩展Category实体封装求和逻辑（代码复用性高） #

将求和逻辑封装到Category的扩展中，再在视图中监听变化触发计算：

extension Category {
    func totalAmount(in dateRange: ClosedRange<Date>) -> Double {
        guard let moc = managedObjectContext else { return 0.0 }
        let sumExpression = NSExpressionDescription()
        let keypathAmount = NSExpression(forKeyPath: "amount")
        sumExpression.expression = NSExpression(forFunction: "sum:", arguments: [keypathAmount])
        sumExpression.name = "sum"
        sumExpression.expressionResultType = .doubleAttributeType
        
        let request = NSFetchRequest<NSFetchRequestResult>(entityName: "Transaction")
        request.predicate = NSCompoundPredicate(
            type: .and,
            subpredicates: [
                NSPredicate(format: "date BETWEEN %@", [dateRange.lowerBound, dateRange.upperBound]),
                NSPredicate(format: "category == %@", self)
            ]
        )
        request.propertiesToFetch = [sumExpression]
        request.resultType = .dictionaryResultType
        
        do {
            let results = try moc.fetch(request)
            return (results.first as? [String: Double])?["sum"] ?? 0.0
        } catch {
            return 0.0
        }
    }
}

视图中使用：

struct TransactionSumView: View {
    @Environment(\.managedObjectContext) var moc
    @ObservedObject var selectedCategory: Category
    @State private var total: Double = 0.0
    private let dateRange: ClosedRange<Date>
    
    init(selectedCategory: Category) {
        self.selectedCategory = selectedCategory
        self.dateRange = (Calendar.current.date(byAdding: .day, value: -30, to: Date()) ?? Date())...Date()
    }
    
    var body: some View {
        Text("Total: $\(total, specifier: "%.2f")")
            .onAppear(perform: updateTotal)
            .onChange(of: selectedCategory.transactions) { _ in
                updateTotal()
            }
            .onReceive(NotificationCenter.default.publisher(for: NSManagedObjectContext.didSaveObjectsNotification)) { _ in
                updateTotal()
            }
    }
    
    private func updateTotal() {
        total = selectedCategory.totalAmount(in: dateRange)
    }
}

• 优势：求和逻辑与实体绑定，可在多个视图复用；通过视图监听事件确保数据变化时自动更新。

内容的提问来源于stack exchange，提问作者fasoh