Core Data - Come per andare a prendere un soggetto con la proprietà valore massimo

Question

Ho un'entità Person con una proprietà personId (personId è unico)

Come posso prendere la persona con il massimo personId?

(voglio andare a prendere la persona in sé non il valore della proprietà)

Answer 1

Si imposta il fetchLimit per 1 e ordina per personId in ordine decrescente. Ad esempio:

NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] initWithEntityName:@"Person"]; 

fetchRequest.fetchLimit = 1; 
fetchRequest.sortDescriptors = @[[NSSortDescriptor sortDescriptorWithKey:@"personId" ascending:NO]]; 

NSError *error = nil; 

id person = [managedObjectContext executeFetchRequest:fetchRequest error:&error].firstObject; 

Answer 2

È necessario utilizzare un NSFetchRequest con un NSPredicate per specificare la vostra richiesta ...

Adattato da Apple Predicate Progamming Guida:

NSFetchRequest *request = [[[NSFetchRequest alloc] init] autorelease]; 
NSEntityDescription *entity = [NSEntityDescription entityForName:@"Person" 
    inManagedObjectContext:managedObjectContext]; 
[request setEntity:entity]; 

request.predicate = [NSPredicate predicateWithFormat:@"personId==max(personId)"]; 
request.sortDescriptors = [NSArray array]; 

NSError *error = nil; 
NSArray *array = [managedObjectContext executeFetchRequest:request error:&error]; 

Answer 3

Il metodo consigliato è quello di utilizzare Apple Recommended Method NSExpression. Mi aspetterei che questo sarebbe meno costoso rispetto all'utilizzo di un ordinamento. Se ci pensate, con una specie dovrete prendere tutti i record per ordinarli e mantenere il massimo. Con un'espressione dovresti solo leggere l'elenco e mantenere in memoria il massimo.

Ecco un esempio che uso con NSDate

- (NSDate *)lastSync:(PHAssetMediaType)mediaType { 
    NSEntityDescription *entity = [NSEntityDescription entityForName:kMediaItemEntity inManagedObjectContext:self.managedObjectContext]; 

    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init]; 
    fetchRequest.entity = entity; 
    fetchRequest.resultType = NSDictionaryResultType; 

    NSMutableArray *predicates = [NSMutableArray array]; 
    [predicates addObject:[NSPredicate predicateWithFormat:@"%K=%d", kMediaType,mediaType]]; 
    [predicates addObject:[NSPredicate predicateWithFormat:@"%K=%d", kMediaProviderType,self.mediaProviderType]]; 
    NSPredicate *predicate = [NSCompoundPredicate andPredicateWithSubpredicates: predicates]; 
    fetchRequest.predicate = predicate; 

    // Create an expression for the key path. 

    NSExpression *keyPathExpression = [NSExpression expressionForKeyPath:kSyncTime]; 
    // Create an expression to represent the function you want to apply 

    NSExpression *maxExpression = [NSExpression expressionForFunction:@"max:" 
                  arguments:@[keyPathExpression]]; 

    // Create an expression description using the maxExpression and returning a date. 
    NSExpressionDescription *expressionDescription = [[NSExpressionDescription alloc] init]; 
    [expressionDescription setName:@"maxDate"]; 
    [expressionDescription setExpression:maxExpression]; 
    [expressionDescription setExpressionResultType:NSDateAttributeType]; 

    // Set the request's properties to fetch just the property represented by the expressions. 
    fetchRequest.propertiesToFetch = @[expressionDescription] ; // @[kSyncTime]; 

    NSError *fetchError = nil; 
    id requestedValue = nil; 

    // fetch stored media 
    NSArray *results = [self.managedObjectContext executeFetchRequest:fetchRequest error:&fetchError]; 
    if (fetchError || results == nil || results.count == 0) { 
     return [NSDate dateWithTimeIntervalSince1970:0]; 
    } 
    requestedValue = [[results objectAtIndex:0] valueForKey:@"maxDate"]; 
    if (![requestedValue isKindOfClass:[NSDate class]]) { 
     return [NSDate dateWithTimeIntervalSince1970:0]; 
    } 
    DDLogDebug(@"sync date %@",requestedValue); 
    return (NSDate *)requestedValue; 
} 

Answer 4

La risposta di cui sopra usando NSExpression è corretta. Ecco la versione Swift.

private func getLastContactSyncTimestamp() -> Int64? { 

let request: NSFetchRequest<NSFetchRequestResult> = NSFetchRequest() 
request.entity = NSEntityDescription.entity(forEntityName: "Contact", in: self.moc) 
request.resultType = NSFetchRequestResultType.dictionaryResultType 

let keypathExpression = NSExpression(forKeyPath: "timestamp") 
let maxExpression = NSExpression(forFunction: "max:", arguments: [keypathExpression]) 

let key = "maxTimestamp" 

let expressionDescription = NSExpressionDescription() 
expressionDescription.name = key 
expressionDescription.expression = maxExpression 
expressionDescription.expressionResultType = .integer64AttributeType 

request.propertiesToFetch = [expressionDescription] 

var maxTimestamp: Int64? = nil 

do { 

    if let result = try self.moc.fetch(request) as? [[String: Int64]], let dict = result.first { 
     maxTimestamp = dict[key] 
    } 

} catch { 
    assertionFailure("Failed to fetch max timestamp with error = \(error)") 
    return nil 
} 

return maxTimestamp 
} 

dove moc è un NSManagedObjectContext.

Answer 5

Swift 3

let request:NSFetchRequest = Person.fetchRequest() 

let sortDescriptor1 = NSSortDescriptor(key: "personId", ascending: false) 

request.sortDescriptors = [sortDescriptor1] 

request.fetchLimit = 1 

do { 
    let persons = try context.fetch(request) 
    return persons.first?.personId 
} catch { 
    print(error.localizedDescription) 
}