O modelo usado para abrir a loja é incompatível com o modelo usado para criar a loja

Criei um modelo de dados principais no xcode 3.2 e, depois de atualizar o Xcode 4.2, adicionei uma nova entidade da subclasse NSManagedObject (consulte a nova entidade).

Primeiro, parece estranho porque não faz parte do mesmo grupo que o antigo. Aqui está a figura no meu xcode 4.2 (o AlkitabDB é o que eu criei no xcode 3.2, o EndeDB é o novo da versão atual do xcode (4.2):

Segundo, deixei como está, então acessei a segunda entidade (a nova) da mesma maneira que a primeira entidade (a antiga), e o erro como título aparece.

Aqui está o erro:

2012-01-16 21:13:38.496 iHuria[55953:207] Unresolved error Error Domain=NSCocoaErrorDomain Code=134100 "The operation couldn’t be completed. (Cocoa error 134100.)" UserInfo=0x8829cd0 {metadata=<CFBasicHash 0x882a370 [0x1839b38]>{type = immutable dict, count = 7,
entries =>
    2 : <CFString 0x8829b90 [0x1839b38]>{contents = "NSStoreModelVersionIdentifiers"} = <CFArray 0x8829ff0 [0x1839b38]>{type = immutable, count = 0, values = ()}
    4 : <CFString 0x8829bc0 [0x1839b38]>{contents = "NSPersistenceFrameworkVersion"} = <CFNumber 0x8829770 [0x1839b38]>{value = +320, type = kCFNumberSInt64Type}
    6 : <CFString 0x8829bf0 [0x1839b38]>{contents = "NSStoreModelVersionHashes"} = <CFBasicHash 0x882a080 [0x1839b38]>{type = immutable dict, count = 1,
entries =>
    0 : <CFString 0x882a010 [0x1839b38]>{contents = "AlkitabDB"} = <CFData 0x882a030 [0x1839b38]>{length = 32, capacity = 32, bytes = 0xd02ac5f8be6ab0b39add450aca202ac0 ... 3d45d462998d2ccd}
}

    7 : <CFString 0x10e3aa8 [0x1839b38]>{contents = "NSStoreUUID"} = <CFString 0x8829e60 [0x1839b38]>{contents = "4F2EE7FF-463B-4055-BBED-8E603CDBDF59"}
    8 : <CFString 0x10e3948 [0x1839b38]>{contents = "NSStoreType"} = <CFString 0x10e3958 [0x1839b38]>{contents = "SQLite"}
    9 : <CFString 0x8829c40 [0x1839b38]>{contents = "NSStoreModelVersionHashesVersion"} = <CFNumber 0x6b1c7c0 [0x1839b38]>{value = +3, type = kCFNumberSInt32Type}
    10 : <CFString 0x8829c70 [0x1839b38]>{contents = "_NSAutoVacuumLevel"} = <CFString 0x882a0c0 [0x1839b38]>{contents = "2"}
}
, reason=The model used to open the store is incompatible with the one used to create the store}, {
    metadata =     {
        NSPersistenceFrameworkVersion = 320;
        NSStoreModelVersionHashes =         {
            AlkitabDB = <d02ac5f8 be6ab0b3 9add450a ca202ac0 ebd1e860 cbb578c2 3d45d462 998d2ccd>;
        };
        NSStoreModelVersionHashesVersion = 3;
        NSStoreModelVersionIdentifiers =         (
        );
        NSStoreType = SQLite;
        NSStoreUUID = "4F2EE7FF-463B-4055-BBED-8E603CDBDF59";
        "_NSAutoVacuumLevel" = 2;
    };
    reason = "The model used to open the store is incompatible with the one used to create the store";
}

Procurei a solução antes e descobri que deveria remover o aplicativo do simulador e executar novamente o aplicativo, e ele não funcionou. Alguém conhece uma solução para esse problema? Por favor ajude.

A exclusão do aplicativo às vezes não é o caso! Sugira, seu aplicativo já foi publicado! Você não pode simplesmente adicionar uma nova entidade à base de dados e seguir em frente - é necessário executar a migração!

Para aqueles que não querem pesquisar na documentação e estão procurando uma solução rápida:

1. Abra o seu arquivo .xcdatamodeld
2. clique no editor
3. selecione Adicionar versão do modelo ...
4. Adicione uma nova versão do seu modelo (o novo grupo de modelos de dados foi adicionado)
5. selecione o arquivo principal, abra o inspetor de arquivos (painel direito)
6. e em Versioned core data modelselecionar sua nova versão do modelo de dados para o modelo de dados atual
7. Isso não é tudo) Você deve executar a chamada "migração leve".
8. Vá para o seu AppDelegatee encontre onde persistentStoreCoordinatorestá sendo criado
9. Encontre esta linha if (![_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error])
10. Substitua as nilopções por @{NSMigratePersistentStoresAutomaticallyOption:@YES, NSInferMappingModelAutomaticallyOption:@YES}(realmente fornecidas no código comentado nesse método)
11. Aqui está, divirta-se!

