ejdb.hpp

/******************************************************************************
 *
 * C++11 wrapper for EJDB (http://ejdb.org)
 * Copyright (C) 2013 Christian Manning
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
 * USA
 *****************************************************************************/

#ifndef EJDB_HPP
#define EJDB_HPP

#include <memory>
#include <string>
#include <system_error>
#include <vector>
#include <array>
#include <experimental/optional>

#include <boost/config.hpp>

struct EJDB;
struct EJCOLL;
struct EJQ;

#ifndef EJPP_EXPORTS
#define EJPP_EXPORT BOOST_SYMBOL_IMPORT
#else
#define EJPP_EXPORT BOOST_SYMBOL_EXPORT
#endif

#ifndef EJPP_LOCAL
#if defined(__GNUC__)
#define EJPP_LOCAL __attribute__((__visibility__("hidden")))
#else
#define EJPP_LOCAL
#endif
#endif

namespace ejdb {
struct collection;
struct query;

enum class db_mode {
    read = 1 << 0,      
    write = 1 << 1,     
    create = 1 << 2,    
    truncate = 1 << 3,  
    nolock = 1 << 4,    
    noblock = 1 << 5,   
    trans_sync = 1 << 6 
};

constexpr inline db_mode operator|(db_mode lhs, db_mode rhs) noexcept {
    return (db_mode)((std::underlying_type<db_mode>::type)lhs | (std::underlying_type<db_mode>::type)rhs);
}

constexpr inline db_mode& operator|=(db_mode& lhs, db_mode rhs) noexcept { return lhs = lhs | rhs; }

enum class index_mode {
    drop = 1 << 0,     
    drop_all = 1 << 1, 
    optimize = 1 << 2, 
    rebuild = 1 << 3,  
    number = 1 << 4,   
    string = 1 << 5,   
    array = 1 << 6,    
    istring = 1 << 7   
};

constexpr inline index_mode operator|(index_mode lhs, index_mode rhs) noexcept {
    return (index_mode)((std::underlying_type<index_mode>::type)lhs | (std::underlying_type<index_mode>::type)rhs);
}

constexpr inline index_mode& operator|=(index_mode& lhs, index_mode rhs) noexcept { return lhs = lhs | rhs; }

enum class query_search_mode {
    normal = 0,         
    count_only = 1,     
    first_only = 1 << 1 
};

constexpr inline query_search_mode operator|(query_search_mode lhs, query_search_mode rhs) noexcept {
    return (query_search_mode)((std::underlying_type<query_search_mode>::type)lhs |
                               (std::underlying_type<query_search_mode>::type)rhs);
}

constexpr inline query_search_mode& operator|=(query_search_mode& lhs, query_search_mode rhs) noexcept {
    return lhs = lhs | rhs;
}

constexpr inline query_search_mode operator&(query_search_mode lhs, query_search_mode rhs) noexcept {
    return (query_search_mode)((std::underlying_type<query_search_mode>::type)lhs &
                               (std::underlying_type<query_search_mode>::type)rhs);
}

constexpr inline query_search_mode& operator&=(query_search_mode& lhs, query_search_mode rhs) noexcept {
    return lhs = lhs & rhs;
}

enum class errc {
    // Tokyo cabinet error codes
    success,                   
    thread_error,              
    invalid_operation,         
    file_not_found,            
    no_permission,             
    invalid_tc_metadata,       
    invalid_record_header,     
    open_error,                
    close_error,               
    trunc_error,               
    sync_error,                
    stat_error,                
    seek_error,                
    read_error,                
    write_error,               
    mmap_error,                
    lock_error,                
    unlink_error,              
    rename_error,              
    mkdir_error,               
    rmdir_error,               
    keep,                      
    no_record_found,           
    illegal_transaction_state, 
    miscellaneous = 9999,      
    // EJDB error codes
    invalid_collection_name = 9000,          
    invalid_bson = 9001,                     
    invalid_bson_oid = 9002,                 
    invalid_query_control_field = 9003,      
    query_field_require_array = 9004,        
    invalid_metadata = 9005,                 
    invalid_field_path = 9006,               
    invalid_query_regex = 9007,              
    query_result_sort_error = 9008,          
    query_error = 9009,                      
    query_update_failed = 9010,              
    query_elemmatch_limit = 9011,            
    query_cannot_mix_include_exclude = 9012, 
    query_invalid_action = 9013,             
    too_many_collections = 9014,             
    import_export_error = 9015,              
    json_parse_failed = 9016,                
    bson_too_large = 9017,                   
    invalid_command = 9018                   
};

std::error_code make_error_code(errc ecode) noexcept;

} // namespace ejdb

namespace std {
template <> struct is_error_code_enum<ejdb::errc> : public true_type {};
}

namespace ejdb {

struct EJPP_EXPORT db final {
    db() noexcept = default;

    explicit operator bool() const noexcept;

    std::error_code error() const noexcept;
    static std::error_code error(std::weak_ptr<EJDB>) noexcept;

    bool open(const std::string& path, db_mode mode, std::error_code& ec);
    void open(const std::string& path, db_mode mode);

    bool is_open() const noexcept;

    bool close(std::error_code& ec) noexcept;
    void close();

    collection get_collection(const std::string& name, std::error_code& ec) const;
    collection get_collection(const std::string& name) const;

    collection create_collection(const std::string& name, std::error_code& ec);
    collection create_collection(const std::string& name);

    bool remove_collection(const std::string& name, bool unlink_file, std::error_code& ec);
    void remove_collection(const std::string& name, bool unlink_file);

    const std::vector<collection> get_collections() const;

    query create_query(const std::vector<char>& doc, std::error_code& ec);
    query create_query(const std::vector<char>& doc);

