ngen_sqlite.hpp

#ifndef NGEN_GEOPACKAGE_SQLITE_H
#define NGEN_GEOPACKAGE_SQLITE_H
 
#include <memory>
#include <vector>
 
#include <sqlite3.h>
 
#include <boost/core/span.hpp>
#include "traits.hpp"
 
namespace ngen {
namespace sqlite {
 
struct sqlite_error : public std::runtime_error
{
    using std::runtime_error::runtime_error;
 
    sqlite_error(const std::string& origin_func, int code, const std::string& extra = "");
};
 
class database
{
    struct deleter
    {
        void operator()(sqlite3* db)
        {
            sqlite3_close_v2(db);
        }
 
        void operator()(sqlite3_stmt* stmt)
        {
            sqlite3_finalize(stmt);
        }
    };
 
    using sqlite_t = std::unique_ptr<sqlite3, deleter>;
    using stmt_t   = std::unique_ptr<sqlite3_stmt, deleter>;
 
  public:
    struct iterator
    {
        iterator() = delete;
 
        explicit iterator(stmt_t&& stmt);
 
        bool done() const noexcept;
 
        iterator& next();
 
        iterator& restart();
 
        int current_row() const noexcept;
 
        int num_columns() const noexcept;
 
        int find(const std::string& name) const noexcept;
 
        const boost::span<const std::string> columns() const noexcept;
 
        const boost::span<const int> types() const noexcept;
 
 
        template<typename Tp>
        Tp get(int col) const;
 
        template<typename Tp>
        Tp get(const std::string& col) const
        { return get<Tp>(find(col)); }
 
      private:
 
        sqlite3_stmt* ptr_() const noexcept;
        void          handle_get_index_(int col) const;
 
        stmt_t stmt_;
    
        int step_ = -1;
        int done_ = false;
        int ncol_ = 0;
 
        std::vector<std::string> names_;
        std::vector<int>         types_;
    }; // struct iterator
 
    // Prevent default construction and copy
    // construction/assignment.
    database()                           = delete;
    database(const database&)            = delete;
    database& operator=(const database&) = delete;
 
    // Allow move operations
    database(database&&)            = default;
    database& operator=(database&&) = default;
    ~database()                     = default;
 
    explicit database(const std::string& path);
 
 
    sqlite3* connection() const noexcept;
 
    bool contains(const std::string& table);
 
    iterator query(const std::string& statement, const boost::span<const std::string> binds = {});
 
    template<
        typename... Ts,
        std::enable_if_t<
            ngen::traits::all_is_convertible<std::string, Ts...>::value,
            bool
        > = true
    >
    iterator query(const std::string& statement, const Ts&... params)
    {
        std::array<std::string, sizeof...(params)> binds = { params... };
        return query(statement, binds);
    }
 
  private:
    sqlite_t conn_ = nullptr;
};
 
} // namespace sqlite
} // namespace ngen
 
#endif // NGEN_GEOPACKAGE_SQLITE_H