PS Isso se aplica apenas à migração leve. Para que sua migração se qualifique como uma migração leve, suas alterações devem estar confinadas a essa faixa estreita:

• Adicione ou remova uma propriedade (atributo ou relacionamento).
• Torne uma propriedade não opcional opcional.
• Torne um atributo opcional não opcional, desde que você forneça um valor padrão.
• Adicione ou remova uma entidade.
• Renomeie uma propriedade.
• Renomeie uma entidade.

Para Swift 4

coordinator.addPersistentStore(ofType: NSSQLiteStoreType, configurationName: nil, at: url, options: [NSMigratePersistentStoresAutomaticallyOption: true, NSInferMappingModelAutomaticallyOption: true])

Remova o aplicativo do simulador e faça uma limpeza no seu projeto. Isso deve esclarecer essas questões. Certifique-se de que você não esteja executando o depurador ao excluir o aplicativo, caso contrário ele não será excluído corretamente.

Se você quiser ter certeza de que foi, verifique este diretório Users/INSERT_YOUR_USER_HERE/Library/Application Support/iPhone Simulator/na pasta do seu aplicativo, na versão que você está executando.

Nota: Isso é apenas para desenvolvimento. Para produção, você precisa implementar algum tipo de migração. Google "Migração de dados principais", com a migração leve sendo a mais simples.

Basta adicionar o atributo Opções ao criar persistentStoreCoordinator no arquivo AppDelegate.m para o método de dados do núcleo, conforme abaixo

OBJETIVO-C

- (NSPersistentStoreCoordinator *)persistentStoreCoordinator
{
    if (_persistentStoreCoordinator != nil)
    {
        return _persistentStoreCoordinator;
    }

    NSLog(@"persistentStoreCoordinator___");
    NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"MyApp.sqlite"];

    NSMutableDictionary *options = [[NSMutableDictionary alloc] init];
    [options setObject:[NSNumber numberWithBool:YES] forKey:NSMigratePersistentStoresAutomaticallyOption];
    [options setObject:[NSNumber numberWithBool:YES] forKey:NSInferMappingModelAutomaticallyOption];

    NSError *error = nil;
    _persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]];
    if (![_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:options error:&error])
    {
        NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
        abort();
    }

    NSLog(@"persistentStoreCoordinator___2");
    return _persistentStoreCoordinator;
}

