Database

Closes all open databases, and releases all resources

Initializes a Database structure for interacting with a Predix Sync on-device database, using the provided database name.

Databases consist of documents, which are name/value dictionaries of JSON-compatible data.

Documents may also be related to binary attachments such as images, ZIP files, videos, etc.

Data may be indexed, and then queried.

Multiple calls to open with equivalent configurations will return the same Database object instance.

Example

let config = Database.OpenDatabaseConfiguration.default

do {
    let database = try Database.open(with: config, create: true)
    if let database = database {
        // ... the database is now open, and ready for interactions
    }
} catch let error {
    // ... handle error...
}

Returns an open database object for the matching configuration, if a database matching the configuration has already been opened.

If no database matching the configuration is open, then the Database.open(with: ) must first be called to open the database.

Deletes the database with the given configuration, removing all associated files from the file system. If the specified database is open, it will first be closed before being deleted. Does nothing if no database with the provided name exists.

Returns an array of the names of databases already created on the current device under the provided file location

Returns the total number of documents currently stored in the local database.

If the number of documents is greater than Int.max, will return Int.max

Closes the database, stopping all replications, and releasing all resources used by the Database instance.

Once closed, the Database instance is no longer valid; no methods should be called on the Database object.

Closes, then deletes the database, removing all associated files from the file system.

Once deleted, the Database instance is no longer valid; no methods should be called on the Database object.

The configuration for this Database

Delegate to monitor database change events

Delegate to monitor replication status events

Delegate to exclude documents from being sent to the server during replication

Result enumeration for Database update operations

Database Configuration class.

Indicates the name and location of the database.

Database configuration class used when opening a database

Structure defining a Replication Configuration, to establish data syncing between an on-device database and a Predix Sync offline database service instance.

Indexer implemenation to define a Database index used to query the database

Example:

   let index = Database.Index(name: "myView", version: "1.0", map: { (document, addRow) in
       if let type = document["type"] {
           addRow(type, nil)
       }
   })

   let config = Database.OpenDatabaseConfiguration(indexes: [index])

Used to add and remove observers to queries.

See Also:

• observeQuery(on: with: changeHandler:)
• removeObserver(_ observer:)

Runs a query on a defined index

Example:

var parameters = QueryByKeyList()
parameters.keyList = ["a", "b", "c"]

myDatabase.runQuery(on: "MyView", with: parameters) { queryResult  in

    // do something with query results

}

See Also:

• QueryResults
• QueryByKeyList

• QueryByKeyRange

Runs and observes a query on a defined index. The provided changeHandler closure will be called after the query is first run, then anytime the query results change.

When a query is observed, the index will continued to be monitored, and if any changes to the database occur that result in changes to the query results, the associated changeHandler will be called.

Changes will continue to be monitored until the returned QueryObserver is passed to the removeQueryObserver method.

Example:

var parameters = QueryByKeyList()
parameters.keyList = ["a", "b", "c"]

let observer = myDatabase.observeQuery(on: "MyView", with: parameters) { queryResult  in

    // do something with query results

}

See Also:

• removeObserver

Stops observing the query established with a observeQuery(on: with: changeHandler:) call.

See Also:

• observeQuery(on: with: changeHandler:)

Starts data replication for this Database between the client and server based on the provided ReplicationConfiguration

Replaces (and stops) any previously existing replication for this Database before starting replication based on the provided configuration.

Stops the replication for this Database. Does nothing if no replication is currently configured for this Database.

Configuration details for the active replication, or nil if there is no active replication.

Will be nil if a non-repeating replication has completed, or failed, or if a repeating replication has been stopped.

Downloads attachments for documents that were sync’d without their attachments (downloadsAttachments was false)

If called on a document that already has it’s attachment data, the attachment will not be redownloaded.

Retrieve a document from the database.

Example:

  myDatabase.fetchDocument("document1") { document in
      print("Document retrieved")
  }

Retrieves multiple documents from the database.

Example:

  let idList = ["document1", "document2", "document3"]

  myDatabase.fetchDocuments(idList) { documents in
      print("Document retrieved \(documents.count) documents")
  }

Adds a document to the database.

If a document with the same Id already exists in the database the operation will fail.

Example:

   let myDocument = Document()
   myDocument["someKey"] = "someValue"

   myDatabase.add(myDocument) { result in
       switch result {
       case .success(let addedDocument):
           print("added document with id: \(addedDocument.id)")
       case .failed(let error):
           print("encountered error adding document: \(error)")
       }
   }

Updates an existing document in the database.

If there is no document with the same Id in the database, the operation fails.

Example:

   myDocument["someKey"] = "someNewValue"

   myDatabase.update(myDocument) { result in
       switch result {
       case .success(let updatedDocument):
           print("updated document with id: \(updatedDocument.id)")
       case .failed(let error):
           print("encountered error updating the document: \(error)")
       }
   }

Saves a document to the database.

If a document with the same Id already exists in the database, the existing document will be replaced. If no previous document exists, the document will be created.

Example:

   let myDocument = Document()
   myDocument["someKey"] = "someValue"

   myDatabase.save(myDocument) { result in
       switch result {
       case .success(let savedDocument):
           print("saved document with id: \(savedDocument)")
       case .failed(let error):
           print("encountered error saving document: \(error)")
       }
   }

Deletes a document in the database with the given Id.

Does nothing if no document with the provided Id exists.

Example:

   myDatabase.delete(documentWithId: "document1") { result in
       switch result {
       case .success(let documentId):
           print("deleted document with id: \(documentId)")
       case .failed(let error):
           print("encountered error deleting the document: \(error)")
       }
   }