CRUD-Operationen (Create, Remove, Update, Delete) ausführen

Sie können den Inhalt eines Datastore modifizieren.

Informationen zu diesem Vorgang

Weitere Details zu CRUD-Operationen (Create, Retrieve, Update, Delete) finden Sie in der Dokumentation unter CDTDatastore CRUD.

Informationen zu CRUD-Operationen (Create, Retrieve, Update, Delete) für einen fernen Store finden Sie in der Beschreibung der Cloudant-Dokumente.

Übergeordnetes Thema: Mobile Daten für die App-Migration mit dem IMFData- oder Cloudant-SDK in Cloudant speichern

Daten erstellen

Vorgehensweise

Daten speichern:

AndroidVORHER (mit IMFData/CloudantToolkit):

// Vorhandenen Store verwenden
CDTStore *store = existingStore;

// Zu speicherndes Fahrzeug erstellen
Automobile *automobile = [[Automobile alloc] initWithMake:@"Toyota" model:@"Corolla" year: 2006];

[store save:automobile completionHandler:^(id savedObject, NSError *error) {
    if (error) {
        // Speichern fehlgeschlagen, Handler hat einen Fehler empfangen
    } else {
        // Ergebnis verwenden
        Automobile *savedAutomobile = savedObject;
        NSLog(@"saved revision: %@", savedAutomobile);
    }
}];
 // Vorhandenen Store verwenden
let store:CDTStore = existingStore

// Zu speicherndes Objekt erstellen
let automobile = Automobile(make: "Toyota", model: "Corolla", year: 2006)

store.save(automobile, completionHandler: { (savedObject:AnyObject!, error:NSError!) -> Void in
    if nil != error {
        // Speichern fehlgeschlagen, Handler hat einen Fehler empfangen
    } else {
        // Ergebnis verwenden
        print("Saved revision: \(savedObject)")
    }
})
Android
// Vorhandenen Store verwenden
Store store = existingStore;

// Zu speicherndes Objekt erstellen
Automobile automobile = new Automobile("Toyota", "Corolla", 2006);

// Fahrzeug im Store speichern
Task<Object> saveTask = store.save(automobile); 
saveTask.continueWith(new Continuation<Object, Void>() {
    @Override
    public Void then(Task<Object> task) throws Exception {
        if (task.isFaulted()) {
            // Speichern nicht erfolgreich. Fehler ist in task.getError() enthalten.
        } else {
            // Ergebnis verwenden
            Automobile savedAutomobile = (Automobile) task.getResult();
        }
        return null;
    }
});
AndroidNACHHER (mit Cloudant Sync): 
// Vorhandenen Store verwenden
CDTDatastore *datastore = existingDatastore;

// Dokumenthauptteil erstellen
CDTMutableDocumentRevision * revision = [CDTMutableDocumentRevision revision];
revision.body = @{@"@datatype" : @"Automobile", @"make" :@"Toyota", @"model": @"Corolla", @"year" : @2006};

NSError* error = nil;
CDTDocumentRevision *createdRevision = [datastore createDocumentFromRevision:revision error:&error];

if (error) {
    // Speichern fehlgeschlagen, Handler hat einen Fehler empfangen
} else {
    // Ergebnis verwenden
    NSLog(@"Revision: %@", createdRevision);
}
// Vorhandenen Store verwenden
let datastore:CDTDatastore = existingDatastore

// Dokumenthauptteil erstellen
let revision = CDTMutableDocumentRevision()
revision.setBody(["make":"Toyota","model":"Corolla","year":2006])

var createdRevision:CDTDocumentRevision?
do{
    createdRevision = try datastore.createDocumentFromRevision(revision)
    NSLog("Revision: \(createdRevision)");
}catch let error as NSError{
    // Fehler behandeln
}
Android
// Vorhandenen Store verwenden
Datastore datastore = existingStore;

// Dokumenthauptteil erstellen
Map<String, Object> body = new HashMap<String, Object>();
body.put("@datatype", "Automobile");
body.put("make", "Toyota");
body.put("model", "Corolla");
body.put("year", 2006);

// Überarbeitung erstellen und Hauptteil festlegen
MutableDocumentRevision revision  = new MutableDocumentRevision();
revision.body = DocumentBodyFactory.create(body);

// Überarbeitung im Store speichern
DocumentRevision savedRevision = datastore.createDocumentFromRevision(revision);

Daten lesen

Sie können Daten abrufen.

Vorgehensweise

Daten lesen:
AndroidVORHER (mit IMFData/CloudantToolkit):
CDTStore *store = existingStore;
NSString *automobileId = existingAutomobileId;

// Fahrzeug aus dem Store abrufen
[store fetchById:automobileId completionHandler:^(id object, NSError *error) {
    if (error) {
        // Abrufen fehlgeschlagen, Handler hat einen Fehler empfangen
    } else {
        // Ergebnis verwenden
        Automobile *savedAutomobile = object;
        NSLog(@"fetched automobile: %@", savedAutomobile);
    }
}];
// Vorhandenen Store und vorhandenes Fahrzeug verwenden
let store:CDTStore = existingStore
let automobileId:String = existingAutomobileId