    bool sync(std::error_code& ec) noexcept;
    void sync();

    std::vector<char> metadata(std::error_code& ec);
    std::vector<char> metadata();

  private:
    std::shared_ptr<EJDB> m_db;
};

namespace detail {

template <query_search_mode flags>
using query_return_type = typename std::conditional<
    (flags & query_search_mode::count_only) == query_search_mode::count_only, uint32_t,
    typename std::conditional<(flags & query_search_mode::first_only) == query_search_mode::first_only,
                              std::vector<char>, std::vector<std::vector<char>>>::type>::type;
}

struct EJPP_EXPORT collection final {
    collection() noexcept = default;

    explicit operator bool() const noexcept;

    std::experimental::optional<std::array<char, 12>> save_document(const std::vector<char>& data, std::error_code& ec);
    std::experimental::optional<std::array<char, 12>> save_document(const std::vector<char>& data, bool merge,
                                                                    std::error_code& ec);
    std::array<char, 12> save_document(const std::vector<char>& data, bool merge = false);

    std::vector<char> load_document(std::array<char, 12> oid, std::error_code& ec) const;
    std::vector<char> load_document(std::array<char, 12> oid) const;

    bool remove_document(std::array<char, 12>, std::error_code& ec) noexcept;
    void remove_document(std::array<char, 12>);

    bool set_index(const std::string& ipath, index_mode flags, std::error_code& ec);
    void set_index(const std::string& ipath, index_mode flags);

    template <query_search_mode flags = query_search_mode::normal>
    detail::query_return_type<flags> execute_query(const query&);

    std::vector<std::vector<char>> get_all();

    bool sync(std::error_code& ec) noexcept;
    void sync();

    std::string name() const;

    struct transaction_t;

    transaction_t& transaction() noexcept;

  private:
    friend struct db;
    EJPP_LOCAL collection(std::weak_ptr<EJDB> m_db, EJCOLL* m_coll) noexcept;

    std::weak_ptr<EJDB> m_db;
    EJCOLL* m_coll{nullptr};

  public:
    struct transaction_t {
        bool start() noexcept;
        bool commit() noexcept;
        bool abort() noexcept;

        bool in_transaction() const noexcept;
        explicit operator bool() const noexcept;

      private:
        explicit transaction_t(collection*) noexcept;
        transaction_t(transaction_t&&) = default;
        transaction_t& operator=(transaction_t&&) = default;
        transaction_t(const transaction_t& b) = default;
        transaction_t& operator=(const transaction_t&) = default;

        friend struct collection;
        friend struct unique_transaction;
        collection* m_collection;
        std::weak_ptr<EJDB> m_db;
    };

  private:
    transaction_t m_transaction{this};
};

#ifndef DOXYGEN_SHOULD_SKIP_THIS
extern template EJPP_EXPORT detail::query_return_type<query_search_mode::normal>
collection::execute_query<query_search_mode::normal>(const query& qry);
extern template EJPP_EXPORT detail::query_return_type<query_search_mode::count_only>
collection::execute_query<query_search_mode::count_only>(const query& qry);
extern template EJPP_EXPORT detail::query_return_type<query_search_mode::first_only>
collection::execute_query<query_search_mode::first_only>(const query& qry);
extern template EJPP_EXPORT detail::query_return_type<query_search_mode::count_only | query_search_mode::first_only>
collection::execute_query<query_search_mode::count_only | query_search_mode::first_only>(const query& qry);
#endif // DOXYGEN_SHOULD_SKIP_THIS

struct EJPP_EXPORT query final {
    query() noexcept = default;

    explicit operator bool() const noexcept;

    query& operator&=(const std::vector<char>&)&;
    query&& operator&=(const std::vector<char>&)&&;
    query& operator&=(query) & noexcept;
    query&& operator&=(query) && noexcept;

    query& operator|=(const std::vector<char>&)&;
    query&& operator|=(const std::vector<char>&)&&;
    query& operator|=(query) & noexcept;
    query&& operator|=(query) && noexcept;

    query& set_hints(const std::vector<char>&)&;
    query&& set_hints(const std::vector<char>&)&&;

  private:
    friend struct db;
    friend struct collection;
    EJPP_LOCAL query(std::weak_ptr<EJDB> m_db, EJQ* m_qry) noexcept;

    std::weak_ptr<EJDB> m_db;

    struct eqry_deleter {
        void operator()(EJQ* ptr) const noexcept;
    };
    std::unique_ptr<EJQ, eqry_deleter> m_qry;
};

struct adopt_transaction_t {};
struct try_transaction_t {};

constexpr adopt_transaction_t adopt_transaction{};
constexpr try_transaction_t try_transaction{};

struct EJPP_EXPORT unique_transaction {
    unique_transaction() noexcept = default;
    explicit unique_transaction(collection::transaction_t& trans);

    unique_transaction(collection::transaction_t& trans, adopt_transaction_t) noexcept;
    unique_transaction(collection::transaction_t& trans, try_transaction_t) noexcept;

    unique_transaction(unique_transaction&&) noexcept;
    unique_transaction& operator=(unique_transaction&&);

    ~unique_transaction();

    void start();
    void commit();
    void abort();

    collection::transaction_t* release() noexcept;

    bool owns_transaction() const noexcept;
    explicit operator bool() const noexcept;

  private:
    unique_transaction(const unique_transaction&) = delete;
    unique_transaction& operator=(const unique_transaction&) = delete;

    collection::transaction_t* m_trans{nullptr};
    bool m_owns{false};
    std::shared_ptr<EJDB> m_db;
};

struct EJPP_EXPORT transaction_guard : private unique_transaction {
    explicit transaction_guard(collection::transaction_t& trans);
};

} // namespace ejdb

#endif // EJDB_HPP