From 62e234c114d2b6ead93a1d39593c66b648c3d0a6 Mon Sep 17 00:00:00 2001 From: Karen Arutyunov Date: Thu, 1 Feb 2024 15:47:37 +0300 Subject: Turn libodb-oracle repository into package for muti-package repository --- libodb-oracle/odb/oracle/database.hxx | 542 ++++++++++++++++++++++++++++++++++ 1 file changed, 542 insertions(+) create mode 100644 libodb-oracle/odb/oracle/database.hxx (limited to 'libodb-oracle/odb/oracle/database.hxx') diff --git a/libodb-oracle/odb/oracle/database.hxx b/libodb-oracle/odb/oracle/database.hxx new file mode 100644 index 0000000..0b66999 --- /dev/null +++ b/libodb-oracle/odb/oracle/database.hxx @@ -0,0 +1,542 @@ +// file : odb/oracle/database.hxx +// license : ODB NCUEL; see accompanying LICENSE file + +#ifndef ODB_ORACLE_DATABASE_HXX +#define ODB_ORACLE_DATABASE_HXX + +#include + +#include +#include // std::ostream + +#include +#include // ODB_CXX11 +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace odb +{ + namespace oracle + { + class transaction_impl; + + class LIBODB_ORACLE_EXPORT database: public odb::database + { + public: + database (const std::string& user, + const std::string& password, + const std::string& db, + ub2 charset = 0, + ub2 ncharset = 0, + OCIEnv* environment = 0, + details::transfer_ptr = + details::transfer_ptr ()); + + database (const std::string& user, + const std::string& password, + const std::string& service, + const std::string& host, + unsigned int port = 0, + ub2 charset = 0, + ub2 ncharset = 0, + OCIEnv* environment = 0, + details::transfer_ptr = + details::transfer_ptr ()); + + // Extract the database parameters from the command line. The + // following options are recognized: + // + // --user + // --password + // --database + // --service + // --host + // --port + // --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. This + // constructor may throw the cli_exception exception. + // + database (int& argc, + char* argv[], + bool erase = false, + ub2 charset = 0, + ub2 ncharset = 0, + OCIEnv* environment = 0, + details::transfer_ptr = + details::transfer_ptr ()); + + // Move-constructible but not move-assignable. + // + // Note: noexcept is not specified since odb::database(odb::database&&) + // can throw. + // +#ifdef ODB_CXX11 + database (database&&); +#endif + + static void + print_usage (std::ostream&); + + // 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); + + // Bulk persist. Can be a range of references or pointers (including + // smart pointers) to objects. + // + template + void + persist (I begin, I end, bool continue_failed = true); + + // 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); + + // Bulk update. Can be a range of references or pointers (including + // smart pointers) to objects. + // + template + void + update (I begin, I end, bool continue_failed = true); + + // 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); + + // Bulk erase. + // + template + void + erase (I id_begin, I id_end, bool continue_failed = true); + + // Can be a range of references or pointers (including smart pointers) + // to objects. + // + template + void + erase (I obj_begin, I obj_end, bool continue_failed = true); + + // 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 oracle::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 oracle::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 oracle::query_base&); + + template + bool + query_one (const oracle::query_base&, T& object); + + template + T + query_value (const oracle::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 oracle::query_base&); + + template + prepared_query + prepare_query (const char* name, const odb::query_base&); + + // Transactions. + // + public: + virtual transaction_impl* + begin (); + + public: + connection_ptr + connection (); + + public: + const std::string& + user () const + { + return user_; + } + + const std::string& + password () const + { + return password_; + } + + const std::string& + db () const + { + return db_; + } + + const std::string& + service () const + { + return service_; + } + + const std::string& + host () const + { + return host_; + } + + unsigned int + port () const + { + return port_; + } + + ub2 + charset () const + { + return charset_; + } + + ub2 + ncharset () const + { + return ncharset_; + } + + OCIEnv* + environment () + { + return environment_; + } + + // SQL statement tracing. + // + public: + typedef oracle::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; + + public: + // Database id constant (useful for meta-programming). + // + static const odb::database_id database_id = id_oracle; + + public: + virtual + ~database (); + + protected: + virtual odb::connection* + connection_ (); + + private: + // Note: remember to update move ctor if adding any new members. + // + std::string user_; + std::string password_; + + std::string db_; + + std::string service_; + std::string host_; + unsigned int port_; + + ub2 charset_; + ub2 ncharset_; + + auto_handle auto_environment_; + OCIEnv* environment_; + + details::unique_ptr factory_; + }; + } +} + +#include + +#include + +#endif // ODB_ORACLE_DATABASE_HXX -- cgit v1.1