sqlite3pp.h

// sqlite3pp.h
//
// The MIT License
//
// Copyright (c) 2015 Wongoo Lee (iwongu at gmail dot com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

//////////////////////////////////////////////////////////////////////////////////////////
// Mod Author: David Maisonave - Sep-2025
// This a modified version of [Wongoo Lee] original sqlite3pp.
// - Source comes from the following link: https://github.com/iwongu/sqlite3pp
// This version was originally modified by David Maisonave Nov-2021,
// and then additional modifications made in Sep-2025.
// 
// Most of the 2025 changes are associated with compiling with manage C++ code,
// using SQLiteDLLConnect.h which has a manage class SQLiteDLLConnect, 
// and allows run time linking to SQLite3.dll with manage C++ code.
// 
// Changes:
// - Added UNICODE API's.
// - Change some names to avoid spell checker errors.
// - Changed local include to use "" instead of <>, to avoid compiler error on some systems.
// - Added functions that take std::string
// - Added enhance logic to connect to SQLite3.db at runtime when compiling CLR code.
// - Other miscellaneous changes where I added comments [David Maisonave changes]
//
// For example usage see [Wongoo Lee] github link: https://github.com/iwongu/sqlite3pp

#ifndef SQLITE3PP_H
#define SQLITE3PP_H

// [David Maisonave changes] -- commented out the following macros which where not being used, but was producing compiler warnings.
//#define SQLITE3PP_VERSION "1.0.8"
//#define SQLITE3PP_VERSION_MAJOR 1
//#define SQLITE3PP_VERSION_MINOR 0
//#define SQLITE3PP_VERSION_PATCH 8

#include <functional>
#include <iterator>
#include <stdexcept>
#include <string>
#include <tuple>
#include <vector> // [David Maisonave changes] -- Required for Blob & Clob types
#include <memory> // [David Maisonave changes] -- Required for Blob & Clob types
#include <ctime>  // [David Maisonave changes] -- Required for Date & Datetime types

#ifdef __CLR_VER // [David Maisonave changes] -- Used for run time level connection to SQLite3.dll
#define SQLITE_MANAGE_CODE
#endif

#ifdef SQLITE3PP_LOADABLE_EXTENSION
#include "sqlite3ext.h"
SQLITE_EXTENSION_INIT1
#else
#include "sqlite3.h"
#endif

#ifdef SQLITE_MANAGE_CODE // [David Maisonave changes] -- Used for run time level connection to SQLite3.dll
#include "SQLiteDLLConnect.h"
#define SQLITEDLLCONNECT SQLiteDLLConnect::
#define SQLITE_DLLCONNECT runTimeConnect.
#else
#define SQLITEDLLCONNECT
#define SQLITE_DLLCONNECT
#endif

namespace sqlite3pp
{
	class database;
	namespace ext
	{
		class function;
		class aggregate;
		database borrow(sqlite3* pdb);
	}

#if defined(SQLITE3PP_NO_UNICODE) || !defined(_UNICODE)
	using tstring = std::string;
#else
	using tstring = std::wstring;
#endif // SQLITE3PP_NO_UNICODE || !_UNICODE

#ifndef SQLITE3PP_CONVERT_TO_RESULTING_AFFINITY
	// SQLite3 types (Excluding string types)
	using Blob = std::shared_ptr<std::vector<unsigned char> >;// Stores binary data
	using Clob = std::shared_ptr< std::vector<char> >;	// Stores strings that can have multiple NULL terminators
	struct Date	{std::time_t t;};
	struct Datetime	{std::tm tm_struct;};
	using TEXT = tstring;
#endif //!SQLITE3PP_CONVERT_TO_RESULTING_AFFINITY	
  template <class T>
  struct convert {
	using to_int = int;
  };

  class null_type {};
  extern null_type ignore;

  class NonCopyable
  {
   protected:
	NonCopyable() = default;
	~NonCopyable() = default;

	NonCopyable(NonCopyable&&) = default;
	NonCopyable& operator=(NonCopyable&&) = default;

	NonCopyable(NonCopyable const&) = delete;
	NonCopyable& operator=(NonCopyable const&) = delete;
  };

  class database : NonCopyable
  {
#ifdef SQLITE_MANAGE_CODE
		SQLite_DLL::RunTimeConnect* runTimeConnect = NULL;// [David Maisonave changes] -- Used for run time level connection to SQLite3.dll
#endif
	friend class statement;
	friend class database_error;
	friend class ext::function;
	friend class ext::aggregate;
	friend database ext::borrow(sqlite3* pdb);

