Il modello utilizzato per aprire il negozio non è compatibile con quello utilizzato per creare il negozio

Ho creato un modello Core Data in xcode 3.2 e dopo l'aggiornamento in Xcode 4.2, ho quindi aggiunto una nuova entità della sottoclasse NSManagedObject (fare riferimento alla nuova entità).

Per prima cosa, sembra strano perché non è nello stesso gruppo di quello vecchio. Ecco l'immagine sul mio xcode 4.2 (AlkitabDB è quello che ho creato in xcode 3.2, EndeDB è quello nuovo dall'attuale versione di xcode (4.2):

La seconda cosa, l'ho lasciata così com'è, quindi ho avuto accesso alla seconda entità (la nuova) allo stesso modo della prima entità (la vecchia), e appare l'errore come intitolato.

Ecco l'errore:

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";
}

Prima ho cercato la soluzione e ho scoperto che avrei dovuto rimuovere l'applicazione dal simulatore e rieseguire l'app, e non ha funzionato. Qualcuno conosce una soluzione per questo problema? Per favore aiuto.

L'eliminazione dell'app a volte non è il caso! Suggerisci, la tua app è già stata pubblicata! Non puoi semplicemente aggiungere una nuova entità alla base di dati e andare avanti - devi eseguire la migrazione!

Per coloro che non vogliono scavare nella documentazione e sono alla ricerca di una soluzione rapida:

1. Apri il tuo file .xcdatamodeld
2. fai clic su Editor
3. seleziona Aggiungi versione modello ...
4. Aggiungi una nuova versione del tuo modello (aggiunto il nuovo gruppo di modelli di dati)
5. seleziona il file principale, apri la finestra di ispezione dei file (pannello di destra)
6. e in Versioned core data modelselezionare la nuova versione del modello di dati per il modello di dati corrente
7. NON È TUTTO) Dovresti eseguire la cosiddetta "migrazione leggera".
8. Vai al tuo AppDelegatee trova dove persistentStoreCoordinatorviene creato
9. Trova questa linea if (![_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error])
10. Sostituisci le nilopzioni con @{NSMigratePersistentStoresAutomaticallyOption:@YES, NSInferMappingModelAutomaticallyOption:@YES}(effettivamente fornito nel codice commentato in quel metodo)
11. Ecco qua, divertiti!

PS Questo vale solo per la migrazione leggera. Affinché la tua migrazione sia qualificata come migrazione leggera, le tue modifiche devono essere limitate a questa banda ristretta:

• Aggiungi o rimuovi una proprietà (attributo o relazione).
• Rendi facoltativa una proprietà non facoltativa.
• Rendere non facoltativo un attributo, purché si fornisca un valore predefinito.
• Aggiungi o rimuovi un'entità.
• Rinomina una proprietà.
• Rinomina un'entità.

Per Swift 4

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

Rimuovi l'app dal simulatore ed esegui un clean sul tuo progetto. Ciò dovrebbe chiarire questi problemi. Assicurati di non essere in esecuzione nel debugger quando elimini l'app altrimenti non la eliminerà correttamente.

Se vuoi essere sicuro che sia sparito, controlla questa directory Users/INSERT_YOUR_USER_HERE/Library/Application Support/iPhone Simulator/per la cartella della tua app, nella versione in esecuzione.

Nota: questo è solo per lo sviluppo. Per la produzione, è necessario implementare una sorta di migrazione. Google "Core Data Migration", con la migrazione leggera la più semplice.

Aggiungi l' attributo Opzioni durante la creazione di persistentStoreCoordinator nel file AppDelegate.m per il metodo dei dati di base come di seguito

Objective-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;
}

SWIFT

    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
}

Aveva risolto il mio problema ..

Risposta: Rimuovi l'app dal simulatore, esegui un clean e ricostruisci il tuo progetto.

Nota: ogni volta che si apportano modifiche alla definizione dei dati principali, eliminare l'app installata sul dispositivo fisico o sul simulatore, pulire il progetto e ricostruire nuovamente.

Sì. Una volta eliminata l'app sul dispositivo fisico e ricostruita, funziona.

Per swift, in AppDelegate.swift trova la riga

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

e sostituirlo con

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

