// Create or open database
var database = new Database("mydb");
 
// Create a new document (i.e. a record) in the database
string id = null;
using (var mutableDoc = new MutableDocument())
{
   mutableDoc.SetFloat("version", 2.0f)
       .SetString("type", "SDK");
 
   // Save it to the database
   database.Save(mutableDoc);
   id = mutableDoc.Id;
}
 
// Update a document
using (var doc = database.GetDocument(id))
using (var mutableDoc = doc.ToMutable())
{
   mutableDoc.SetString("language", "C#");
   database.Save(mutableDoc);
 
   using (var docAgain = database.GetDocument(id))
   {
       Console.WriteLine($"Document ID :: {docAgain.Id}");
       Console.WriteLine($"Learning {docAgain.GetString("language")}");
   }
}
 
// Create a query to fetch documents of type SDK
// i.e. SELECT * FROM database WHERE type = "SDK"
using (var query = QueryBuilder.Select(SelectResult.All())
   .From(DataSource.Database(database))
   .Where(Expression.Property("type").EqualTo(Expression.String("SDK"))))
{
   // Run the query
   var result = query.Execute();
   Console.WriteLine($"Number of rows :: {result.AllResults().Count}");
}
 
// Create replicator to push and pull changes to and from the cloud
var targetEndpoint = new URLEndpoint(new Uri("ws://localhost:4984/getting-started-db"));
var replConfig = new ReplicatorConfiguration(database, targetEndpoint);
 
// Add authentication
replConfig.Authenticator = new BasicAuthenticator("john", "pass");
 
// Optionally, Create replicator (make sure to add an instance or static variable
// named _Replicator)
var _Replicator = new Replicator(replConfig);
_Replicator.AddChangeListener((sender, args) =>
{
   if (args.Status.Error != null)
   {
       Console.WriteLine($"Error :: {args.Status.Error}");
   }
});
 
// Start replicator
_Replicator.Start();
                                

                                        // Create or open a database
val cfg = DatabaseConfigurationFactory.create()
val database = Database(  "mydb", cfg)
​// Create a new document (i.e. a record) in the database.
var mutableDoc = MutableDocument().setFloat("version", 2.0f).setString("type", "SDK")
// Save it to the database.
database.save(mutableDoc)
​// Retrieve and update a document.
mutableDoc = database.getDocument(mutableDoc.id)!!.toMutable().setString("language", "Java")
database.save(mutableDoc)
// Retrieve immutable document and log the document ID generated by the database and some document properties
val document = database.getDocument(mutableDoc.id)!!
Log.i(TAG, "Document ID :: ${document.id}")
Log.i(TAG, "Learning ${document.getString("language")}")
​// Create a query to fetch documents of type SDK.
val rs = QueryBuilder.select(SelectResult.all())
  .from(DataSource.database(database))
  .where(Expression.property("type").equalTo(Expression.string("SDK")))
  .execute()
Log.i(TAG, "Number of rows :: ${rs.allResults().size}")
​
// Create a replicator to push and pull changes to and from the cloud.
val replicator = Replicator(
  ReplicatorConfigurationFactory.create(
      database = database,
      target = URLEndpoint(URI("ws://localhost:4984/getting-started-db")),
      type = ReplicatorType.PUSH_AND_PULL,
      authenticator = BasicAuthenticator("sync-gateway", "password".toCharArray())
  )
)
​// Optional, Listen to replicator change events.
replicator.addChangeListener { change ->
  val err = change.status.error
  if (err != null) {
      Log.i(TAG, "Error code ::  ${err.code}")
  }
}
​// Start replication.
replicator.start()
                                

                                        // Open or create the database
CBLError err;
CBLDatabase* database = CBLDatabase_Open(FLSTR("mydb"), NULL, &err);
if(!database) {
   // Error handling.  For brevity, this is truncated in the rest of the snippet
   fprintf(stderr, "Error opening database (%d / %d)\n", err.domain, err.code);
   FLSliceResult msg = CBLError_Message(&err);
   fprintf(stderr, "%.*s\n", (int)msg.size, (const char *)msg.buf);
   FLSliceResult_Release(msg);
   return;
}
 
// Create a new document (i.e. a record) in the database
CBLDocument* mutableDoc = CBLDocument_Create();
FLMutableDict properties = CBLDocument_MutableProperties(mutableDoc);
FLMutableDict_SetFloat(properties, FLSTR("version"), 3.0f);
 
// Save it to the database
if(!CBLDatabase_SaveDocument(database, mutableDoc, &err)) {
   // Failed to save, do error handling as above
   return;
}
 
FLStringResult id = FLSlice_Copy(CBLDocument_ID(mutableDoc));
CBLDocument_Release(mutableDoc);
 
// Update a document
mutableDoc = CBLDatabase_GetMutableDocument(database, FLSliceResult_AsSlice(id), &err);
if(!mutableDoc) {
   return;
}
 
properties = CBLDocument_MutableProperties(mutableDoc);
FLMutableDict_SetString(properties, FLSTR("language"), FLSTR("C"));
if(!CBLDatabase_SaveDocument(database, mutableDoc, &err)) {
   return;
}
 
// Note const here, means readonly
const CBLDocument* docAgain = CBLDatabase_GetDocument(database, FLSliceResult_AsSlice(id), &err);
if(!docAgain) {
     return;
}
 
// No copy this time, so no release later (notice it is not FLStringResult this time)
FLString retrievedID = CBLDocument_ID(docAgain);
FLDict retrievedProperties = CBLDocument_Properties(docAgain);
FLString retrievedLanguage = FLValue_AsString(FLDict_Get(retrievedProperties, FLSTR("language")));
printf("Document ID :: %.*s\n", (int)retrievedID.size, (const char *)retrievedID.buf);
 
CBLDocument_Release(mutableDoc);
CBLDocument_Release(docAgain);
FLSliceResult_Release(id);
 
// Create a query to fetch documents of type SDK
int errorPos;
CBLQuery* query = CBLDatabase_CreateQuery(database, kCBLN1QLLanguage, FLSTR("SELECT * FROM _ WHERE type = \"SDK\""), &errorPos, &err);
if(!query) {
   // Failed to create query, do error handling as above
   // Note that errorPos will contain the position in the N1QL string
   // that the parse failed, if applicable
   return;
}
 
CBLResultSet* result = CBLQuery_Execute(query, &err);
if(!result) {
   // Failed to run query, do error handling as above
   return;
}
 
CBLResultSet_Release(result);
CBLQuery_Release(query);
 
// Create replicator to push and pull changes to and from the cloud
CBLEndpoint* targetEndpoint = CBLEndpoint_CreateWithURL(FLSTR("ws://localhost:4984/getting-started-db"), &err);
if(!targetEndpoint) {
   // Failed to create endpoint, do error handling as above
   return;
}
 
CBLReplicatorConfiguration replConfig;
CBLAuthenticator* basicAuth = CBLAuth_CreatePassword(FLSTR("john"), FLSTR("pass"));
memset(&replConfig, 0, sizeof(replConfig));
replConfig.database = database;
replConfig.endpoint = targetEndpoint;
replConfig.authenticator = basicAuth;
 
CBLReplicator* replicator = CBLReplicator_Create(&replConfig, &err);
CBLAuth_Free(basicAuth);
CBLEndpoint_Free(targetEndpoint);
if(!replicator) {
   // Failed to create replicator, do error handling as above
   return;
}
 
// Optionally, add replication listener
CBLListenerToken* token = CBLReplicator_AddChangeListener(replicator, getting_started_change_listener, NULL);
 
// Start the replicator
CBLReplicator_Start(replicator, false);