RÁPIDO

    lazy var persistentStoreCoordinator: NSPersistentStoreCoordinator = {
    // The persistent store coordinator for the application. This implementation creates and returns a coordinator, having added the store for the application to it. This property is optional since there are legitimate error conditions that could cause the creation of the store to fail.
    // Create the coordinator and store
    let coordinator = NSPersistentStoreCoordinator(managedObjectModel: self.managedObjectModel)
    let url = self.applicationDocumentsDirectory.URLByAppendingPathComponent("SingleViewCoreData.sqlite")
    var failureReason = "There was an error creating or loading the application's saved data."

    // MAIN LINE OF CODE TO ADD
    let mOptions = [NSMigratePersistentStoresAutomaticallyOption: true,
                    NSInferMappingModelAutomaticallyOption: true]

    do {
        try coordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: url, options: mOptions)
    } catch {
        // Report any error we got.
        var dict = [String: AnyObject]()
        dict[NSLocalizedDescriptionKey] = "Failed to initialize the application's saved data"
        dict[NSLocalizedFailureReasonErrorKey] = failureReason

        dict[NSUnderlyingErrorKey] = error as NSError
        let wrappedError = NSError(domain: "YOUR_ERROR_DOMAIN", code: 9999, userInfo: dict)
        // Replace this with code to handle the error appropriately.
        // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
        NSLog("Unresolved error \(wrappedError), \(wrappedError.userInfo)")
        abort()
    }

    return coordinator
}

Ele resolveu o meu problema ..

Resposta: remova o aplicativo do simulador, execute uma limpeza e reconstrua seu projeto.

Nota: Sempre que você executar alterações na definição de Dados Principais, exclua o aplicativo instalado no Dispositivo Físico ou Simulador, Limpe o Projeto e Reconstrua novamente.

Sim. Depois de excluir o aplicativo no dispositivo físico e reconstruí-lo, ele funciona.

Para swift, em AppDelegate.swift encontre a linha

try coordinator!.addPersistentStoreWithType(NSXMLStoreType, configuration:  nil, URL: url, options: nil )

e substitua-o por

try coordinator!.addPersistentStoreWithType(NSXMLStoreType, configuration: nil, URL: url, options: [NSMigratePersistentStoresAutomaticallyOption: true, NSInferMappingModelAutomaticallyOption: true])

Passei vários dias lutando contra esse erro, bem como as falhas mescladas de ModelFromBundles e obtendo o erro "Não é possível mesclar modelos com duas entidades diferentes nomeadas *".

O problema principal é que o Xcode não remove recursos antigos dos dispositivos e eu tinha versões antigas do meu modelo de dados (arquivos .mom) que estavam causando conflitos. Por isso, a exclusão do aplicativo corrigiu o problema em um dos meus dispositivos.

Depois de encontrar esta postagem no blog por meio de outra resposta do SO, tornei meu aplicativo mais tolerante com os modelos antigos, alterando esta linha que procura TODOS os arquivos .mom:

NSManagedObjectModel *model = [NSManagedObjectModel mergedModelFromBundles:nil];

para isso, que apenas procura no diretório Filtros:

NSString *path = [[NSBundle mainBundle] pathForResource:@"Filters" ofType:@"momd"];
NSURL *momURL = [NSURL fileURLWithPath:path];
NSManagedObjectModel *model = [[NSManagedObjectModel alloc] initWithContentsOfURL:momURL];

Usei recursivePathsForResourcesOfType a partir desta pergunta : para ajudar a descobrir isso registrando todos os arquivos .mom no aplicativo:

NSArray *momPaths = [self recursivePathsForResourcesOfType:@"mom" inDirectory:[[NSBundle mainBundle] resourcePath]];
NSLog(@"All .mom files:%@",momPaths);

Também usei o iExplorer para examinar os arquivos .mom estranhos (ainda não tentei excluí-los).

O método abaixo também foi útil. Ele mostrou que uma entidade estava no modelo mesclado retornado por [psc managedObjectModel] que não existia mais em nenhum dos meus modelos ou na própria loja. Foi isso que me permitiu acreditar que um modelo antigo estava sendo armazenado em cache no próprio dispositivo, que a construção limpa não removeu. O método registra cada entidade que é a mesma, foi alterada, adicionada ou removida do modelo. (escrito com esta resposta do SO como ponto de partida):