   public:
	using busy_handler = std::function<int (int)>;
	using commit_handler = std::function<int ()>;
	using rollback_handler = std::function<void ()>;
	using update_handler = std::function<void (int, char const*, char const*, long long int)>;
	using authorize_handler = std::function<int (int, char const*, char const*, char const*, char const*)>;
	using backup_handler = std::function<void (int, int, int)>;

	explicit database( char const* dbname = nullptr, int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, const char* vfs = nullptr );
	database(database&& db);
	database& operator=(database&& db);
	database(const std::string dbname, int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, const char* vfs = nullptr);// [David Maisonave changes] -- Add std::string support
	database(sqlite3* pdb); // [David Maisonave changes] -- Not sure why this was made private, but this constructor can be usefull when mixing classes of similar type.
	~database();
	
#ifndef SQLITE3PP_NO_UNICODE	
	// Unicode support
	explicit database( const  wchar_t* dbname, int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, const wchar_t* vfs = nullptr );
	int connect( const  wchar_t* dbname, int flags, const wchar_t* vfs = nullptr );
	int execute( const std::wstring& sql );
	int attach(const  wchar_t* dbname, const  wchar_t* name);
	int detach(const  wchar_t* name);
	int backup(const  wchar_t* dbname, database& destdb, const  wchar_t* destdbname, backup_handler h, int step_page = 5);
#endif //!SQLITE3PP_NO_UNICODE

	int connect( char const* dbname, int flags, const char* vfs = nullptr );
	int disconnect();

	int attach(char const* dbname, char const* name);
	int detach(char const* name);

	int backup(database& destdb, backup_handler h = {});
	int backup(char const* dbname, database& destdb, char const* destdbname, backup_handler h, int step_page = 5);

	long long int last_insert_rowid() const;

	int enable_foreign_keys(bool enable = true);
	int enable_triggers(bool enable = true);
	int enable_extended_result_codes(bool enable = true);

	int changes() const;

	int error_code() const;
	int extended_error_code() const;
	char const* error_msg() const;

	int execute( char const* sql );
		// int executef(char const* sql, ...);// [David Maisonave changes] -- Removed this variadic function of executef because could not compile it in manage C++ code.
		int execute(const std::string& sql);// [David Maisonave changes] -- Adding std::string capabilities
	int set_busy_timeout(int ms);

	void set_busy_handler(busy_handler h);
	void set_commit_handler(commit_handler h);
	void set_rollback_handler(rollback_handler h);
	void set_update_handler(update_handler h);
	void set_authorize_handler(authorize_handler h);

   private:
		int executef(char const* sql, const char* dbname, const char* name);// [David Maisonave changes] -- Added this to replace associated variadic function which doesn't compile in manage C++ code.
		int executef(char const* sql, const char* name);// [David Maisonave changes] -- Added this to replace associated variadic function which doesn't compile in manage C++ code.
   private:
	sqlite3* db_;
	bool borrowing_;

	busy_handler bh_;
	commit_handler ch_;
	rollback_handler rh_;
	update_handler uh_;
	authorize_handler ah_;
  };

  class database_error : public std::runtime_error
  {
   public:
	explicit database_error(char const* msg);
		explicit database_error(const std::string& msg);// [David Maisonave changes] -- Adding std::string capabilities
	explicit database_error(database& db);
  };

  enum copy_semantic { copy, nocopy };
	class statement : NonCopyable
  {
   public:
	int prepare(char const* stmt);
	int finish();

	int bind(int idx, int value);
	int bind(int idx, double value);
	int bind(int idx, long long int value);
	int bind(int idx, char const* value, copy_semantic fcopy);
	int bind(int idx, void const* value, int n, copy_semantic fcopy);
	int bind(int idx, std::string const& value, copy_semantic fcopy);
	int bind(int idx);
	int bind(int idx, null_type);

	int bind(char const* name, int value);
	int bind(char const* name, double value);
	int bind(char const* name, long long int value);
	int bind(char const* name, char const* value, copy_semantic fcopy);
	int bind(char const* name, void const* value, int n, copy_semantic fcopy);
	int bind(char const* name, std::string const& value, copy_semantic fcopy);
	int bind(char const* name);
	int bind(char const* name, null_type);

	int step();
	int reset();

   protected:
	explicit statement(database& db, char const* stmt = nullptr);
	~statement();

	int prepare_impl(char const* stmt);
	int finish_impl(sqlite3_stmt* stmt);

   protected:
	database& db_;
	sqlite3_stmt* stmt_;
	char const* tail_;
#ifndef SQLITE3PP_NO_UNICODE
	explicit statement( database& db, wchar_t const* stmt = nullptr );
	int prepare_impl( wchar_t const* stmt);
   public:
	int prepare( wchar_t const* stmt);
#endif // !SQLITE3PP_NO_UNICODE
  };

