Collection.hh

Go to the documentation of this file.

//
// Collection.hh
//
// Copyright (c) 2022 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.
//
 
#pragma once
#include "cbl++/Base.hh"
#include "cbl++/Database.hh"
#include "cbl/CBLCollection.h"
#include "cbl/CBLScope.h"
#include "fleece/Mutable.hh"
#include <functional>
#include <string>
#include <vector>
 
 
CBL_ASSUME_NONNULL_BEGIN
 
namespace cbl {
    class Document;
    class MutableDocument;
    class CollectionChange;
    class DocumentChange;
    class QueryIndex;
    class VectorIndexConfiguration;

    using CollectionConflictHandler  = std::function<bool(MutableDocument documentBeingSaved,
                                                          Document conflictingDocument)>;
    struct ValueIndexConfiguration {
        QueryLanguage expressionLanguage;

        std::string expressions;

        std::string where;
    };

    struct FullTextIndexConfiguration {
        QueryLanguage expressionLanguage;

        std::string expressions;

        bool ignoreAccents;

        std::string language;

        std::string where;
    };

    struct ArrayIndexConfiguration {
        QueryLanguage expressionLanguage;

        std::string path;

        std::string expressions;
    };

    class Collection : private RefCounted {
    public:
        // Accessors:
        
        std::string name() const                        {return internal::asString(CBLCollection_Name(ref()));}
        
        std::string fullName() const                    {return internal::asString(CBLCollection_FullName(ref()));}
        
        std::string scopeName() const {
            auto scope = CBLCollection_Scope(ref());
            auto scopeName = internal::asString(CBLScope_Name(scope));
            CBLScope_Release(scope);
            return scopeName;
        }
        
        Database database() const                       {return Database(CBLCollection_Database(ref()));}
        
        uint64_t count() const                          {return CBLCollection_Count(ref());}
        
        // Documents:
        
        inline Document getDocument(std::string_view docID) const;
        
        inline MutableDocument getMutableDocument(std::string_view docID) const;

        inline void saveDocument(MutableDocument &doc);

        _cbl_warn_unused
        inline bool saveDocument(MutableDocument &doc, CBLConcurrencyControl concurrency);

        _cbl_warn_unused
        inline bool saveDocument(MutableDocument &doc, CollectionConflictHandler handler);

        inline void deleteDocument(Document &doc);

        _cbl_warn_unused
        inline bool deleteDocument(Document &doc, CBLConcurrencyControl concurrency);

        inline void purgeDocument(Document &doc);

        bool purgeDocument(std::string_view docID) {
            CBLError error;
            bool purged = CBLCollection_PurgeDocumentByID(ref(), slice(docID), &error);
            if ( !purged && !(error.domain == kCBLDomain && error.code == kCBLErrorNotFound) )
                internal::check(false, error);
            return purged;
        }
        
        time_t getDocumentExpiration(std::string_view docID) const {
            CBLError error;
            time_t exp = CBLCollection_GetDocumentExpiration(ref(), slice(docID), &error);
            internal::check(exp >= 0, error);
            return exp;
        }

        void setDocumentExpiration(std::string_view docID, time_t expiration) {
            CBLError error;
            internal::check(CBLCollection_SetDocumentExpiration(ref(), slice(docID), expiration, &error), error);
        }
 
        // Indexes:

        void createValueIndex(std::string_view name, ValueIndexConfiguration config) {
            CBLError error;
            internal::check(CBLCollection_CreateValueIndex(ref(), slice(name), {
                config.expressionLanguage,
                slice(config.expressions),
                slice(config.where)
            }, &error), error);
        }
        
        void createFullTextIndex(std::string_view name, FullTextIndexConfiguration config) {
            CBLError error;
            internal::check(CBLCollection_CreateFullTextIndex(ref(), slice(name), {
                config.expressionLanguage,
                slice(config.expressions),
                config.ignoreAccents,
                slice(config.language),
                slice(config.where)
            }, &error), error);
        }

        void createArrayIndex(std::string_view name, ArrayIndexConfiguration config) {
            CBLError error;
            internal::check(CBLCollection_CreateArrayIndex(ref(), slice(name), {
                config.expressionLanguage,
                slice(config.path),
                slice(config.expressions)
            }, &error), error);
        }
 
#ifdef COUCHBASE_ENTERPRISE
        inline void createVectorIndex(std::string_view name, VectorIndexConfiguration config);
#endif

        void deleteIndex(std::string_view name) {
            CBLError error;
            internal::check(CBLCollection_DeleteIndex(ref(), slice(name), &error), error);
        }

