/// <summary>
/// Opens a view, or creates it if the file doesn't already exist.
/// </summary>
/// <param name="db">The database the view is associated with</param>
/// <param name="path">The file that the view is stored in</param>
/// <param name="viewName">The name of the view</param>
/// <param name="version">The version of the view's map function</param>
/// <param name="flags">The flags for opening the view file</param>
/// <param name="encryptionKey">The option encryption key used to encrypt the database</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>A pointer to the view on success, otherwise null</returns>
public static C4View* c4view_open(C4Database *db, string path, string viewName, string version, C4DatabaseFlags flags,
C4EncryptionKey *encryptionKey, C4Error *outError)
{
using(var path_ = new C4String(path))
using(var viewName_ = new C4String(viewName))
using(var version_ = new C4String(version)) {
return c4view_open(db, path_.AsC4Slice(), viewName_.AsC4Slice(), version_.AsC4Slice(), flags, encryptionKey, outError);
}
}
/// <summary>
/// Creates an enumerator ordered by docID.
/// Options have the same meanings as in Couchbase Lite.
/// There's no 'limit' option; just stop enumerating when you're done.
/// Caller is responsible for freeing the enumerator when finished with it.
/// </summary>
/// <param name="db">The database to operate on</param>
/// <param name="startDocID">The document ID to begin at</param>
/// <param name="endDocID">The document ID to end at</param>
/// <param name="options">Enumeration options (NULL for defaults)</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>A pointer to the enumeator on success, otherwise null</returns>
public static C4DocEnumerator* c4db_enumerateAllDocs(C4Database *db, string startDocID, string endDocID, C4EnumeratorOptions *options,
C4Error *outError)
{
using(var startDocID_ = new C4String(startDocID))
using(var endDocID_ = new C4String(endDocID)) {
return c4db_enumerateAllDocs(db, startDocID_.AsC4Slice(), endDocID_.AsC4Slice(), options, outError);
}
}
public static C4DocEnumerator* c4db_enumerateSomeDocs(C4Database *db, string[] docIDs, C4EnumeratorOptions *options,
C4Error *outError)
{
var c4StringArr = docIDs.Select(x => new C4String(x)).ToArray();
var sliceArr = c4StringArr.Select(x => x.AsC4Slice()).ToArray();
var retVal = default(C4DocEnumerator*);
fixed(C4Slice* ptr = sliceArr) {
retVal = _c4db_enumerateSomeDocs(db, ptr, (uint)docIDs.Length, options, outError);
#if DEBUG
if(retVal != null) {
_AllocatedObjects[(IntPtr)retVal] = "C4DocEnumerator";
#if ENABLE_LOGGING
Console.WriteLine("[c4db_enumerateSomeDocs] Allocated 0x{0}", ((IntPtr)retVal).ToString("X"));
#endif
}
#endif
}
foreach (var c4str in c4StringArr) {
c4str.Dispose();
}
return retVal;
}
public static bool c4db_purgeDoc(C4Database *db, string docId, C4Error *outError)
{
using (var docId_ = new C4String(docId)) {
return c4db_purgeDoc(db, docId_.AsC4Slice(), outError);
}
}
private static extern C4DocEnumerator* _c4db_enumerateAllDocs(C4Database *db, C4Slice startDocID, C4Slice endDocID,
C4EnumeratorOptions *options, C4Error *outError);
public static C4Document* c4doc_get(C4Database *db, C4Slice docID, bool mustExist,
C4Error *outError)
{
#if DEBUG
var retVal = _c4doc_get(db, docID, mustExist, outError);
if(retVal != null) {
_AllocatedObjects[(IntPtr)retVal] = "C4Document";
#if ENABLE_LOGGING
Console.WriteLine("[c4doc_get] Allocated 0x{0}", ((IntPtr)retVal).ToString("X"));
#endif
}
return retVal;
#else
return _c4doc_get(db, docID, mustExist, outError);
#endif
}
public static extern C4Document* c4doc_getBySequence(C4Database *db, ulong sequence, C4Error *outError);
public static extern bool c4db_rekey(C4Database *db, C4EncryptionKey *newKey, C4Error *outError);
public static extern ulong c4db_getDocumentCount(C4Database *db);
/// <summary>
/// Closes the database, deletes the file, and frees the object
/// </summary>
/// <param name="db">The DB object to delete</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>true on success, false otherwise</returns>
public static bool c4db_delete(C4Database *db, C4Error *outError)
{
#if DEBUG
var ptr = (IntPtr)db;
#if ENABLE_LOGGING
if(ptr != IntPtr.Zero && !_AllocatedObjects.ContainsKey(ptr)) {
Console.WriteLine("WARNING: [c4db_delete] freeing object 0x{0} that was not found in allocated list", ptr.ToString("X"));
} else {
#endif
_AllocatedObjects.Remove(ptr);
#if ENABLE_LOGGING
}
#endif
#endif
return _c4db_delete(db, outError);
}
public static extern bool c4db_compact(C4Database *db, C4Error *outError);
private static extern bool _c4db_delete(C4Database *db, C4Error *outError);
/// <summary>
/// Creates an indexing task on one or more views in a database.
/// </summary>
/// <param name="db">The database to operate on</param>
/// <param name="views">An array of views whose indexes should be updated in parallel.</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>A pointer to the indexer on success, otherwise null</returns>
public static C4Indexer* c4indexer_begin(C4Database* db, C4View*[] views, C4Error* outError)
{
fixed(C4View** viewPtr = views) {
#if DEBUG
var retVal = _c4indexer_begin(db, viewPtr, views.Length, outError);
if(retVal != null) {
_AllocatedObjects[(IntPtr)retVal] = "C4Indexer";
#if ENABLE_LOGGING
Console.WriteLine("[c4indexer_begin] Allocated 0x{0}", ((IntPtr)retVal).ToString("X"));
#endif
}
return retVal;
#else
return _c4indexer_begin(db, viewPtr, views.Length, outError);
#endif
}
}
private static extern C4Indexer* _c4indexer_begin(C4Database *db, C4View** views, int viewCount, C4Error *outError);
/// <summary>
/// Writes a raw document to the database, or deletes it if both meta and body are NULL.
/// </summary>
/// <param name="db">The database to operate on</param>
/// <param name="storeName">The store to write to</param>
/// <param name="key">The key to store</param>
/// <param name="meta">The metadata to store</param>
/// <param name="body">The body to store</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>true on success, false otherwise</returns>
public static bool c4raw_put(C4Database *db, string storeName, string key, string meta, string body, C4Error *outError)
{
using(var storeName_ = new C4String(storeName))
using(var key_ = new C4String(key))
using(var meta_ = new C4String(meta))
using(var body_ = new C4String(body)) {
return c4raw_put(db, storeName_.AsC4Slice(), key_.AsC4Slice(), meta_.AsC4Slice(),
body_.AsC4Slice(), outError);
}
}
public static extern ulong c4db_getLastSequence(C4Database *db);
private static extern C4Document* _c4doc_get(C4Database *db, C4Slice docID, [MarshalAs(UnmanagedType.U1)]bool mustExist,
C4Error *outError);
public static extern bool c4db_beginTransaction(C4Database *db, C4Error *outError);
/// <summary>
/// Gets a document from the database. If there's no such document, the behavior depends on
/// the mustExist flag.If it's true, NULL is returned. If it's false, a valid C4Document
/// The current revision is selected(if the document exists.)
/// </summary>
/// <param name="db">The database to retrieve from</param>
/// <param name="docID">The ID of the document to retrieve</param>
/// <param name="mustExist">Whether or not to create the document on demand</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>A pointer to the retrieved document on success, or null on failure</returns>
public static C4Document* c4doc_get(C4Database *db, string docID, bool mustExist, C4Error *outError)
{
using(var docID_ = new C4String(docID)) {
return c4doc_get(db, docID_.AsC4Slice(), mustExist, outError);
}
}
public static extern bool c4db_endTransaction(C4Database *db, [MarshalAs(UnmanagedType.U1)]bool commit, C4Error *outError);
public static extern bool c4db_purgeDoc(C4Database *db, C4Slice docId, C4Error *outError);
public static extern bool c4db_isInTransaction(C4Database *db);
private static extern C4DocEnumerator* _c4db_enumerateChanges(C4Database* db, ulong since, C4EnumeratorOptions* options,
C4Error* outError);
private static extern C4RawDocument* _c4raw_get(C4Database *db, C4Slice storeName, C4Slice docID, C4Error *outError);
public static C4DocEnumerator* c4db_enumerateAllDocs(C4Database *db, C4Slice startDocID, C4Slice endDocID,
C4EnumeratorOptions *options, C4Error *outError)
{
#if DEBUG
var retVal = _c4db_enumerateAllDocs(db, startDocID, endDocID, options, outError);
if(retVal != null) {
_AllocatedObjects[(IntPtr)retVal] = "C4DocEnumerator";
#if ENABLE_LOGGING
Console.WriteLine("[c4db_enumerateAllDocs] Allocated 0x{0}", ((IntPtr)retVal).ToString("X"));
#endif
}
return retVal;
#else
return _c4db_enumerateAllDocs(db, startDocID, endDocID, options, outError);
#endif
}
/// <summary>
/// Reads a raw document from the database. In Couchbase Lite the store named "info" is used for
/// per-database key/value pairs, and the store "_local" is used for local documents.
/// </summary>
/// <param name="db">The database to operate on</param>
/// <param name="storeName">The name of the store to read from</param>
/// <param name="docID">The ID of the document to retrieve</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>A pointer to the retrieved document on success, or null on failure</returns>
public static C4RawDocument* c4raw_get(C4Database *db, string storeName, string docID, C4Error *outError)
{
using(var storeName_ = new C4String(storeName))
using(var docID_ = new C4String(docID)) {
return c4raw_get(db, storeName_.AsC4Slice(), docID_.AsC4Slice(), outError);
}
}
private static extern C4DocEnumerator* _c4db_enumerateSomeDocs(C4Database *db, C4Slice* docIDs, uint docIDsCount,
C4EnumeratorOptions *options, C4Error *outError);
public static extern bool c4raw_put(C4Database *db, C4Slice storeName, C4Slice key, C4Slice meta,
C4Slice body, C4Error *outError);
public TransactionHelper(C4Database *db)
{
C4Error error;
Assert.IsTrue(Native.c4db_beginTransaction(db, &error));
_db = db;
}
public static C4View* c4view_open(C4Database *db, C4Slice path, C4Slice viewName, C4Slice version,
C4DatabaseFlags flags, C4EncryptionKey *encryptionKey, C4Error *outError)
{
#if DEBUG
var retVal = _c4view_open(db, path, viewName, version, flags, encryptionKey, outError);
if(retVal != null) {
_AllocatedObjects[(IntPtr)retVal] = "C4View";
#if ENABLE_LOGGING
Console.WriteLine("[c4view_open] Allocated 0x{0}", ((IntPtr)retVal).ToString("X"));
#endif
}
return retVal;
#else
return _c4view_open(db, path, viewName, version, flags, encryptionKey, outError);
#endif
}