  class command : public statement
  {
   public:
	class BindStream
	{
	 public:
	  BindStream(command& cmd, int idx);

	  template <class T>
	  BindStream& operator << (T value) {
		auto rc = cmd_.bind(idx_, value);
		if (rc != SQLITE_OK) {
		  throw database_error(cmd_.db_);
		}
		++idx_;
		return *this;
	  }
	  BindStream& operator << (char const* value) {
		auto rc = cmd_.bind(idx_, value, copy);
		if (rc != SQLITE_OK) {
		  throw database_error(cmd_.db_);
		}
		++idx_;
		return *this;
	  }
	  BindStream& operator << (std::string const& value) {
		auto rc = cmd_.bind(idx_, value, copy);
		if (rc != SQLITE_OK) {
		  throw database_error(cmd_.db_);
		}
		++idx_;
		return *this;
	  }

	 private:
	  command& cmd_;
	  int idx_;
	};

	explicit command(database& db, char const* stmt = nullptr);

	BindStream binder(int idx = 1);

	int execute();
	int execute_all();
  };

  class query : public statement
  {
   public:
	class rows
	{
	 public:
	  class GetStream
	  {
	   public:
		GetStream(rows* rws, int idx);

		template <class T>
		GetStream& operator >> (T& value) {
		  value = rws_->get(idx_, T());
		  ++idx_;
		  return *this;
		}

	   private:
		rows* rws_;
		int idx_;
	  };

	  explicit rows(sqlite3_stmt* stmt);

	  int data_count() const;
	  int column_type(int idx) const;

	  int column_bytes(int idx) const;

	  template <class T> T get(int idx) const {
		return get(idx, T());
	  }

	  template <class... Ts>
	  std::tuple<Ts...> get_columns(typename convert<Ts>::to_int... idxs) const {
		return std::make_tuple(get(idxs, Ts())...);
	  }

	  GetStream getter(int idx = 0);

	 private:
	  int get(int idx, int) const;
	  double get(int idx, double) const;
	  long long int get(int idx, long long int) const;
	  char const* get(int idx, char const*) const;

	  //////////////////////////////////////////////////////////////////////////////////
	  // Start SQLite3pp_EZ changes
	  // To minimize changes in original SQLite3pp.cpp code, the implementation for this section is in SQLite3pp_EZ.cpp
#ifndef SQLITE3PP_CONVERT_TO_RESULTING_AFFINITY
#ifndef SQLITE3PP_NO_UNICODE
	  wchar_t const* get(int idx, wchar_t const*) const;
	  std::wstring get(int idx, const std::wstring&value) const;
#endif// !SQLITE3PP_NO_UNICODE
	  unsigned char get(int idx, const unsigned char&) const;
	  short int get(int idx, const short int&) const;
	  bool get(int idx, const bool&) const;
	  unsigned long long int get(int idx, const unsigned long long int&) const;
	  Blob get(int idx, const Blob&) const;
	  Clob get(int idx, const Clob&) const;
	  Date get(int idx, const Date&) const;
	  Datetime get(int idx, const Datetime&) const;
#endif// !SQLITE3PP_CONVERT_TO_RESULTING_AFFINITY
	  // End SQLite3pp_EZ changes
	  //////////////////////////////////////////////////////////////////////////////////
	  std::string get(int idx, std::string) const;
	  void const* get(int idx, void const*) const;
	  null_type get(int idx, null_type) const;

	 private:
	  sqlite3_stmt* stmt_;
	};
#pragma warning (disable : 4996) // [David Maisonave changes] -- Remove compiler warning for deprecated iterator.
		class query_iterator : public std::iterator<std::input_iterator_tag, rows>
	{
	 public:
	  query_iterator();
	  explicit query_iterator(query* cmd);

	  bool operator==(query_iterator const&) const;
	  bool operator!=(query_iterator const&) const;

	  query_iterator& operator++();
			value_type operator*() const;
	 private:
	  query* cmd_;
	  int rc_;
	};

	explicit query( database& db, char const* stmt = nullptr );
#ifndef SQLITE3PP_NO_UNICODE
	explicit query( database& db, wchar_t const* stmt );
#endif //!SQLITE3PP_NO_UNICODE
	int column_count() const;

	char const* column_name(int idx) const;
	char const* column_decltype(int idx) const;

	using iterator = query_iterator;

	iterator begin();
	iterator end();
  };

	class transaction : NonCopyable
  {
   public:
	explicit transaction(database& db, bool fcommit = false, bool freserve = false);
	~transaction();

	int commit();
	int rollback();

   private:
	database* db_;
	bool fcommit_;
  };

} // namespace sqlite3pp

#endif