// Fahrzeug aus dem Store abrufen
store.fetchById(automobileId, completionHandler: { (object:AnyObject!, error:NSError!) -> Void in
    if nil != error {
        // Abrufen fehlgeschlagen, Handler hat einen Fehler empfangen
    } else {
        // Ergebnis verwenden
        let savedAutomobile:Automobile = object as! Automobile
        print("Fetched automobile: \(savedAutomobile)")
    }
})
Android
// Vorhandenen Store und vorhandene documentId verwenden
Store store = existingStore;
String automobileId = existingAutomobileId;

// Fahrzeug aus dem Store abrufen
Task<Object> fetchTask = store.fetchById(automobileId);
fetchTask.continueWith(new Continuation<Object, Void>() {
    @Override
    public Void then(Task<Object> task) throws Exception {
        if (task.isFaulted()) {
            // Abruf nicht erfolgreich. Fehler ist in task.getError() enthalten.
        } else {
            // Ergebnis verwenden 
            Automobile fetchedAutomobile = (Automobile) task.getResult();
        }
        return null;
    }
});
AndroidNACHHER (mit Cloudant Sync): 
// Vorhandenen Store und vorhandene documentId verwenden
CDTDatastore *datastore = existingDatastore;
NSString *documentId = existingDocumentId;

// Überarbeitung CDTDocumentRevision aus dem Store abrufen
NSError* error = nil;
CDTDocumentRevision *fetchedRevision = [datastore getDocumentWithId:documentId error:&error];

if (error) {
    // Abrufen fehlgeschlagen, Handler hat einen Fehler empfangen
} else {
    // Ergebnis verwenden
    NSLog(@"Revision: %@", fetchedRevision);
}
// Vorhandenen Store und vorhandene documentId verwenden
let datastore:CDTDatastore = existingDatastore
let documentId:String = existingDocumentId

var fetchedRevision:CDTDocumentRevision?
do{
    fetchedRevision = try datastore.getDocumentWithId(documentId)
    NSLog("Revision: \(fetchedRevision)");
}catch let error as NSError{
    // Fehler behandeln
}
Android
// Vorhandenen Store und vorhandene documentId verwenden
Datastore datastore = existingStore;
String documentId = existingDocumentId;

// Überarbeitung aus dem Store abrufen
DocumentRevision fetchedRevision = datastore.getDocument(documentId);

Daten aktualisieren

Wenn Sie ein Objekt aktualisieren möchten, müssen Sie "save" für ein vorhandenes Objekt ausführen. Da das Element bereits vorhanden ist, wird es aktualisiert.

Vorgehensweise

Aktualisieren Sie Objekte.
AndroidVORHER (mit IMFData/CloudantToolkit):
// Vorhandenen Store und vorhandenes Fahrzeug verwenden
CDTStore *store = existingStore;
Automobile *automobile = existingAutomobile;

// Einige Werte des Fahrzeugs aktualisieren
automobile.year = 2015;

// Fahrzeug im Store speichern
[store save:automobile completionHandler:^(id savedObject, NSError *error) {
    if (error) {
        // Speichern fehlgeschlagen, Handler hat einen Fehler empfangen
    } else {
        // Ergebnis verwenden
        Automobile *savedAutomobile = savedObject;
        NSLog(@"saved automobile: %@", savedAutomobile);
    }
}];
// Vorhandenen Store und vorhandenes Fahrzeug verwenden
let store:CDTStore = existingStore
let automobile:Automobile = existingAutomobile

// Einige Werte des Fahrzeugs aktualisieren
automobile.year = 2015

// Fahrzeug im Store speichern
store.save(automobile, completionHandler: { (savedObject:AnyObject!, error:NSError!) -> Void in
    if nil != error {
        // Aktualisierung fehlgeschlagen, Handler hat einen Fehler empfangen
    } else {
        // Ergebnis verwenden
        let savedAutomobile:Automobile = savedObject as! Automobile
        print("Updated automobile: \(savedAutomobile)")
    }
})
Android
// Vorhandenen Store und vorhandenes Fahrzeug verwenden
Store store = existingStore;
Automobile automobile = existingAutomobile;

// Einige Werte des Fahrzeugs aktualisieren
automobile.setYear(2015);

// Fahrzeug im Store speichern
Task<Object> saveTask = store.save(automobile);
saveTask.continueWith(new Continuation<Object, Void>() {
    @Override
    public Void then(Task<Object> task) throws Exception {
        if (task.isFaulted()) {
            // Speichern nicht erfolgreich. Fehler ist in task.getError() enthalten.
        } else {
            // Ergebnis verwenden
            Automobile savedAutomobile = (Automobile) task.getResult();
        }
        return null;
    }
});
AndroidNACHHER (mit Cloudant Sync): 
// Vorhandenen Store und vorhandenes Dokument verwenden
CDTDatastore *datastore = existingDatastore;
CDTMutableDocumentRevision *documentRevision = [existingDocumentRevision mutableCopy];