        fleece::RetainedArray getIndexNames() {
            CBLError error{};
            FLMutableArray flNames = CBLCollection_GetIndexNames(ref(), &error);
            internal::check(error.code == 0, error);
            fleece::RetainedArray names(flNames);
            FLArray_Release(flNames);
            return names;
        }
        
        inline QueryIndex getIndex(std::string_view name);
        
        // Listeners:
        
        using CollectionChangeListener = cbl::ListenerToken<CollectionChange*>;

        [[nodiscard]] CollectionChangeListener addChangeListener(CollectionChangeListener::Callback callback) {
            auto l = CollectionChangeListener(callback);
            l.setToken( CBLCollection_AddChangeListener(ref(), &_callListener, l.context()) );
            return l;
        }

        using CollectionDocumentChangeListener = cbl::ListenerToken<DocumentChange*>;

        [[nodiscard]] CollectionDocumentChangeListener addDocumentChangeListener(std::string_view docID,
                                                                                 CollectionDocumentChangeListener::Callback callback)
        {
            auto l = CollectionDocumentChangeListener(callback);
            l.setToken( CBLCollection_AddDocumentChangeListener(ref(), slice(docID), &_callDocListener, l.context()) );
            return l;
        }
        
    protected:
 
        static Collection adopt(const CBLCollection* _cbl_nullable d, CBLError *error) {
            internal::check(d != nullptr || error->code == 0, *error);
            Collection col;
            col._ref = (CBLRefCounted*)d;
            return col;
        }
        
        friend class Database;
        friend class Document;
        friend class QueryIndex;
        
        CBL_REFCOUNTED_BOILERPLATE(Collection, RefCounted, CBLCollection);
    
    private:
        
        static void _callListener(void* _cbl_nullable context, const CBLCollectionChange* change);
 
        static void _callDocListener(void* _cbl_nullable context, const CBLDocumentChange* change);
    };

    class CollectionChange {
    public:
        Collection& collection()                    {return _collection;}
        
        std::vector<slice>& docIDs()                {return _docIDs;}
        
        CollectionChange(Collection collection, std::vector<slice> docIDs)
        :_collection(std::move(collection))
        ,_docIDs(std::move(docIDs))
        { }
 
    private:
        
        Collection _collection;
        std::vector<slice> _docIDs;
    };

    class DocumentChange {
    public:
        Collection& collection()                    {return _collection;}
        
        slice& docID()                              {return _docID;}

        DocumentChange(Collection collection, std::string_view docID)
        :_collection(std::move(collection))
        ,_docID(slice(docID))
        { }
        
    private:
        
        Collection _collection;
        slice _docID;
    };
 
    // Database method bodies:
 
    inline Collection Database::getCollection(std::string_view collectionName, std::optional<std::string_view> optScopeName) const {
        CBLError error {};
        slice scopeName = optScopeName.value_or(slice(kCBLDefaultScopeName));
        return Collection::adopt(CBLDatabase_Collection(ref(), slice(collectionName), slice(scopeName), &error), &error) ;
    }
 
    inline Collection Database::createCollection(std::string_view collectionName, std::optional<std::string_view> optScopeName) {
        CBLError error {};
        slice scopeName = optScopeName.value_or(slice(kCBLDefaultScopeName));
        return Collection::adopt(CBLDatabase_CreateCollection(ref(), slice(collectionName), scopeName, &error), &error) ;
    }
 
    inline Collection Database::getDefaultCollection() const {
        CBLError error {};
        return Collection::adopt(CBLDatabase_DefaultCollection(ref(), &error), &error) ;
    }
 
    // Collection method bodies:
 
    inline void Collection::_callListener(void* _cbl_nullable context, const CBLCollectionChange* change) {
        Collection col = Collection((CBLCollection*)change->collection);
        std::vector<slice> docIDs((slice*)&change->docIDs[0], (slice*)&change->docIDs[change->numDocs]);
        auto ch = std::make_unique<CollectionChange>(col, docIDs);
        CollectionChangeListener::call(context, ch.get());
    }
 
    inline void Collection::_callDocListener(void* _cbl_nullable context, const CBLDocumentChange* change) {
        Collection col = Collection((CBLCollection*)change->collection);
        slice docID = change->docID;
        auto ch = std::make_unique<DocumentChange>(col, docID);
        CollectionDocumentChangeListener::call(context, ch.get());
    }
}

template<> struct std::hash<cbl::Collection> {
    std::size_t operator() (cbl::Collection const& col) const {
        auto name = CBLCollection_Name(col.ref());
        auto scope = CBLCollection_Scope(col.ref());
        std::size_t hash = fleece::slice(name).hash() ^ fleece::slice(CBLScope_Name(scope)).hash();
        CBLScope_Release(scope);
        return hash;
    }
};
 
CBL_ASSUME_NONNULL_END