Ho appena trascorso diversi giorni a combattere questo errore, oltre agli arresti anomali di mergedModelFromBundles e ottenere l'errore "Impossibile unire i modelli con due entità diverse denominate *".

Si scopre che il problema alla radice era che Xcode non rimuoveva le vecchie risorse dai dispositivi e avevo vecchie versioni del mio modello di dati (file .mom) che causavano conflitti. Ecco perché l'eliminazione dell'app ha risolto il problema su uno dei miei dispositivi.

Dopo aver trovato questo post sul blog tramite un'altra risposta SO, ho reso la mia app più tollerante rispetto ai vecchi modelli cambiando questa linea che cerca TUTTI i file .mom:

NSManagedObjectModel *model = [NSManagedObjectModel mergedModelFromBundles:nil];

a questo, che appare solo nella directory dei filtri:

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

Ho usato recursivePathsForResourcesOfType da questa domanda : per aiutare a capirlo registrando tutti i file .mom nell'app:

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

Ho anche usato iExplorer per esaminare i file .mom estranei (non ho ancora provato a eliminarli).

Anche il metodo seguente è stato utile. Ha dimostrato che un'entità si trovava nel modello unito restituito da [psc managedObjectModel] che non esisteva più in nessuno dei miei modelli o nel negozio stesso. Questo è ciò che mi ha fatto credere che un vecchio modello fosse memorizzato nella cache sul dispositivo stesso che l'edificio pulito non ha rimosso. Il metodo registra ogni entità uguale, modificata, aggiunta o rimossa dal modello. (scritto con questa risposta SO come punto di partenza):

- (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;
}

utilizzo: chiamato prima di aggiungere ogni negozio a NSPersistentStoreCoordinator:

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

Ogni volta che si modifica la definizione della data principale, è necessario eliminare le app installate sul dispositivo fisico o sul simulatore.

1. Interrompi l'esecuzione dell'app.
2. Elimina app sul simulatore.
3. Product -> Clean
4. Costruisci, corri.

La soluzione più semplice che ha funzionato per me in Swift 2.1, Xcode 7 è:

1. Elimina l'app dal simulatore (Cmd + Maiusc + H per accedere alla schermata principale. Premi a lungo l'app, fai clic su croce, proprio come al solito elimini un'app dal telefono)

2. Cmd + Maiusc + H di nuovo per interrompere la danza delle app

3. Torna al tuo progetto ed esegui nuovamente

Ho avuto questo problema durante la scrittura / lettura da Core Data con 2 entità configurate. L'eliminazione dell'app e la riesecuzione del programma hanno risolto il problema

