sqlite.h

Go to the documentation of this file.

#ifndef DBALLE_SQL_SQLITE_H
#define DBALLE_SQL_SQLITE_H
 
#include <dballe/core/error.h>
#include <dballe/sql/sql.h>
#include <functional>
#include <sqlite3.h>
#include <vector>
 
namespace dballe {
namespace sql {
struct SQLiteStatement;

struct error_sqlite : public dballe::error_db
{
    std::string msg;
 
    error_sqlite(sqlite3* db, const std::string& msg);
    error_sqlite(const std::string& dbmsg, const std::string& msg);
    ~error_sqlite() noexcept {}
 
    const char* what() const noexcept override { return msg.c_str(); }
 
    static void throwf(sqlite3* db, const char* fmt, ...)
        WREPORT_THROWF_ATTRS(2, 3);
};

class SQLiteConnection : public Connection
{
protected:
    std::string pathname;
    int flags   = 0;
    sqlite3* db = nullptr;
    bool forked = false;
 
    void init_after_connect();
    static void on_sqlite3_profile(void* arg, const char* query,
                                   sqlite3_uint64 usecs);
 
    SQLiteConnection();
 
    void fork_prepare() override;
    void fork_parent() override;
    void fork_child() override;
 
    void check_connection();
 
    void reopen();
 
public:
    SQLiteConnection(const SQLiteConnection&)  = delete;
    SQLiteConnection(const SQLiteConnection&&) = delete;
    ~SQLiteConnection();
 
    static std::shared_ptr<SQLiteConnection> create();
 
    SQLiteConnection& operator=(const SQLiteConnection&) = delete;
 
    operator sqlite3*() { return db; }
 
    void open_file(const std::string& pathname,
                   int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
    void open_memory(int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
    void open_private_file(int flags = SQLITE_OPEN_READWRITE |
                                       SQLITE_OPEN_CREATE);
 
    std::unique_ptr<Transaction> transaction(bool readonly = false) override;
    std::unique_ptr<SQLiteStatement> sqlitestatement(const std::string& query);
 
    bool has_table(const std::string& name) override;
    std::string get_setting(const std::string& key) override;
    void set_setting(const std::string& key, const std::string& value) override;
    void drop_settings() override;
    void execute(const std::string& query) override;
    void explain(const std::string& query, FILE* out) override;

    void drop_table_if_exists(const char* name);

    int get_last_insert_id();

    int changes();

    void exec(const std::string& query);
    void exec_nothrow(const std::string& query) noexcept;
 
#if SQLITE_VERSION_NUMBER >= 3014000
    void trace(unsigned mask = SQLITE_TRACE_STMT);
#endif
};

struct SQLiteStatement
{
    SQLiteConnection& conn;
    std::string query;
    sqlite3_stmt* stm = nullptr;
 
    SQLiteStatement(SQLiteConnection& conn, const std::string& query);
    SQLiteStatement(const SQLiteStatement&)  = delete;
    SQLiteStatement(const SQLiteStatement&&) = delete;
    ~SQLiteStatement();
    SQLiteStatement& operator=(const SQLiteStatement&) = delete;

    template <typename... Args> void bind(const Args&... args)
    {
        bindn<sizeof...(args)>(args...);
    }
 
    void bind_null_val(int idx);
    void bind_val(int idx, int val);
    void bind_val(int idx, unsigned val);
    void bind_val(int idx, unsigned short val);
    void bind_val(int idx, const Datetime& val);
    void bind_val(int idx, const char* val); // Warning: SQLITE_STATIC is used
    void bind_val(int idx,
                  const std::string& val); // Warning: SQLITE_STATIC is used
    void
    bind_val(int idx,
             const std::vector<uint8_t>& val); // Warning: SQLITE_STATIC is used

    void execute();

    void execute(std::function<void()> on_row);

    void execute_one(std::function<void()> on_row);

    int column_int(int col) { return sqlite3_column_int(stm, col); }

    sqlite3_int64 column_int64(int col)
    {
        return sqlite3_column_int64(stm, col);
    }

    double column_double(int col) { return sqlite3_column_double(stm, col); }

    const char* column_string(int col)
    {
        return (const char*)sqlite3_column_text(stm, col);
    }

    std::vector<uint8_t> column_blob(int col)
    {
        int size           = sqlite3_column_bytes(stm, col);
        const uint8_t* val = (const uint8_t*)sqlite3_column_blob(stm, col);
        return std::vector<uint8_t>(val, val + size);
    }

    Datetime column_datetime(int col);

    bool column_isnull(int col)
    {
        return sqlite3_column_type(stm, col) == SQLITE_NULL;
    }
 
    void wrap_sqlite3_reset();
    void wrap_sqlite3_reset_nothrow() noexcept;
    [[noreturn]] void reset_and_throw(const std::string& errmsg);
 
    operator sqlite3_stmt*() { return stm; }
#if 0
    int execute();
    int exec_direct(const char* query);
    int exec_direct(const char* query, int qlen);

    int execute_and_close();
    int exec_direct_and_close(const char* query);
    int exec_direct_and_close(const char* query, int qlen);

    int columns_count();
    bool fetch();
    bool fetch_expecting_one();
    void close_cursor();
    void close_cursor_if_needed();
    size_t select_rowcount();
    size_t rowcount();
#endif
 
private:
    // Implementation of variadic bind: terminating condition
    template <size_t total> void bindn() {}
    // Implementation of variadic bind: recursive iteration over the parameter
    // pack
    template <size_t total, typename... Args, typename T>
    void bindn(const T& first, const Args&... args)
    {
        bind_val(total - sizeof...(args), first);
        bindn<total>(args...);
    }
};
 
} // namespace sql
} // namespace dballe
#endif