// Einige Werte in der Überarbeitung aktualisieren
[documentRevision.body setValue:@2015 forKey:@"year"];

NSError* error = nil;
CDTDocumentRevision *updatedRevision = [datastore updateDocumentFromRevision:documentRevision error:&error];
if (error) {
    // Speichern fehlgeschlagen, Handler hat einen Fehler empfangen
} else {
    // Ergebnis verwenden
    NSLog(@"Revision: %@", updatedRevision);
}
// Vorhandenen Store und vorhandenes Dokument verwenden
let datastore:CDTDatastore = existingDatastore
let documentRevision:CDTMutableDocumentRevision = existingDocumentRevision.mutableCopy()

// Einige Werte in der Überarbeitung aktualisieren
documentRevision.body()["year"] = 2015

var updatedRevision:CDTDocumentRevision?
do{
    updatedRevision = try datastore.updateDocumentFromRevision(documentRevision)
    NSLog("Revision: \(updatedRevision)");
}catch let error as NSError{
    // Fehler behandeln
}
Android
// Vorhandenen Store und vorhandene documentId verwenden
// Vorhandenen Store verwenden
Datastore datastore = existingStore;

// Überarbeitung MutableDocumentRevision aus vorhandener Überarbeitung erstellen
MutableDocumentRevision revision = existingRevision.mutableCopy();

// Einige Werte in der Überarbeitung aktualisieren
Map<String, Object> body = revision.getBody().asMap();
body.put("year", 2015);
revision.body = DocumentBodyFactory.create(body);

// Überarbeitung im Store speichern
DocumentRevision savedRevision = datastore.updateDocumentFromRevision(revision);

Daten löschen

Wenn Sie ein Objekt löschen möchten, übergeben Sie es an den Store.

Vorgehensweise

Löschen Sie Objekte.
AndroidVORHER (mit IMFData/CloudantToolkit):
// Vorhandenen Store und vorhandenes Fahrzeug verwenden
CDTStore *store = existingStore;
Automobile *automobile = existingAutomobile;

// Fahrzeugobjekt aus dem Store löschen
[store delete:automobile completionHandler:^(NSString *deletedObjectId, NSString *deletedRevisionId, NSError *error) {
    if (error) {
        // Löschen fehlgeschlagen, Handler hat einen Fehler empfangen
    } else {
        // Ergebnis verwenden
        NSLog(@"deleted Automobile doc-%@-rev-%@", deletedObjectId, deletedRevisionId);
    }
}];
// Vorhandenen Store und vorhandenes Fahrzeug verwenden
let store:CDTStore = existingStore
let automobile:Automobile = existingAutomobile

// Fahrzeugobjekt löschen
store.delete(automobile, completionHandler: { (deletedObjectId:String!, deletedRevisionId:String!, error:NSError!) -> Void in
    if nil != error {
        // Löschen fehlgeschlagen, Handler hat einen Fehler empfangen
    } else {
        // Ergebnis verwenden
        print("deleted document doc-\(deletedObjectId)-rev-\(deletedRevisionId)")
    }
})
Android
// Vorhandenen Store und vorhandenes Fahrzeug verwenden
Store store = existingStore;
Automobile automobile = existingAutomobile;

// Fahrzeug aus dem Store löschen
Task<String> deleteTask = store.delete(automobile);
deleteTask.continueWith(new Continuation<String, Void>() {
    @Override
    public Void then(Task<String> task) throws Exception {
        if (task.isFaulted()) {
            // Löschen nicht erfolgreich. Fehler ist in task.getError() enthalten.
        } else {
            // Ergebnis verwenden
            String deletedAutomobileId = task.getResult();
        }
        return null;
    }
});
AndroidNACHHER (mit Cloudant Sync): 
// Vorhandenen Store und vorhandene Überarbeitung verwenden
CDTDatastore *datastore = existingDatastore;
CDTDocumentRevision *documentRevision = existingDocumentRevision;

// Überarbeitung CDTDocumentRevision aus dem Store löschen
NSError* error = nil;
CDTDocumentRevision *deletedRevision = [datastore deleteDocumentFromRevision:documentRevision error:&error];
if (error) {
    // Löschen fehlgeschlagen, Handler hat einen Fehler empfangen
} else {
    // Ergebnis verwenden
    NSLog(@"deleted document: %@", deletedRevision);
}
// Vorhandenen Store und vorhandene Überarbeitung verwenden
let datastore:CDTDatastore = existingDatastore
let documentRevision:CDTDocumentRevision = existingDocumentRevision

var deletedRevision:CDTDocumentRevision?
do{
    deletedRevision = try datastore.deleteDocumentFromRevision(documentRevision)
    NSLog("Revision: \(deletedRevision)");
}catch let error as NSError{
    // Fehler behandeln
}
Android
// Vorhandenen Store und vorhandene Überarbeitung verwenden
Datastore datastore = existingStore;
BasicDocumentRevision documentRevision = (BasicDocumentRevision) existingDocumentRevision;

// Überarbeitung aus dem Store löschen
DocumentRevision deletedRevision = datastore.deleteDocumentFromRevision(documentRevision);