Cannot get Realm result for objects filtered by the latest (nsdate) value of a property of a collection property swift (the example is clearer)

Question

I Have the following model

class Process: Object {
    @objc dynamic var processID:Int = 1
    let steps = List<Step>()
}

class Step: Object {
    @objc private dynamic var stepCode: Int = 0
    @objc dynamic var stepDateUTC: Date? = nil
    var stepType: ProcessStepType {
        get {
            return ProcessStepType(rawValue: stepCode) ?? .created
        }
        set {
            stepCode = newValue.rawValue
        }
    }
}

enum ProcessStepType: Int { // to review - real value
    case created = 0
    case scheduled = 1
    case processing = 2
    case paused = 3
    case finished = 4
}

A process can start, processing , paused , resume (to be in step processing again), pause , resume again,etc. the current step is the one with the latest stepDateUTC

I am trying to get all Processes, having for last step ,a step of stepType processing "processing ", ie. where for the last stepDate, stepCode is 2 . I came with the following predicate... which doesn't work. Any idea of the right perform to perform such query ?

my best trial is the one. Is it possible to get to this result via one realm query .

let processes = realm.objects(Process.self).filter(NSPredicate(format: "ANY steps.stepCode = 2 AND NOT (ANY steps.stepCode = 4)")

let ongoingprocesses = processes.filter(){$0.steps.sorted(byKeyPath: "stepDateUTC", ascending: false).first!.stepType == .processing}

what I hoped would work

NSPredicate(format: "steps[LAST].stepCode = \(TicketStepType.processing.rawValue)")

I understand [LAST] is not supported by realm (as per the cheatsheet). but is there anyway around I could achieve my goal through a realm query?

Answer 1

There are a few ways to approach this and it doesn't appear the date property is relevant because lists are stored in sequential order (as long as they are not altered), so the last element in the List was added last.

This first piece of code will filter for processes where the last element is 'processing'. I coded this long-handed so the flow is more understandable.

let results = realm.objects(Process.self).filter { p in
    let lastIndex = p.steps.count - 1
    let step = p.steps[lastIndex]
    let type = step.stepType
    if type == .processing {
        return true
    }
    return false
}

Note that Realm objects are lazily loaded - which means thousands of objects have a low memory impact. By filtering using Swift, the objects are filtered in memory so the impact is more significant.

The second piece of code is what I would suggest as it makes filtering much simpler, but would require a slight change to the Process model.

class Process: Object {
    @objc dynamic var processID:Int = 1
    let stepHistory = List<Step>() //RENAMED: the history of the steps
    @objc dynamic var name = ""

    //ADDED: new property tracks current step
    @objc dynamic var current_step = ProcessStepType.created.index 
}

My thought here is that the Process model keeps a 'history' of steps that have occurred so far, and then what the current_step is.

I also modified the ProcessStepType enum to make it more filterable friendly.

enum ProcessStepType: Int { // to review - real value
    case created = 0
    case scheduled = 1
    case processing = 2
    case paused = 3
    case finished = 4

    //this is used when filtering
    var index: Int {
        switch self {
        case .created:
            return 0
        case .scheduled:
            return 1
        case .processing:
            return 2
        case .paused:
            return 3
        case .finished:
            return 4
        }
    }
}

Then to return all processes where the last step in the list is 'processing' here's the filter

let results2 = realm.objects(Process.self).filter("current_step == %@", ProcessStepType.processing.index)

The final thought is to add some code to the Process model so when a step is added to the list, the current_step var is also updated. Coding that is left to the OP.