Estou trabalhando em um aplicativo de aprendizado no estilo de cartão flash para iOS que, em carga, precisa obter um monte de dados do Core Data. Mas os dados que preciso são de um subconjunto bastante específico da entidade, com base nas configurações do usuário, para que haja vários predicados envolvidos na equivalência de testes. Estou achando que essas buscas são muito lentas e, com base em pesquisas sobre SQLite, acho que um índice seria uma boa escolha aqu

Agora, eu entendo (principalmente através da leitura de outras perguntas sobre stackoverflow) que SQLite e Core Data são duas coisas diferentes, basicamente ortogonais, que não devem ser confundidas. Mas também entendo que você deve trabalhar com o Core Data para executar qualquer tipo de trabalho e aprimoramento no banco de dados; não tente ignorar e trabalhar diretamente com o SQLite ao otimizar ou projetar a permanência de objetos no seu aplicativo.

Mas a única coisa que posso encontrar para índices no Core Data é que uma caixa de seleção "indexada" para cada atributo em um modelo. E isso simplesmente não está fazendo o tipo de otimização que estou procurando.

Aqui está a solicitação de busca, atualmente:

NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
NSEntityDescription *entity = [NSEntityDescription entityForName:@"SKUserItem" inManagedObjectContext:context];
fetchRequest.entity = entity;

NSSortDescriptor *sortDescriptor = [[[NSSortDescriptor alloc] initWithKey:@"next" ascending:YES] autorelease];
fetchRequest.sortDescriptors = [NSArray arrayWithObject:sortDescriptor];

NSMutableArray *predicates = [NSMutableArray arrayWithCapacity:6];
[predicates addObject:[NSPredicate predicateWithFormat:@"next < %f", now() + (60.0*60.0*24.0)]];
[predicates addObject:[NSPredicate predicateWithFormat:@"next > %f", nextOffset]];
[predicates addObject:[NSPredicate predicateWithFormat:@"user == %@", user]];
[predicates addObject:[NSPredicate predicateWithFormat:@"langRaw == %d", lang]];

NSArray *stylePredicates = [NSArray arrayWithObjects:[NSPredicate predicateWithFormat:@"styleRaw == %d", SK_SIMP_AND_TRAD], [NSPredicate predicateWithFormat:@"styleRaw == %d", self.style], nil];
[predicates addObject:[NSCompoundPredicate orPredicateWithSubpredicates:stylePredicates]];

if([self.parts count] == 4 || (self.lang == SK_JA && [self.parts count] == 3))
    ;  // don't have to filter by parts; they're studying all of them
else {
    NSMutableArray *partPredicates = [NSMutableArray arrayWithCapacity:[self.parts count]];
    for(NSString *part in self.parts)
        [partPredicates addObject:[NSPredicate predicateWithFormat:@"partRaw == %d", partCode(part)]];
    [predicates addObject:[NSCompoundPredicate orPredicateWithSubpredicates:partPredicates]];
}

NSPredicate *compoundPredicate = [NSCompoundPredicate andPredicateWithSubpredicates:predicates];
fetchRequest.predicate = compoundPredicate;

Então, basicamente, o que essa busca faz é classificar por próxima (a hora em que o item em questão é devido) e filtrar o nome de usuário, o idioma que está sendo estudado, o estilo que está sendo estudado (em chinês, simplificado e tradicional) e as partes que estão sendo estudadas (escrita, tom, leitura ou definição) e buscar apenas dentro de um intervalo "próximo". Aqui está uma pequena lista de coisas que aprendi ao ajustar e mexer com isso:

Sempre verifica a tabela inteira ou parece. Embora o próximo seja indexado, mesmo que eu o force a procurar um intervalo que sei que não retornará nada, ainda levará alguns segundos para que a busca seja concluíd Os predicados, qualquer número de predicados, tornam isso lento. Se eu remover alguns, mas não todos, é quase tão lento. Se eu remover todos os predicados (interrompendo o aplicativo), será muito mais rápid A velocidade depende fortemente de quantos itens de usuário existem no total na tabela. Quanto mais itens houver, mais lento será. Algumas pessoas podem ter dezenas de milhares de itens, e é nesse momento que essa busca pode levar até 10 segundos para ser concluída. Isso está causando pausas estranhas no meu aplicativo. O limite superior do próximo valor foi adicionado não porque precisamos dele, mas porque acelera um pouco a busca. Manter a consulta retorna um subconjunto das propriedades em um dicionário (em vez de um objeto gerenciado inteiro) e buscar o restante preguiçosamente é mais rápido, mas ainda não rápido o suficient

Eu venho do Google App Engine aqui, por isso estou acostumado aos índices que eles fornecem lá. Essencialmente, eu quero esse tipo de índice, mas aplicado ao SQLite através do Core Data. Encontrei informações sobre como adicionar índices no SQLite, do tipo que gostaria, mas, ao fazer esse tipo de indexação pelo Core Data, não consigo encontrar nenhuma informação sobre iss