sqlite.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <sqlite3.h>
 
#include <optional>
#include <string>
#include <vector>
#include <tuple>
#include <stdexcept>
 
namespace sqlite {
  class SQLiteError: public std::runtime_error {
  public:
    explicit SQLiteError(int code, const std::string& prefix = ""): std::runtime_error(prefix + sqlite3_errstr(code)), m_code(code) {}
    int code() const { return m_code; }
  private:
    int m_code; 
  };
 
  namespace detail {
    inline void checkSQLiteError(int code, const std::string& prefix = "")
    {
      if (code != SQLITE_OK) throw SQLiteError(code, prefix);
    }
 
    class ColumnFiller {
    public:
      explicit ColumnFiller(sqlite3_stmt* statement): m_stmt(statement) {}
      void operator()(int index, int& col) { col = sqlite3_column_int(m_stmt, index); }
      void operator()(int index, int64_t& col) { col = sqlite3_column_int(m_stmt, index); }
      void operator()(int index, double& col) { col = sqlite3_column_double(m_stmt, index); }
      void operator()(int index, std::string& col)
      {
        // ptr is owned by sqlite, no need to free but we need to copy
        if (auto ptr = reinterpret_cast<const char*>(sqlite3_column_text(m_stmt, index)); ptr != nullptr) {
          col = ptr;
        }
      }
      void operator()(int index, std::vector<std::byte>& col)
      {
        // ptr is owned by sqlite, no need to free but we need to copy
        if (auto ptr = reinterpret_cast<const std::byte*>(sqlite3_column_blob(m_stmt, index)); ptr != nullptr) {
          size_t bytes = sqlite3_column_bytes(m_stmt, index);
          col = std::vector<std::byte>(ptr, ptr + bytes);
        }
      }
      template<class T>
      void operator()(int index, std::optional<T>& col)
      {
        if (sqlite3_column_type(m_stmt, index) != SQLITE_NULL) {
          col.emplace();
          (*this)(index, *col);
        }
      }
    private:
      sqlite3_stmt* m_stmt; 
    };
 
    class ParameterBinder {
    public:
      explicit ParameterBinder(sqlite3_stmt* statement): m_stmt(statement) {}
 
      template<class T>
      void operator()(int index, T&& param)
      {
        // For some reason bind parameters start at one ...
        checkSQLiteError(bind(index + 1, std::forward<T>(param)));
      }
    private:
      int bind(int index, int param) { return sqlite3_bind_int(m_stmt, index, param);}
      int bind(int index, int64_t param) { return sqlite3_bind_int64(m_stmt, index, param); }
      int bind(int index, double param) { return sqlite3_bind_double(m_stmt, index, param);}
      int bind(int index, const std::string& param)
      {
        return sqlite3_bind_text(m_stmt, index, param.data(), param.size(), SQLITE_TRANSIENT);
      }
      int bind(int index, const std::vector<std::byte>& param)
      {
        return sqlite3_bind_blob(m_stmt, index, param.data(), param.size(), SQLITE_TRANSIENT);
      }
      template<class T>
      int bind(int index, const std::optional<T>& param)
      {
        if (param.has_value()) return bind(*param);
        return sqlite3_bind_null(m_stmt, index);
      }
      sqlite3_stmt* m_stmt; 
    };
 
    template<class Tuple, class Func, std::size_t ...Is>
    void visitTupleWithIndexImpl(Tuple&& t, Func&& f, std::index_sequence<Is...>)
    {
      // C++17 fold expression to just do all the calls in one  separated by "," operator ...
      (f(std::integral_constant<std::size_t, Is> {}, std::get<Is>(t)), ...);
    }
 
    template<class ... T, class Func>
    void visitTupleWithIndex(std::tuple<T...>& t, Func&& f)
    {
      visitTupleWithIndexImpl(t, std::forward<Func>(f), std::make_index_sequence<sizeof...(T)> {});
    }
  }
 
  template<class ObjectType, class ... Columns>
  class ObjectStatement {
  public:
    using value_type = ObjectType;
 
    class iterator {
    public:
 
      using iterator_category = std::input_iterator_tag;
 
      using value_type = ObjectType;
 
      using difference_type = size_t;
 
      using pointer = value_type*;
 
      using reference = value_type&;
 
      iterator() = default;
      explicit iterator(ObjectStatement* instance): m_instance(instance), m_row{0}
      {
        (*this)++;
      }
      iterator& operator++()
      {
        if (m_row < 0) return *this;
        ++m_row;
        if (!m_instance->step()) m_row = -1;
        return *this;
      }
      iterator operator++(int) {iterator retval = *this; ++(*this); return retval;}
      bool operator==(const iterator& other) const { return m_row == other.m_row; }
      bool operator!=(const iterator& other) const { return m_row != other.m_row; }
      value_type operator*() const { return m_instance->getRow(); }
    private:
      ObjectStatement* m_instance{nullptr};
      int64_t m_row{ -1};
    };
 
    iterator begin() { return iterator(this); }
    iterator end() const { return iterator(); }
 
    ObjectStatement(sqlite3* db, const std::string& query, bool persistent)
    {
      detail::checkSQLiteError(sqlite3_prepare_v3(db, query.data(), query.size(), persistent ? SQLITE_PREPARE_PERSISTENT : 0,
                                                  &m_statement, nullptr), "Cannot prepare database statement: ");
      if (auto cols = sqlite3_column_count(m_statement); cols != sizeof...(Columns)) {
        throw std::runtime_error("Number of column (" + std::to_string(cols) + ") doesn't match number of template parameters (" +
                                 std::to_string(sizeof...(Columns)) + ')');
      }
    }
    ~ObjectStatement() { if (m_statement) sqlite3_finalize(m_statement); }
 
    template<class ... Parameters>
    ObjectStatement& execute(Parameters... parameters)
    {
      if (auto params = sqlite3_bind_parameter_count(m_statement); params != sizeof...(Parameters)) {
        throw std::runtime_error("Number of arguments (" + std::to_string(sizeof...(Parameters)) +
                                 ") doesn't match number of statement parameters (" + std::to_string(params) + ")");
      }
      sqlite3_reset(m_statement);
      auto parameter_tuple = std::make_tuple(parameters...);
      detail::visitTupleWithIndex(parameter_tuple, detail::ParameterBinder{m_statement});
      return *this;
    }
 
    bool step()
    {
      if (auto ret = sqlite3_step(m_statement); ret != SQLITE_ROW) {
        if (ret == SQLITE_DONE) return false;
        detail::checkSQLiteError(ret);
      }
      return true;
    }
 
    value_type getRow() const
    {
      std::tuple<Columns...> result;
      detail::visitTupleWithIndex(result, detail::ColumnFiller{m_statement});
      return std::make_from_tuple<value_type>(std::move(result));
    }
  private:
    sqlite3_stmt* m_statement{nullptr};
  };
 
  template<class ... Columns> using Statement = ObjectStatement<std::tuple<Columns...>, Columns...>;
  template<class T> using SimpleStatement = ObjectStatement<T, T>;
 
  class Connection {
  public:
    explicit Connection(const std::string& filename)
    {
      detail::checkSQLiteError(sqlite3_open_v2(filename.c_str(), &m_connection, SQLITE_OPEN_READONLY, nullptr));
    }
    ~Connection() { if (m_connection) sqlite3_close_v2(m_connection); }
    template<class ... Columns>
    Statement<Columns...> prepare(const std::string& query, bool persistent = false) { return Statement<Columns...>(m_connection, query, persistent); }
    operator sqlite3* () const { return m_connection; }
  private:
    sqlite3* m_connection;
  };
}