// file : odb/sqlite/database.hxx // copyright : Copyright (c) 2009-2017 Code Synthesis Tools CC // license : GNU GPL v2; see accompanying LICENSE file #ifndef ODB_SQLITE_DATABASE_HXX #define ODB_SQLITE_DATABASE_HXX #include #include #include #include // std::ostream #include #include // ODB_CXX11 #include #include #include #include #include #include #include #include #include #include // We use the sqlite3_open_v2() flags in our interface. Define them // for SQLite earlier that 3.5.0. // #if SQLITE_VERSION_NUMBER < 3005000 # define SQLITE_OPEN_READONLY 0x00000001 # define SQLITE_OPEN_READWRITE 0x00000002 # define SQLITE_OPEN_CREATE 0x00000004 #endif namespace odb { namespace sqlite { class transaction_impl; class LIBODB_SQLITE_EXPORT database: public odb::database { public: database (const std::string& name, int flags = SQLITE_OPEN_READWRITE, bool foreign_keys = true, const std::string& vfs = "", details::transfer_ptr = details::transfer_ptr ()); #ifdef _WIN32 database (const std::wstring& name, int flags = SQLITE_OPEN_READWRITE, bool foreign_keys = true, const std::string& vfs = "", details::transfer_ptr = details::transfer_ptr ()); #endif // Extract the database parameters from the command line. The // following options are recognized: // // --database // --create // --read-only // --options-file // // For more information, see the output of the print_usage() function // below. If erase is true, the above options are removed from the argv // array and the argc count is updated accordingly. The command line // options override the flags passed as an argument. This constructor // may throw the cli_exception exception. // database (int& argc, char* argv[], bool erase = false, int flags = SQLITE_OPEN_READWRITE, bool foreign_keys = true, const std::string& vfs = "", details::transfer_ptr = details::transfer_ptr ()); // Move-constructible but not move-assignable. // #ifdef ODB_CXX11 database (database&&); #endif static void print_usage (std::ostream&); public: const std::string& name () const { return name_; } int flags () const { return flags_; } bool foreign_keys () const { return foreign_keys_; } const std::string& vfs () const { return vfs_; } // Object persistence API. // public: // Make the object persistent. // template typename object_traits::id_type persist (T& object); template typename object_traits::id_type persist (const T& object); template typename object_traits::id_type persist (T* obj_ptr); template class P> typename object_traits::id_type persist (const P& obj_ptr); template class P> typename object_traits::id_type persist (const P& obj_ptr); template class P> typename object_traits::id_type persist (P& obj_ptr); template class P> typename object_traits::id_type persist (P& obj_ptr); template typename object_traits::id_type persist (const typename object_traits::pointer_type& obj_ptr); // Load an object. Throw object_not_persistent if not found. // template typename object_traits::pointer_type load (const typename object_traits::id_type& id); template void load (const typename object_traits::id_type& id, T& object); // Load (or reload, if it is already loaded) a section of an object. // template void load (T& object, section&); // Reload an object. // template void reload (T& object); template void reload (T* obj_ptr); template class P> void reload (const P& obj_ptr); template class P> void reload (const P& obj_ptr); template class P> void reload (P& obj_ptr); template class P> void reload (P& obj_ptr); template void reload (const typename object_traits::pointer_type& obj_ptr); // Loan an object if found. Return NULL/false if not found. // template typename object_traits::pointer_type find (const typename object_traits::id_type& id); template bool find (const typename object_traits::id_type& id, T& object); // Update the state of a modified objects. // template void update (T& object); template void update (T* obj_ptr); template class P> void update (const P& obj_ptr); template class P> void update (const P& obj_ptr); template class P> void update (P& obj_ptr); template class P> void update (P& obj_ptr); template void update (const typename object_traits::pointer_type& obj_ptr); // Update a section of an object. Throws the section_not_loaded // exception if the section is not loaded. Note also that this // function does not clear the changed flag if it is set. // template void update (const T& object, const section&); // Make the object transient. Throw object_not_persistent if not // found. // template void erase (const typename object_traits::id_type& id); template void erase (T& object); template void erase (T* obj_ptr); template class P> void erase (const P& obj_ptr); template class P> void erase (const P& obj_ptr); template class P> void erase (P& obj_ptr); template class P> void erase (P& obj_ptr); template void erase (const typename object_traits::pointer_type& obj_ptr); // Erase multiple objects matching a query predicate. // template unsigned long long erase_query (); template unsigned long long erase_query (const char*); template unsigned long long erase_query (const std::string&); template unsigned long long erase_query (const sqlite::query_base&); template unsigned long long erase_query (const odb::query_base&); // Query API. // template result query (); template result query (const char*); template result query (const std::string&); template result query (const sqlite::query_base&); template result query (const odb::query_base&); // Query one API. // template typename result::pointer_type query_one (); template bool query_one (T& object); template T query_value (); template typename result::pointer_type query_one (const char*); template bool query_one (const char*, T& object); template T query_value (const char*); template typename result::pointer_type query_one (const std::string&); template bool query_one (const std::string&, T& object); template T query_value (const std::string&); template typename result::pointer_type query_one (const sqlite::query_base&); template bool query_one (const sqlite::query_base&, T& object); template T query_value (const sqlite::query_base&); template typename result::pointer_type query_one (const odb::query_base&); template bool query_one (const odb::query_base&, T& object); template T query_value (const odb::query_base&); // Query preparation. // template prepared_query prepare_query (const char* name, const char*); template prepared_query prepare_query (const char* name, const std::string&); template prepared_query prepare_query (const char* name, const sqlite::query_base&); template prepared_query prepare_query (const char* name, const odb::query_base&); // Transactions. // public: virtual transaction_impl* begin (); transaction_impl* begin_immediate (); transaction_impl* begin_exclusive (); public: connection_ptr connection (); // SQL statement tracing. // public: typedef sqlite::tracer tracer_type; void tracer (tracer_type& t) { odb::database::tracer (t); } void tracer (tracer_type* t) { odb::database::tracer (t); } using odb::database::tracer; // Database schema version. // protected: virtual const schema_version_info& load_schema_version (const std::string& schema_name) const; // Database id constant (useful for meta-programming). // public: static const odb::database_id database_id = id_sqlite; public: virtual ~database (); protected: virtual odb::connection* connection_ (); private: // Note: remember to update move ctor if adding any new members. // std::string name_; int flags_; bool foreign_keys_; std::string vfs_; details::unique_ptr factory_; }; } } #include #include #endif // ODB_SQLITE_DATABASE_HXX