Ho appena eliminato il [Simulator App Folder]/Document/*.sqlitefile dopo aver apportato modifiche alle entità e ha funzionato. E, naturalmente, il file .sqlite contiene tutti i dati e le strutture memorizzati che andranno persi.

Elimina un'applicazione dal simulatore e pulisci un codice ed esegui .it funziona bene. Potrebbe essere il tuo aiuto.

Se stai usando Swift.

Segui la risposta di @Stas e inserisci le opzioni, al posto di zero, nel tuo delegato app:

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

Prova "Ripristina contenuto e impostazioni" nel simulatore. Ha funzionato per me dopo aver eliminato l'app e Clean build

Ho riscontrato lo stesso problema con la mia app (non ancora rilasciata nell'App Store).

Ecco come l'ho risolto:

1. Run Clean (Cmd + Maiusc + K)
2. Riavvia il simulatore iOS
3. Simulatore iOS -> Ripristina contenuto e impostazioni (dalla barra di navigazione)

(3) è stato il passaggio che alla fine è riuscito a funzionare correttamente. Spero che questo ti aiuti!

Anche se a volte puoi semplicemente rimuovere l'app dal dispositivo quando modifichi lo schema nel modello a oggetti gestiti, in alcuni scenari ciò non è possibile, ad esempio perché hai già pubblicato l'app con un vecchio schema.

In questo caso, devi occuparti della migrazione dei vecchi dati nel nuovo schema:

Core Data Model Modeling e migrazione dei dati

Dovrai migrare il modello di dati di base utilizzando la migrazione. Ogni volta che modifichi il modello, lo rendi incompatibile senza il controllo delle versioni. Allacciati, è un po 'un argomento peloso.

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

Se si apportano modifiche al modello Core Data, è necessario fornire una politica di migrazione che indichi a Core Data come adottare oggetti persistenti esistenti (creati dagli utenti con la versione attualmente rilasciata) nel nuovo modello.

Per alcuni scenari, Core Data è in grado di inferire automaticamente la mappatura dal vecchio modello a quello nuovo. Per modifiche più complesse, potrebbe essere necessario implementare alcune logiche che eseguono la migrazione.

I dettagli sono disponibili nella Guida alla programmazione della versione del modello dei dati di base e della migrazione dei dati .

Aggiorna
Questa risposta qui su Stack Overflow copre le basi della migrazione leggera di Core Data e ha anche del codice per iniziare.

Questo problema si verifica in genere a causa dell'incompatibilità tra la versione su cui è stato creato il DB . L'approccio generale a questo problema è eliminare l'app e reinstallarla . Ma nel tuo caso menzionato la versione di DB è completamente diversa su Xcode 3.2 e 4.2. Quindi meglio usare la stessa versione di Xcode per DB.

Innanzitutto, le uniche cose che dovrebbero essere nel xcdatamodeldbundle sono i xcdatamodelfile. Le sottoclassi NON devono essere presenti in xcdatamodeld. Sposta quelli fuori di lì. C'è una buona probabilità che stiano confondendo il compilatore.

In secondo luogo, l'errore indica che i dati principali non riescono a trovare il modello. Hai creato dati e poi toccato il modello? In tal caso, si è in uno stato incoerente e è necessario risolverlo eliminando i dati (suggeriti da Philippe) o eseguendo il rollback delle modifiche del modello INDIETRO .

Stavo ottenendo l'errore ma il motivo per cui stavo ottenendo l'errore era a causa di quanto segue.

Inizialmente avevo un'entità denominata "Voce" e una riga salvata per quell'entità nel database. Ho quindi aggiunto un'altra Entità denominata "Persona" e dopo aver aggiunto quella è andata a compilare e ho ricevuto l'errore. Quindi ho risolto il problema eliminando l'Entità "Persona" e quindi creando l'app, cancellando la riga che si trovava in "Voce" e quindi chiudendo l'applicazione. Ho quindi eliminato l'app completamente dal mio telefono e poi ho fatto una ricostruzione e ha funzionato bene. Non sono sicuro di quale passaggio abbia corretto il problema (l'eliminazione della riga o dell'app), ma spero che se stai cercando una soluzione, questo ti aiuterà. :)

Modifica: Oh, e se ti preoccupi di cancellare la tua nuova Entità (nel mio caso "Persona") per costruire di nuovo l'app, ricorda che puoi recuperarla in seguito usando CMD + Z!

Ho avuto questo problema: ho prima resettato il mio simulatore e poi pulito il progetto e ricostruito. E poi funziona.

Quando si modificano i dati principali, (aggiungendo un campo alla tabella, rimuovendo un campo ecc.), Il file sqlite nella cartella documenti delle applicazioni deve essere sincronizzato con lo schema.

Questo file non viene sovrascritto per impostazione predefinita, questo file deve essere rigenerato.

Segui questi passi:

1. Vai alla cartella indicata da NSURL. (Questo percorso può essere trovato nel messaggio di eccezione generato dall'applicazione prima dell'arresto anomalo.) Esempio: / Utenti // Libreria / Supporto applicazioni / Simulatore iPhone // Applicazioni // Documenti

2. rimuovere o rinominare il file sqlite

3. Pulisci ed esegui nuovamente l'applicazione
4. La nuova esecuzione dell'applicazione genererebbe un nuovo file sqlite.

Ciò assicurerà che lo schema e l'Xcode siano sincronizzati.

Per lo sviluppo di app per Mac:

1. Pulisci il progetto
2. Pulisci i dati derivati
3. Vai su / Users / YOUR_NAME / Library / Containers / YOUR_APP_BUNDLE_ID / Data / Documents / ed elimina tutti i file all'interno (come ".sqlite", ".sqlite-shm" ...)

Ha funzionato per me, spero che questo possa essere utile.

Simulatore iOS -> Ripristina contenuti e impostazioni ...

Ha funzionato per me

Simulatore iOS -> Ripristina contenuti e impostazioni ... -> Ripristina Funziona anche su iOS9 (xcode 7.1)