chore: update couchbase-lite-c to 3.2.0

Author: xdm67x

.DS_Store

@@ -1,6 +1,6 @@
 [package]
 name = "couchbase_lite"
-version = "3.1.7-0"
+version = "3.2.0-1"
 # The first three numbers correspond to the Couchbase Lite C release, the fourth number corresponds to the Doctolib release
 
 [dependencies]

Cargo.toml

@@ -91,6 +91,7 @@ namespace cbl {
 
         CBLRefCounted* _cbl_nullable _ref;
 
+        friend class Extension;
         friend class Transaction;
     };
 

libcblite-3.0.3/.DS_Store

@@ -18,6 +18,7 @@
 
 #pragma once
 #include "cbl++/Base.hh"
+#include "cbl++/Database.hh"
 #include "cbl/CBLCollection.h"
 #include "cbl/CBLScope.h"
 #include "fleece/Mutable.hh"
@@ -35,6 +36,8 @@ namespace cbl {
     class MutableDocument;
     class CollectionChange;
     class DocumentChange;
+    class QueryIndex;
+    class VectorIndexConfiguration;
 
     /** Conflict handler used when saving a document. */
     using CollectionConflictHandler = std::function<bool(MutableDocument documentBeingSaved,
@@ -61,19 +64,25 @@ namespace cbl {
     public:
         // Accessors:
 
-        /** The collection name. */
-        std::string name() const                    {return asString(CBLCollection_Name(ref()));}
+        /** The collection's name. */
+        std::string name() const                        {return asString(CBLCollection_Name(ref()));}
 
-        /** The scope name. */
+        /** The collection's fully qualified name in the '<scope-name>.<collection-name>' format. */
+        std::string fullName() const                    {return asString(CBLCollection_FullName(ref()));}
+        
+        /** The scope's name. */
         std::string scopeName() const {
             auto scope = CBLCollection_Scope(ref());
             auto scopeName = asString(CBLScope_Name(scope));
             CBLScope_Release(scope);
             return scopeName;
         }
 
+        /** The collection's database.  */
+        Database database() const                       {return Database(CBLCollection_Database(ref()));}
+        
         /** The number of documents in the collection. */
-        uint64_t count() const                      {return CBLCollection_Count(ref());}
+        uint64_t count() const                          {return CBLCollection_Count(ref());}
 
         // Documents:
 
@@ -190,6 +199,17 @@ namespace cbl {
             CBLError error;
             check(CBLCollection_CreateFullTextIndex(ref(), name, config, &error), error);
         }
+        
+#ifdef COUCHBASE_ENTERPRISE
+        /** ENTERPRISE EDITION ONLY
+         
+            Creatres a vector index in the collection.
+            If an identical index with that name already exists, nothing happens (and no error is returned.)
+            If a non-identical index with that name already exists, it is deleted and re-created.
+            @param name  The index name.
+            @param config  The vector index config. */
+        inline void createVectorIndex(slice name, const VectorIndexConfiguration &config);
+#endif
 
         /** Deletes an index given its name from the collection. */
         void deleteIndex(slice name) {
@@ -207,6 +227,9 @@ namespace cbl {
             return names;
         }
 
+        /** Get an index by name. If the index doesn't exist, the NULL QueryIndex object will be returned. */
+        inline QueryIndex getIndex(slice name);
+        
         // Listeners:
 
         /** Collection Change Listener Token */
@@ -250,6 +273,7 @@ namespace cbl {
 
         friend class Database;
         friend class Document;
+        friend class QueryIndex;
 
         CBL_REFCOUNTED_BOILERPLATE(Collection, RefCounted, CBLCollection);
 
@@ -311,6 +335,23 @@ namespace cbl {
         Collection _collection;
         slice _docID;
     };
+
+    // Database method bodies:
+
+    inline Collection Database::getCollection(slice collectionName, slice scopeName) const {
+        CBLError error {};
+        return Collection::adopt(CBLDatabase_Collection(ref(), collectionName, scopeName, &error), &error) ;
+    }
+
+    inline Collection Database::createCollection(slice collectionName, slice scopeName) {
+        CBLError error {};
+        return Collection::adopt(CBLDatabase_CreateCollection(ref(), collectionName, scopeName, &error), &error) ;
+    }
+
+    inline Collection Database::getDefaultCollection() const {
+        CBLError error {};
+        return Collection::adopt(CBLDatabase_DefaultCollection(ref(), &error), &error) ;
+    }
 }
 
 /** Hash function for Collection. */

libcblite-3.0.3/LICENSE.txt

@@ -24,5 +24,8 @@
 #include "Collection.hh"
 #include "Database.hh"
 #include "Document.hh"
+#include "Prediction.hh"
 #include "Query.hh"
+#include "QueryIndex.hh"
 #include "Replicator.hh"
+#include "VectorIndex.hh"

libcblite-3.0.3/include/cbl++/Base.hh

@@ -45,6 +45,24 @@ namespace cbl {
     using ConflictHandler = std::function<bool(MutableDocument documentBeingSaved,
                                                Document conflictingDocument)>;
 
+    
+#ifdef COUCHBASE_ENTERPRISE
+    /** ENTERPRISE EDITION ONLY
+     
+        Couchbase Lite  Extension. */
+    class Extension {
+    public:
+        /** Enables Vector Search extension by specifying the extension path to search for the Vector Search extension library.
+            This function must be called before opening a database that intends to use the vector search extension.
+            @param path The file system path of the directory that contains the Vector Search extension library.
+            @note Must be called before opening a database that intends to use the vector search extension. */
+        static void enableVectorSearch(slice path) {
+            CBLError error {};
+            RefCounted::check(CBL_EnableVectorSearch(path, &error), error);
+        }
+    };
+#endif
+
     /** Couchbase Lite Database. */
     class Database : private RefCounted {
     public:
@@ -159,7 +177,7 @@ namespace cbl {
 
         /** Returns the names of all existing scopes in the database.
             The scope exists when there is at least one collection created under the scope.
-            The default scope is exceptional in that it will always exists even there are no collections under it.
+            @note The default scope will always exist, containing at least the default collection.
             @return The names of all existing scopes in the database, or throws if an error occurred. */
         fleece::MutableArray getScopeNames() const {
             CBLError error {};
@@ -186,10 +204,7 @@ namespace cbl {
             @param collectionName  The name of the collection.
             @param scopeName  The name of the scope.
             @return A \ref Collection instance, or NULL if the collection doesn't exist, or throws if an error occurred. */
-        inline Collection getCollection(slice collectionName, slice scopeName =kCBLDefaultScopeName) const {
-            CBLError error {};
-            return Collection::adopt(CBLDatabase_Collection(ref(), collectionName, scopeName, &error), &error) ;
-        }
+        inline Collection getCollection(slice collectionName, slice scopeName =kCBLDefaultScopeName) const;
 
         /** Create a new collection.
             The naming rules of the collections and scopes are as follows:
@@ -201,27 +216,19 @@ namespace cbl {
             @param collectionName  The name of the collection.
             @param scopeName  The name of the scope.
             @return A \ref Collection instance, or throws if an error occurred. */
-        inline Collection createCollection(slice collectionName, slice scopeName =kCBLDefaultScopeName) {
-            CBLError error {};
-            return Collection::adopt(CBLDatabase_CreateCollection(ref(), collectionName, scopeName, &error), &error) ;
-        }
+        inline Collection createCollection(slice collectionName, slice scopeName =kCBLDefaultScopeName);
 
         /** Delete an existing collection.
+            @note The default collection cannot be deleted.
             @param collectionName  The name of the collection.
             @param scopeName  The name of the scope. */
         inline void deleteCollection(slice collectionName, slice scopeName =kCBLDefaultScopeName) {
             CBLError error {};
             check(CBLDatabase_DeleteCollection(ref(), collectionName, scopeName, &error), error);
         }
 
-        /** Returns the default collection.
-            @note The default collection may not exist if it was deleted.
-                  Also, the default collection cannot be recreated after being deleted.
-            @return A \ref Collection instance, or NULL if the default collection doesn't exist, or throws if an error occurred. */
-        inline Collection getDefaultCollection() const {
-            CBLError error {};
-            return Collection::adopt(CBLDatabase_DefaultCollection(ref(), &error), &error) ;
-        }
+        /** Returns the default collection. */
+        inline Collection getDefaultCollection() const;
 
         // Documents:
 
@@ -448,6 +455,12 @@ namespace cbl {
         ~Database() {
             clear();
         }
+        
+    protected:
+        friend class Collection;
+        friend class Scope;
+        
+        CBL_REFCOUNTED_WITHOUT_COPY_MOVE_BOILERPLATE(Database, RefCounted, CBLDatabase)
 
     private:
         void open(slice& name, const CBLDatabaseConfiguration* _cbl_nullable config) {
@@ -494,8 +507,6 @@ namespace cbl {
 
         std::shared_ptr<NotificationsReadyCallbackAccess> _notificationReadyCallbackAccess;
 
-        CBL_REFCOUNTED_WITHOUT_COPY_MOVE_BOILERPLATE(Database, RefCounted, CBLDatabase)
-        
     public:
         Database(const Database &other) noexcept
         :RefCounted(other)
@@ -575,7 +586,6 @@ namespace cbl {
 
         CBLDatabase* _cbl_nullable _db = nullptr;
     };
-
 }
 
 CBL_ASSUME_NONNULL_END

libcblite-3.0.3/include/cbl++/Collection.hh

@@ -71,6 +71,10 @@ namespace cbl {
         inline MutableDocument mutableCopy() const;
 
     protected:
+        friend class Collection;
+        friend class Database;
+        friend class Replicator;
+        
         Document(CBLRefCounted* r)                  :RefCounted(r) { }
 
         static Document adopt(const CBLDocument* _cbl_nullable d, CBLError *error) {
@@ -89,11 +93,7 @@ namespace cbl {
             else
                 throw error;
         }
-
-        friend class Collection;
-        friend class Database;
-        friend class Replicator;
-
+        
         CBL_REFCOUNTED_BOILERPLATE(Document, RefCounted, const CBLDocument)
     };
 

libcblite-3.0.3/include/cbl++/CouchbaseLite.hh

@@ -0,0 +1,88 @@
+//
+// Prediction.hh
+//
+// Copyright (c) 2024 Couchbase, Inc All rights reserved.
+//
+// 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
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// 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.
+//
+
+// VOLATILE API: Couchbase Lite C++ API is not finalized, and may change in
+// future releases.
+
+#ifdef COUCHBASE_ENTERPRISE
+
+#pragma once
+#include "cbl++/Base.hh"
+#include "cbl/CBLPrediction.h"
+#include <memory>
+#include <unordered_map>
+
+// VOLATILE API: Couchbase Lite C++ API is not finalized, and may change in
+// future releases.
+
+CBL_ASSUME_NONNULL_BEGIN
+
+namespace cbl {
+    /** ENTERPRISE EDITION ONLY
+     
+        The PredictiveModel  that allows to integrate machine learning model
+        into queries via invoking query's PREDICTION() function.
+     
+        @note The predictive index feature is not supported by Couchbase Lite for C.
+              The Predictive Model is currently for creating vector indexes using the PREDICTION() function,
+              which will call the specified predictive model for computing the vectors. */
+    class PredictiveModel {
+    public:
+        /** Predicts and returns a mutable dictionary based on the input dictionary.
+            Override this function  for the implementation.
+            @param input The input dictionary corresponding to the input dictionary expression given in the query's PREDICTION() function
+            @return The output dictionary.
+                    - To create a new dictionary for returning, use fleece::MutableDict::newDict().
+                    - To create a null result to evaluate as MISSING, use fleece::MutableDict(). */
+        virtual fleece::MutableDict prediction(fleece::Dict input) noexcept = 0;
+        
+        virtual ~PredictiveModel() = default;
+    };
+
+    static std::unordered_map<slice, std::unique_ptr<PredictiveModel>> _sPredictiveModels;
+
+    /** Predictive Model Registation 
+        This class provides static methods to register and unregister predictive models. */
+    class Prediction {
+    public:
+        /** Registers a predictive model with the given name. */
+        static void registerModel(slice name, std::unique_ptr<PredictiveModel> model) {
+            auto prediction = [](void* context, FLDict input) {
+                auto m = (PredictiveModel*)context;
+                return FLMutableDict_Retain((FLMutableDict) m->prediction(input));
+            };
+            
+            CBLPredictiveModel config { };
+            config.context = model.get();
+            config.prediction = prediction;
+            CBL_RegisterPredictiveModel(name, config);
+            
+            _sPredictiveModels[name] = std::move(model);
+        }
+        
+        /** Unregisters the predictive model with the given name. */
+        static void unregisterModel(slice name) {
+            CBL_UnregisterPredictiveModel(name);
+            _sPredictiveModels.erase(name);
+        }
+    };
+}
+
+CBL_ASSUME_NONNULL_END
+    
+#endif