sqlitepp.h

Go to the documentation of this file.

#pragma once
 
#if __has_include("defs.h")
#include "defs.h"
#endif
 
#include <string>
#include <map>
#include <memory>
#include <cassert>
#include <cstring>
 
#include "safe_winsock.h"
#include <sqlite3/sqlite3.h>
#include "errorcode.h"
 
#ifndef _WIN32
//#include <strings.h>
#endif
 
#if (defined(_MSVC_LANG) && _MSVC_LANG < 202002L)                                                  \
  || (!defined(_MSVC_LANG) && (__cplusplus < 202002L))
#error "sqlitepp requires c++20"
#endif
 
#pragma comment(lib, "sqlite3.lib")
 
namespace mlib {
 
class Query;

class Database
{
public:
  enum class openflags
  {
    readonly = SQLITE_OPEN_READONLY,                     
    readwrite = SQLITE_OPEN_READWRITE,                   
    create          = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 
    uri =           SQLITE_OPEN_URI,                               
    nomutex =       SQLITE_OPEN_NOMUTEX,     
    fullmutex     = SQLITE_OPEN_FULLMUTEX, 
    sharedcache   = SQLITE_OPEN_SHAREDCACHE, 
    privatecache  = SQLITE_OPEN_PRIVATECACHE, 
    memory        = SQLITE_OPEN_MEMORY | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,  
    nofollow      = SQLITE_OPEN_NOFOLLOW, 
    ext_result    = SQLITE_OPEN_EXRESCODE 
  };

  Database ();

  Database (const std::string& name, openflags flags = openflags::create);

  Database& copy (Database& src);

  bool connected ()
  {
    return (bool)db;
  };

  bool is_readonly ();

  operator sqlite3* ()
  {
    return handle ();
  }

  sqlite3* handle () const
  {
    return db ? db.get () : nullptr;
  }

  sqlite3_int64 last_rowid ();

  sqlite3_int64 changes ();

  sqlite3_int64 total_changes ();

  erc open (const std::string& name, openflags flags = openflags::create);

  erc close ();

  erc exec (const std::string& sql);

  checked<Query> make_query (const std::string& sql);

  checked<Query> make_query_multiple (std::string& sql);

  std::string filename (const std::string& schema = "main") const;

  std::string schema (int n) const;

  int extended_error ();

  erc flush ();

  inline static void Errors (mlib::errfac& fac)
  {
    sqlite_errors = &fac;
  }

  inline static const errfac& Errors ()
  {
    return *sqlite_errors;
  }
 
private:
  std::shared_ptr<sqlite3> db;
  friend class Query;
 
  static errfac* sqlite_errors;
};

class Query
{
  friend class Database;
 
public:
  Query ();

  Query (Database& db, const std::string& sql = std::string ());

  Query (const Query& other);

  Query (Query&& other);

  Query& operator= (Query&& rhs);

  Query& operator= (const Query& rhs);
 
  ~Query ();

  operator sqlite3_stmt* ();

  Query& operator= (const std::string& str);

  Query& sql (const std::string& str);

  std::string sql () const;

  operator std::string () const;

  erc step ();
 
  Query& bind (int par, const std::string& val);
  Query& bind (const std::string& parname, const std::string& val);
  Query& bind (int par, int val);
  Query& bind (const std::string& parname, int val);
  Query& bind (int par, double val);
  Query& bind (const std::string& parname, double val);
  Query& bind (int par, sqlite3_int64 val);
  Query& bind (const std::string& parname, sqlite3_int64 val);
  Query& bind (int par, void* val, int len);
  Query& bind (const std::string& parname, void* val, int len);
#ifdef _WIN32
  Query& bind (int par, const SYSTEMTIME& st);
  Query& bind (const std::string& parname, const SYSTEMTIME& st);
#endif
 
  Query& clear_bindings ();
 
  int column_int (int nc) const;
  int column_int (const std::string& colname) const;
 
  std::string column_str (int nc) const;
  std::string column_str (const std::string& colname) const;
 
  const char* column_text (int nc) const;
  const char* column_text (const std::string& colname) const;
 
  double column_double (int nc) const;
  double column_double (const std::string& colname) const;
 
  sqlite3_int64 column_int64 (int nc) const;
  sqlite3_int64 column_int64 (const std::string& name) const;
 
  const void* column_blob (int nc) const;
  const void* column_blob (const std::string& name) const;
 
#ifdef _WIN32
  SYSTEMTIME column_time (int nc) const;
  SYSTEMTIME column_time (const std::string& name) const;
#endif
 
  int column_type (int nc) const;
  int column_type (const std::string& colname) const;
 
  int column_size (int nc) const;
  int column_size (const std::string& colname) const;
 
#ifndef SQLITE_OMIT_DECLTYPE
  std::string decl_type (int nc) const;
  std::string decl_type (const std::string& colname) const;
#endif
 
#ifdef SQLITE_ENABLE_COLUMN_METADATA
  std::string table_name (int nc) const;
  std::string table_name (const std::string& colname) const;
 
  std::string database_name (int nc) const;
  std::string database_name (const std::string& colname) const;
#endif
 
  std::string column_name (int nc) const;

  int columns ();

  erc reset ();

  void clear ();
 
private:
  void map_columns () const;
  int find_col (const std::string& colname) const;
  erc check_errors (int rc);
 
  sqlite3_stmt* stmt;
  Database dbase;

  struct iless
  {
    bool operator() (const std::string& left, const std::string& right) const;
  };
 
  std::map<std::string, int, Query::iless> mutable index;
  bool mutable col_mapped;
};
 
/*==================== INLINE FUNCTIONS ===========================*/
inline sqlite3_int64 Database::last_rowid ()
{
  assert (db);
  return sqlite3_last_insert_rowid (db.get ());
}
 
inline sqlite3_int64 Database::changes ()
{
  assert (db);
  return sqlite3_changes64 (db.get ());
}
 
inline sqlite3_int64 mlib::Database::total_changes ()
{
  assert (db);
  return sqlite3_total_changes64 (db.get ());
}
 
inline Query::Query ()
  : stmt (0)
  , col_mapped (false)
{}
 
inline Query::operator sqlite3_stmt* ()
{
  return stmt;
}
 
inline int Query::columns ()
{
  return sqlite3_column_count (stmt);
}

inline Query& Query::operator= (const std::string& str)
{
  return sql (str);
}
 
inline bool Query::iless::operator() (const std::string& left, const std::string& right) const
{
#ifdef _WIN32
  return _strcmpi (left.c_str (), right.c_str ()) < 0;
#else
  return strcasecmp (left.c_str (), right.c_str ()) < 0;
#endif
}

inline Query::operator std::string () const
{
  return sql ();
}
 
inline Database::openflags operator| (const Database::openflags& f1, const Database::openflags& f2)
{
  return static_cast<Database::openflags> (static_cast<int> (f1) | static_cast<int> (f2));
}
 
}; // namespace mlib