- (BOOL)comparePersistentStore:(NSPersistentStoreCoordinator *)psc withStoreURL: (NSURL *)storeURL {
    NSError *error = nil;

    // Get the entities & keys from the persistent store coordinator
    NSManagedObjectModel *pscModel = [psc managedObjectModel];
    NSDictionary *pscEntities = [pscModel entitiesByName];
    NSSet *pscKeys = [NSSet setWithArray:[pscEntities allKeys]];
    //NSLog(@"psc model:%@", pscModel);
    //NSLog(@"psc keys:%@", pscKeys);
    NSLog(@"psc contains %d entities", [pscModel.entities count]);

    // Get the entity hashes from the storeURL
    NSDictionary *storeMetadata = [NSPersistentStoreCoordinator metadataForPersistentStoreOfType:NSSQLiteStoreType
                                                                                          URL:storeURL
                                                                                        error:&error];
    NSDictionary *storeHashes = [storeMetadata objectForKey:@"NSStoreModelVersionHashes"];
    //NSLog(@"store metadata:%@", sourceMetadata);
    NSLog(@"store URL:%@", storeURL);
    NSLog(@"store NSStoreUUID:%@", [storeMetadata objectForKey:@"NSStoreUUID"]);
    NSLog(@"store NSStoreType:%@", [storeMetadata objectForKey:@"NSStoreType"]);
    NSSet *storeKeys = [NSSet setWithArray:[storeHashes allKeys]];

    // Determine store entities that were added, removed, and in common (to/with psc)
    NSMutableSet *addedEntities = [NSMutableSet setWithSet:pscKeys];
    NSMutableSet *removedEntities = [NSMutableSet setWithSet:storeKeys];
    NSMutableSet *commonEntities = [NSMutableSet setWithSet:pscKeys];
    NSMutableSet *changedEntities = [NSMutableSet new];
    [addedEntities minusSet:storeKeys];
    [removedEntities minusSet:pscKeys];
    [commonEntities minusSet:removedEntities];
    [commonEntities minusSet:addedEntities];

    // Determine entities that have changed (with different hashes)
    [commonEntities enumerateObjectsUsingBlock:^(NSString *key, BOOL *stop) {
        NSData *storeHash = [storeHashes objectForKey:key];
        NSEntityDescription *pscDescrip = [pscEntities objectForKey:key];
        if ( ! [pscDescrip.versionHash isEqualToData:storeHash]) {
            if (storeHash != nil && pscDescrip.versionHash != nil) {
                [changedEntities addObject:key];
            }
        }
    }];

    // Remove changed entities from common list
    [commonEntities minusSet:changedEntities];

    if ([commonEntities count] > 0) {
        NSLog(@"Common entities:");
        [commonEntities enumerateObjectsUsingBlock:^(NSString *key, BOOL *stop) {
            NSData *storeHash = [storeHashes objectForKey:key];
            NSEntityDescription *pscDescrip = [pscEntities objectForKey:key];
            NSLog(@"\t%@:\t%@", key, pscDescrip.versionHash);
        }];
    }
    if ([changedEntities count] > 0) {
        NSLog(@"Changed entities:");
        [changedEntities enumerateObjectsUsingBlock:^(NSString *key, BOOL *stop) {
            NSData *storeHash = [storeHashes objectForKey:key];
            NSEntityDescription *pscDescrip = [pscEntities objectForKey:key];
            NSLog(@"\tpsc   %@:\t%@", key, pscDescrip.versionHash);
            NSLog(@"\tstore %@:\t%@", key, storeHash);
    }];
    }
    if ([addedEntities count] > 0) {
        NSLog(@"Added entities to psc model (not in store):");
        [addedEntities enumerateObjectsUsingBlock:^(NSString *key, BOOL *stop) {
            NSEntityDescription *pscDescrip = [pscEntities objectForKey:key];
            NSLog(@"\t%@:\t%@", key, pscDescrip.versionHash);
        }];
    }
    if ([removedEntities count] > 0) {
        NSLog(@"Removed entities from psc model (exist in store):");
        [removedEntities enumerateObjectsUsingBlock:^(NSString *key, BOOL *stop) {
            NSData *storeHash = [storeHashes objectForKey:key];
            NSLog(@"\t%@:\t%@", key, storeHash);
        }];
    }

    BOOL pscCompatibile = [pscModel isConfiguration:nil     compatibleWithStoreMetadata:storeMetadata];
    NSLog(@"Migration needed? %@", pscCompatibile?@"no":@"yes");

    return pscCompatibile;
}

