Cloudant Sync iOS datastore library.
Objective-C Other
Latest commit e3903ce Mar 20, 2017 @emlaver emlaver committed on GitHub Merge pull request #354 from cloudant/352-fix-not-size-in-query
352 fix queries with both $not and $size operators
Failed to load latest commit information.
CDTDatastore.xcodeproj Add missing asset to bundle Dec 5, 2016
CDTDatastore Allow queries combining $not and $size operators Mar 20, 2017
CDTDatastoreEncryption Restore encryption tests (#340) Nov 25, 2016
CDTDatastoreReplicationAcceptanceTests Added creds to UNIRest requests Mar 17, 2017
CDTDatastoreTestApp Make it possible to run Replication Acceptance Tests Oct 10, 2016
CDTDatastoreTestAppTests Make it possible to run Replication Acceptance Tests Oct 10, 2016
CDTDatastoreTestAppUITests Make it possible to run Replication Acceptance Tests Oct 10, 2016
CDTDatastoreTests Allow queries combining $not and $size operators Mar 20, 2017
Project Update Sample Application Oct 17, 2016
doc Update Sample Application Oct 17, 2016
.clang-format Added .clang-format file Nov 6, 2014
.gitignore Adds support for filtered pull replication and reorganizes the Jun 2, 2014
.travis.yml Removed iOS testing from travis Mar 15, 2017
CDTDatastore copy-Info.plist Enable CDTDatastore to build as a framework. Feb 2, 2016
CDTDatastore.podspec Prepare for 1.2.0 release Dec 7, 2016
CDTDatastoreEncryption copy-Info.plist Enable CDTDatastore to build as a framework. Feb 2, 2016
CDTDatastoreReplicationAcceptanceTests copy-Info.plist Enable CDTDatastore to build as a framework. Feb 2, 2016 Allow queries combining $not and $size operators Mar 20, 2017 Admendments to Dec 5, 2016
CONTRIBUTORS Update LICENSE and README with correct information. Dec 6, 2013
Jenkinsfile Enabled RATs for master branch Mar 17, 2017
LICENSE Update LICENSE and README with correct information. Dec 6, 2013
PodFile Simplify podfile and update for new targets (#342) Nov 25, 2016 Update README for Swift 3. Oct 17, 2016
Rakefile Enabled RATs for master branch Mar 17, 2017
build.rb Modify scripts to run replication acceptance tests with encryption. Jun 11, 2015 Make it possible to run Replication Acceptance Tests Oct 10, 2016


Version Platform Build Status

Applications use Cloudant Sync to store, index and query local JSON data on a device and to synchronise data between many devices. Synchronisation is under the control of the application, rather than being controlled by the underlying system. Conflicts are also easy to manage and resolve, either on the local device or in the remote database.

Cloudant Sync is an Apache CouchDB™ replication-protocol-compatible datastore for devices that don't want or need to run a full CouchDB instance. It's built by Cloudant, building on the work of many others, and is available under the Apache 2.0 licence.

The API is quite different from CouchDB's; we retain the MVCC data model but not the HTTP-centric API.

This library is for iOS, an Android version is also available.

If you have questions, please join our mailing list and drop us a line.

Using in your project

CDTDatastore is available through CocoaPods, to install it add the following line to your Podfile:

pod "CDTDatastore"

Note: We only support building on the latest stable release of Xcode

Using in a Swift app

CDTDatastore is useable from Swift out of the box with a few small quirks. Install as per the instructions above, and import CloudantSync.h into your bridging header.

The Overview section below has examples in both Objective-C and Swift.

Example project

There is an example project in the Project folder, for iOS 7. To get this up and running independently of the main codebase, a Podfile is included:

$ cd Project
$ pod install
$ open Project.xcworkspace

Running the tests


Tested Platforms

CDTDatastore gets regularly tested on the following platforms:

  • OS X 10.11 (El Captain)
  • iPhone 4S (Simulator), iOS 9.2

Overview of the library

Once the libraries are added to a project, the basics of adding and reading a document are:

#import <CloudantSync.h>

// Create a CDTDatastoreManager using application internal storage path
NSError *outError = nil;
NSFileManager *fileManager= [NSFileManager defaultManager];

NSURL *documentsDir = [[fileManager URLsForDirectory:NSDocumentDirectory
                                           inDomains:NSUserDomainMask] lastObject];
NSURL *storeURL = [documentsDir URLByAppendingPathComponent:@"cloudant-sync-datastore"];
NSString *path = [storeURL path];

CDTDatastoreManager *manager =
[[CDTDatastoreManager alloc] initWithDirectory:path

CDTDatastore *datastore = [manager datastoreNamed:@"my_datastore"

// Create a document
CDTDocumentRevision *rev = [CDTDocumentRevision revisionWithDocId:@"doc1"];
// Use [CDTDocumentRevision revision] to get an ID generated for you on saving
rev.body = [@{
    @"description": @"Buy milk",
    @"completed": @NO,
    @"type": @"com.cloudant.sync.example.task"
} mutableCopy];

// Add an attachment -- binary data like a JPEG
CDTUnsavedFileAttachment *att1 = [[CDTUnsavedFileAttachment alloc]
rev.attachments[] = att;

// Save the document to the database
CDTDocumentRevision *revision = [datastore createDocumentFromRevision:rev
// `revision` will be `nil` on failures.

// Read a document
NSString *docId = revision.docId;
CDTDocumentRevision *retrieved = [datastore getDocumentWithId:docId

If you are using Swift, install the library as per the instructions above and add the use_frameworks! instruction to your target. A bridging header is required if the use_frameworks! instruction is not used.

If you are using a bridging header, include the CloudantSync.h and you should be good to go:

#import <CDTDatastore/CloudantSync.h>

To add, and read documents in Swift, the basics are:

import CDTDatastore

do {
    let fileManager = FileManager.default

    let documentsDir = fileManager.urls(for: .documentDirectory, in: .userDomainMask).last!

    let storeURL = documentsDir.appendingPathComponent("cloudant-sync-datastore")
    let path = storeURL.path

    let manager = try CDTDatastoreManager(directory: path)
    let datastore = try manager.datastoreNamed("my_datastore")

    // Create a document
    let rev = CDTDocumentRevision(docId: "doc1")
    rev.body = ["description":"Buy Milk",
                "completed": false,

    // Add an attachment - binary data like a JPEG
    let att1 = CDTUnsavedFileAttachment(path: "/path/to/image/jpg",
                                        name: "cute_cat.jpg",
                                        type: "image/jpeg")!
    rev.attachments[] = att1

    let revision = try datastore.createDocument(from: rev)

    // Read a document
    let docId = revision.docId
    let retrieved = try datastore.getDocumentWithId(docId!)

} catch {
    print("Encountered an error: \(error)")

Read more in the CRUD document.

You can subscribe for notifications of changes in the database, which is described in the events documentation. It's still a bit raw right now:

  • You receive a notification for all new revisions in replication (which can be more than one per updated document).

Replicating Data Between Many Devices

Replication is used to synchronise data between the local datastore and a remote database, either a CouchDB instance or a Cloudant database. Many datastores can replicate with the same remote database, meaning that cross-device synchronisation is achieved by setting up replications from each device to the remote database.

Replication is simple to get started in the common cases:

#import <CloudantSync.h>

// Create and start the replicator -- -start is essential!
CDTReplicatorFactory *replicatorFactory =
[[CDTReplicatorFactory alloc] initWithDatastoreManager:manager];

NSString *s = @"";
NSURL *remoteDatabaseURL = [NSURL URLWithString:s];
CDTDatastore *datastore = [manager datastoreNamed:@"my_datastore"];

// Replicate from the local to remote database
CDTPushReplication *pushReplication = [CDTPushReplication replicationWithSource:datastore
NSError *error;
CDTReplicator *replicator = [replicatorFactory oneWay:pushReplication error:&error];

//check error

// Start the replicator
[replicator start];
import CDTDatastore
do {

    let datastore = try manager.datastoreNamed("my_datastore");

    // Replicate from the local to remote database
    let remote = URL(string: "")!
    datastore.push(to: remote) { error in

        if let error = error {
            print("Encountered an error: \(error)")
        } else {
            print("Replication complete")


} catch {
    print("Encountered an error: \(error)")

Read more in the replication docs.

Finding data

Once you have thousands of documents in a database, it's important to have efficient ways of finding them. We've added an easy-to-use querying API. Once the appropriate indexes are set up, querying is as follows:

NSDictionary *query = @{
    @"name": @"John",         // name equals John
    @"age": @{ @"$gt" : @25}  // age greater than 25
CDTQResultSet *result = [datastore find:query];
[result enumerateObjectsUsingBlock:^(CDTDocumentRevision *rev, NSUInteger idx, BOOL *stop) {
    // do something
let query = [
    "name" : "John", // name equals John
    "age" : ["$gt" : 25] // age greater than 25
let result = datastore.find(query)
result?.enumerateObjects { rev, idx, stop in
    // do something

See Index and Querying Data.

As of version 0.16.0 the indexing and querying code has been re-written and has more features than the previous implementation. For details about migrating to a 0.16.0+ indexing and query version from a previous version see Index and Querying Migration.


An obvious repercussion of being able to replicate documents about the place is that sometimes you might edit them in more than one place at the same time. When the databases containing these concurrent edits replicate, there needs to be some way to bring these divergent documents back together. Cloudant's MVCC data-model is used to do this.

A document is really a tree of the document and its history. This is neat because it allows us to store multiple versions of a document. In the main, there's a single, linear tree -- just a single branch -- running from the creation of the document to the current revision. It's possible, however, to create further branches in the tree. At this point your document is conflicted and needs some surgery to resolve the conflicts and bring it back to full health.


All requirements are included in the source code or pulled in as dependencies via pod install.



Contributing to the project




CDTDatastore classes and TouchDB classes

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Used libraries under different licences

  • MYUtilities is licensed under the BSD licence (portions copied into vendor directory).
  • FMDB, by Gus Mueller, is under the MIT License.
  • Google Toolbox For Mac is under the Apache License 2.0.