use: chamado antes de adicionar cada loja ao NSPersistentStoreCoordinator:

    [self comparePersistentStore:self.psc withStoreURL:self.iCloudStoreURL];
    _iCloudStore = [self.psc addPersistentStoreWithType:NSSQLiteStoreType
                                          configuration:nil
                                                    URL:self.iCloudStoreURL
                                                options:options
                                                  error:&localError];

Toda vez que você fizer alterações na definição da Data Principal, exclua os aplicativos instalados no dispositivo ou simulador físico.

1. Pare a execução do aplicativo.
2. Excluir aplicativo no simulador.
3. Product -> Clean
4. Construa, corra.

A solução mais simples que funcionou para mim no Swift 2.1, Xcode 7 é:

1. Exclua o aplicativo do simulador (Cmd + Shift + H para ir para a tela inicial. Pressione e segure o aplicativo, clique em cruz, da maneira usual como excluir um aplicativo do seu telefone)

2. Cmd + Shift + H novamente para parar a dança dos aplicativos

3. Volte ao seu projeto e execute novamente

Eu tive esse problema ao escrever / ler o Core Data com 2 entidades configuradas. Excluir o aplicativo e executar novamente o programa corrigiu o problema

Acabei de excluir o [Simulator App Folder]/Document/*.sqlitearquivo depois de fazer alterações nas entidades e funcionou. E, é claro, o arquivo .sqlite contém todos os dados e estruturas armazenados que serão perdidos.

Por favor, apague um aplicativo do simulador e limpe um código e execute.

Se você estiver usando o Swift.

Siga a resposta em @Stas e insira as opções, no lugar de zero, em seu App Delegate:

let myOptions = [NSMigratePersistentStoresAutomaticallyOption: true,
            NSInferMappingModelAutomaticallyOption: true]
        if coordinator!.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: url, options: myOptions, error: &error) == nil {

Tente "Redefinir conteúdo e configurações" no simulador. Trabalhou para mim depois de excluir o aplicativo e a compilação limpa

Eu tive o mesmo problema com meu aplicativo (ainda não lançado na App Store).

Aqui está como eu o consertei:

1. Executar limpo (Cmd + Shift + K)
2. Reinicie o iOS Simulator
3. Simulador iOS -> Redefinir conteúdo e configurações (na barra de navegação)

(3) foi o passo que finalmente conseguiu que ele funcionasse corretamente. Espero que isto ajude!

Embora às vezes você possa remover o aplicativo do dispositivo ao alterar o esquema no modelo de objeto gerenciado, em alguns cenários isso não é possível, por exemplo, porque você já publicou seu aplicativo com um esquema antigo.

Se for esse o caso, você deve cuidar da migração de dados antigos para o novo esquema:

Versão do modelo de dados principais e migração de dados

Você precisará migrar o modelo de Dados Principais usando a migração. Sempre que você altera o modelo, torna-o incompatível sem controle de versão. Prenda-se, é um assunto meio peludo.

http://developer.apple.com/library/ios/#documentation/cocoa/Conceptual/CoreDataVersioning/Articles/Introduction.html

Se você fizer alterações no modelo do Core Data, precisará fornecer uma política de migração que informe ao Core Data como adotar objetos persistentes existentes (criados por seus usuários com a versão lançada no momento) para o novo modelo.

Para alguns cenários, o Core Data pode inferir automaticamente o mapeamento do modelo antigo para o novo. Para alterações mais complexas, pode ser necessário implementar alguma lógica que execute a migração.

Detalhes podem ser encontrados no Guia de Programação de Versão do Modelo de Dados Principais e Migração de Dados .

Atualizar
Esta resposta aqui no Stack Overflow aborda os conceitos básicos da migração leve do Core Data e também possui algum código para você começar.

Esse problema geralmente ocorre devido à incompatibilidade entre a versão na qual o banco de dados foi criado. A abordagem geral para esse problema é excluir o aplicativo e reinstalá- lo. Mas no seu caso mencionado, a versão do DB é completamente diferente no Xcode 3.2 e 4.2. Então, é melhor usar a mesma versão do Xcode for DB.

Primeiro, as únicas coisas que devem estar no xcdatamodeldpacote são os xcdatamodelarquivos. Suas subclasses NÃO devem estar na xcdatamodeld. Mova aqueles para fora de lá. Há uma boa chance de que eles estejam confundindo o compilador.

Segundo, o erro indica que o Core Data não consegue encontrar o seu modelo. Você criou dados e depois tocou no modelo? Nesse caso, você está em um estado inconsistente e precisa corrigi-lo excluindo os dados (sugerido por Philippe) ou revertendo suas alterações no modelo BACK .

Eu estava recebendo o erro, mas o motivo pelo qual estava recebendo o erro era o seguinte.

Originalmente, eu tinha uma Entidade chamada "Entrada" e tinha uma linha salva para essa entidade no banco de dados. Adicionei outra Entidade chamada "Person" e, depois de adicionar, fui criar e obtive o erro. Então, resolvi o problema excluindo a entidade "Pessoa" e, em seguida, criando o aplicativo, excluí a linha que estava em "Entrada" e fechei o aplicativo. Excluí o aplicativo totalmente do meu telefone e, em seguida, fiz uma reconstrução e funcionou bem. Não tenho certeza de qual etapa corrigiu o problema (a exclusão da linha ou do aplicativo), mas espero que, se você esteja procurando uma solução, isso ajude. :)

Edit: Ah, e se você se preocupou em excluir sua nova Entidade (no meu caso "Pessoa") para criar o aplicativo novamente, lembre-se de que você poderá recuperá-lo novamente usando CMD + Z!

Eu tive esse problema - primeiro redefini meu simulador e depois limpei o projeto e reconstruí-lo. E então funciona.

Quando você altera os dados principais (adicionando um campo à tabela, removendo o campo etc.), o arquivo sqlite na pasta de documentos do aplicativo precisa estar sincronizado com o seu esquema.

Este arquivo não é substituído por padrão, ele precisa ser regenerado.

Siga esses passos:

1. Vá para a pasta apontada por NSURL. (Esse caminho pode ser encontrado na mensagem de exceção gerada pelo aplicativo antes de travar.) Exemplo: / Usuários // Biblioteca / Suporte a aplicativos / iPhone Simulator // Aplicativos // Documentos

2. remover ou renomear o arquivo sqlite

3. Limpe e execute novamente o aplicativo
4. A nova execução do aplicativo geraria um novo arquivo sqlite.

Isso garantirá que o esquema e o Xcode estejam sincronizados.

Para desenvolvimento de aplicativos para mac:

1. Limpe o projeto
2. Limpar dados derivados
3. Vá para / Users / YOUR_NAME / Library / Containers / YOUR_APP_BUNDLE_ID / Data / Documents / e exclua todos os arquivos internos (como ".sqlite", ".sqlite-shm" ...)

Funcionou para mim, espero que isso possa ser útil.

Simulador iOS -> Redefinir conteúdo e configurações ...

Trabalhou para mim

Simulador iOS -> Redefinir conteúdo e configurações ... -> Redefinir também funciona no iOS9 (xcode 7.1)