diff options
Diffstat (limited to 'odb/sqlite')
25 files changed, 897 insertions, 261 deletions
diff --git a/odb/sqlite/database.cxx b/odb/sqlite/database.cxx index 0f1138f..00618b5 100644 --- a/odb/sqlite/database.cxx +++ b/odb/sqlite/database.cxx @@ -38,7 +38,8 @@ namespace odb bool foreign_keys, const string& vfs, transfer_ptr<connection_factory> factory) - : name_ (name), + : odb::database (id_sqlite), + name_ (name), flags_ (flags), foreign_keys_ (foreign_keys), vfs_ (vfs), @@ -57,7 +58,8 @@ namespace odb bool foreign_keys, const string& vfs, transfer_ptr<connection_factory> factory) - : flags_ (flags), + : odb::database (id_sqlite), + flags_ (flags), foreign_keys_ (foreign_keys), vfs_ (vfs), factory_ (factory.transfer ()) @@ -114,7 +116,8 @@ namespace odb bool foreign_keys, const string& vfs, transfer_ptr<connection_factory> factory) - : flags_ (flags), + : odb::database (id_sqlite), + flags_ (flags), foreign_keys_ (foreign_keys), vfs_ (vfs), factory_ (factory.transfer ()) diff --git a/odb/sqlite/database.hxx b/odb/sqlite/database.hxx index bbb01f6..aa15a9b 100644 --- a/odb/sqlite/database.hxx +++ b/odb/sqlite/database.hxx @@ -19,6 +19,7 @@ #include <odb/sqlite/version.hxx> #include <odb/sqlite/forward.hxx> +#include <odb/sqlite/query.hxx> #include <odb/sqlite/tracer.hxx> #include <odb/sqlite/connection.hxx> #include <odb/sqlite/connection-factory.hxx> @@ -102,6 +103,191 @@ namespace odb return vfs_; } + // Object persistence API. + // + public: + + // Make the object persistent. + // + template <typename T> + typename object_traits<T>::id_type + persist (T& object); + + template <typename T> + typename object_traits<T>::id_type + persist (T* obj_ptr); + + template <typename T, template <typename> class P> + typename object_traits<T>::id_type + persist (const P<T>& obj_ptr); + + template <typename T, typename A1, template <typename, typename> class P> + typename object_traits<T>::id_type + persist (const P<T, A1>& obj_ptr); + + template <typename T, template <typename> class P> + typename object_traits<T>::id_type + persist (P<T>& obj_ptr); + + template <typename T, typename A1, template <typename, typename> class P> + typename object_traits<T>::id_type + persist (P<T, A1>& obj_ptr); + + template <typename T> + typename object_traits<T>::id_type + persist (const typename object_traits<T>::pointer_type& obj_ptr); + + // Load an object. Throw object_not_persistent if not found. + // + template <typename T> + typename object_traits<T>::pointer_type + load (const typename object_traits<T>::id_type& id); + + template <typename T> + void + load (const typename object_traits<T>::id_type& id, T& object); + + // Reload an object. + // + template <typename T> + void + reload (T& object); + + template <typename T> + void + reload (T* obj_ptr); + + template <typename T, template <typename> class P> + void + reload (const P<T>& obj_ptr); + + template <typename T, typename A1, template <typename, typename> class P> + void + reload (const P<T, A1>& obj_ptr); + + template <typename T, template <typename> class P> + void + reload (P<T>& obj_ptr); + + template <typename T, typename A1, template <typename, typename> class P> + void + reload (P<T, A1>& obj_ptr); + + template <typename T> + void + reload (const typename object_traits<T>::pointer_type& obj_ptr); + + // Loan an object if found. Return NULL/false if not found. + // + template <typename T> + typename object_traits<T>::pointer_type + find (const typename object_traits<T>::id_type& id); + + template <typename T> + bool + find (const typename object_traits<T>::id_type& id, T& object); + + // Update the state of a modified objects. + // + template <typename T> + void + update (T& object); + + template <typename T> + void + update (T* obj_ptr); + + template <typename T, template <typename> class P> + void + update (const P<T>& obj_ptr); + + template <typename T, typename A1, template <typename, typename> class P> + void + update (const P<T, A1>& obj_ptr); + + template <typename T, template <typename> class P> + void + update (P<T>& obj_ptr); + + template <typename T, typename A1, template <typename, typename> class P> + void + update (P<T, A1>& obj_ptr); + + template <typename T> + void + update (const typename object_traits<T>::pointer_type& obj_ptr); + + // Make the object transient. Throw object_not_persistent if not + // found. + // + template <typename T> + void + erase (const typename object_traits<T>::id_type& id); + + template <typename T> + void + erase (T& object); + + template <typename T> + void + erase (T* obj_ptr); + + template <typename T, template <typename> class P> + void + erase (const P<T>& obj_ptr); + + template <typename T, typename A1, template <typename, typename> class P> + void + erase (const P<T, A1>& obj_ptr); + + template <typename T, template <typename> class P> + void + erase (P<T>& obj_ptr); + + template <typename T, typename A1, template <typename, typename> class P> + void + erase (P<T, A1>& obj_ptr); + + template <typename T> + void + erase (const typename object_traits<T>::pointer_type& obj_ptr); + + // Erase multiple objects matching a query predicate. + // + template <typename T> + unsigned long long + erase_query (); + + template <typename T> + unsigned long long + erase_query (const char*); + + template <typename T> + unsigned long long + erase_query (const std::string&); + + template <typename T> + unsigned long long + erase_query (const sqlite::query<T>&); + + // Query API. + // + template <typename T> + result<T> + query (); + + template <typename T> + result<T> + query (const char*); + + template <typename T> + result<T> + query (const std::string&); + + template <typename T> + result<T> + query (const sqlite::query<T>&); + // Transactions. // public: diff --git a/odb/sqlite/database.ixx b/odb/sqlite/database.ixx index ab0f09b..c8b2a30 100644 --- a/odb/sqlite/database.ixx +++ b/odb/sqlite/database.ixx @@ -15,5 +15,383 @@ namespace odb return connection_ptr ( static_cast<sqlite::connection*> (connection_ ())); } + + template <typename T> + inline typename object_traits<T>::id_type database:: + persist (T& obj) + { + return persist_<T, id_sqlite> (obj); + } + + template <typename T> + inline typename object_traits<T>::id_type database:: + persist (T* p) + { + typedef typename object_traits<T>::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + return persist_<T, id_sqlite> (pobj); + } + + template <typename T, template <typename> class P> + inline typename object_traits<T>::id_type database:: + persist (const P<T>& p) + { + typedef typename object_traits<T>::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + return persist_<T, id_sqlite> (pobj); + } + + template <typename T, typename A1, template <typename, typename> class P> + inline typename object_traits<T>::id_type database:: + persist (const P<T, A1>& p) + { + typedef typename object_traits<T>::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + return persist_<T, id_sqlite> (pobj); + } + + template <typename T, template <typename> class P> + inline typename object_traits<T>::id_type database:: + persist (P<T>& p) + { + const P<T>& cr (p); + return persist<T, P> (cr); + } + + template <typename T, typename A1, template <typename, typename> class P> + inline typename object_traits<T>::id_type database:: + persist (P<T, A1>& p) + { + const P<T, A1>& cr (p); + return persist<T, A1, P> (cr); + } + + template <typename T> + inline typename object_traits<T>::id_type database:: + persist (const typename object_traits<T>::pointer_type& pobj) + { + return persist_<T, id_sqlite> (pobj); + } + + template <typename T> + inline typename object_traits<T>::pointer_type database:: + load (const typename object_traits<T>::id_type& id) + { + return load_<T, id_sqlite> (id); + } + + template <typename T> + inline void database:: + load (const typename object_traits<T>::id_type& id, T& obj) + { + return load_<T, id_sqlite> (id, obj); + } + + template <typename T> + inline typename object_traits<T>::pointer_type database:: + find (const typename object_traits<T>::id_type& id) + { + return find_<T, id_sqlite> (id); + } + + template <typename T> + inline bool database:: + find (const typename object_traits<T>::id_type& id, T& obj) + { + return find_<T, id_sqlite> (id, obj); + } + + template <typename T> + inline void database:: + reload (T& obj) + { + reload_<T, id_sqlite> (obj); + } + + template <typename T> + inline void database:: + reload (T* p) + { + reload<T> (*p); + } + + template <typename T, template <typename> class P> + inline void database:: + reload (const P<T>& p) + { + reload (odb::pointer_traits< P<T> >::get_ref (p)); + } + + template <typename T, typename A1, template <typename, typename> class P> + inline void database:: + reload (const P<T, A1>& p) + { + reload (odb::pointer_traits< P<T, A1> >::get_ref (p)); + } + + template <typename T, template <typename> class P> + inline void database:: + reload (P<T>& p) + { + reload (odb::pointer_traits< P<T> >::get_ref (p)); + } + + template <typename T, typename A1, template <typename, typename> class P> + inline void database:: + reload (P<T, A1>& p) + { + reload (odb::pointer_traits< P<T, A1> >::get_ref (p)); + } + + template <typename T> + inline void database:: + reload (const typename object_traits<T>::pointer_type& pobj) + { + typedef typename object_traits<T>::pointer_type pointer_type; + + reload (odb::pointer_traits<pointer_type>::get_ref (pobj)); + } + + template <typename T> + inline void database:: + update (T& obj) + { + update_<T, id_sqlite> (obj); + } + + template <typename T> + inline void database:: + update (T* p) + { + typedef typename object_traits<T>::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + update_<T, id_sqlite> (pobj); + } + + template <typename T, template <typename> class P> + inline void database:: + update (const P<T>& p) + { + typedef typename object_traits<T>::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + update_<T, id_sqlite> (pobj); + } + + template <typename T, typename A1, template <typename, typename> class P> + inline void database:: + update (const P<T, A1>& p) + { + typedef typename object_traits<T>::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + update_<T, id_sqlite> (pobj); + } + + template <typename T, template <typename> class P> + inline void database:: + update (P<T>& p) + { + const P<T>& cr (p); + update<T, P> (cr); + } + + template <typename T, typename A1, template <typename, typename> class P> + inline void database:: + update (P<T, A1>& p) + { + const P<T, A1>& cr (p); + update<T, A1, P> (cr); + } + + template <typename T> + inline void database:: + update (const typename object_traits<T>::pointer_type& pobj) + { + update_<T, id_sqlite> (pobj); + } + + template <typename T> + inline void database:: + erase (const typename object_traits<T>::id_type& id) + { + return erase_<T, id_sqlite> (id); + } + + template <typename T> + inline void database:: + erase (T& obj) + { + return erase_<T, id_sqlite> (obj); + } + + template <typename T> + inline void database:: + erase (T* p) + { + typedef typename object_traits<T>::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + erase_<T, id_sqlite> (pobj); + } + + template <typename T, template <typename> class P> + inline void database:: + erase (const P<T>& p) + { + typedef typename object_traits<T>::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + erase_<T, id_sqlite> (pobj); + } + + template <typename T, typename A1, template <typename, typename> class P> + inline void database:: + erase (const P<T, A1>& p) + { + typedef typename object_traits<T>::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + erase_<T, id_sqlite> (pobj); + } + + template <typename T, template <typename> class P> + inline void database:: + erase (P<T>& p) + { + const P<T>& cr (p); + erase<T, P> (cr); + } + + template <typename T, typename A1, template <typename, typename> class P> + inline void database:: + erase (P<T, A1>& p) + { + const P<T, A1>& cr (p); + erase<T, A1, P> (cr); + } + + template <typename T> + inline void database:: + erase (const typename object_traits<T>::pointer_type& pobj) + { + erase_<T, id_sqlite> (pobj); + } + + template <typename T> + inline unsigned long long database:: + erase_query () + { + // T is always object_type. + // + return erase_query<T> (sqlite::query<T> ()); + } + + template <typename T> + inline unsigned long long database:: + erase_query (const char* q) + { + // T is always object_type. + // + return erase_query<T> (sqlite::query<T> (q)); + } + + template <typename T> + inline unsigned long long database:: + erase_query (const std::string& q) + { + // T is always object_type. + // + return erase_query<T> (sqlite::query<T> (q)); + } + + template <typename T> + inline unsigned long long database:: + erase_query (const sqlite::query<T>& q) + { + // T is always object_type. + // + return object_traits_impl<T, id_sqlite>::erase_query (*this, q); + } + + template <typename T> + inline result<T> database:: + query () + { + return query<T> (sqlite::query<T> ()); + } + + template <typename T> + inline result<T> database:: + query (const char* q) + { + return query<T> (sqlite::query<T> (q)); + } + + template <typename T> + inline result<T> database:: + query (const std::string& q) + { + return query<T> (sqlite::query<T> (q)); + } + + template <typename T> + inline result<T> database:: + query (const sqlite::query<T>& q) + { + // T is always object_type. We also don't need to check for transaction + // here; object_traits::query () does this. + // + return query_<T, id_sqlite>::call (*this, q); + } } } diff --git a/odb/sqlite/forward.hxx b/odb/sqlite/forward.hxx index 9be506f..e2f4df1 100644 --- a/odb/sqlite/forward.hxx +++ b/odb/sqlite/forward.hxx @@ -20,7 +20,6 @@ namespace odb class statement; class transaction; class tracer; - class query; // Implementation details. // @@ -52,6 +51,7 @@ namespace odb template <typename T> class container_statements; + class query_base; class query_params; } diff --git a/odb/sqlite/no-id-object-result.hxx b/odb/sqlite/no-id-object-result.hxx index 84a7265..7079678 100644 --- a/odb/sqlite/no-id-object-result.hxx +++ b/odb/sqlite/no-id-object-result.hxx @@ -14,7 +14,7 @@ #include <odb/details/shared-ptr.hxx> #include <odb/sqlite/version.hxx> -#include <odb/sqlite/forward.hxx> // query +#include <odb/sqlite/forward.hxx> // query_base #include <odb/sqlite/result.hxx> #include <odb/sqlite/statement.hxx> @@ -29,10 +29,10 @@ namespace odb public: typedef odb::no_id_object_result_impl<T> base_type; - typedef typename base_type::object_traits object_traits; typedef typename base_type::object_type object_type; - typedef typename base_type::pointer_type pointer_type; + + typedef object_traits_impl<object_type, id_sqlite> object_traits; typedef typename base_type::pointer_traits pointer_traits; typedef typename object_traits::statements_type statements_type; @@ -40,7 +40,7 @@ namespace odb virtual ~no_id_object_result_impl (); - no_id_object_result_impl (const query&, + no_id_object_result_impl (const query_base&, details::shared_ptr<select_statement>, statements_type&); diff --git a/odb/sqlite/no-id-object-result.txx b/odb/sqlite/no-id-object-result.txx index 8519c47..5dad5b2 100644 --- a/odb/sqlite/no-id-object-result.txx +++ b/odb/sqlite/no-id-object-result.txx @@ -21,7 +21,7 @@ namespace odb template <typename T> no_id_object_result_impl<T>:: - no_id_object_result_impl (const query& q, + no_id_object_result_impl (const query_base& q, details::shared_ptr<select_statement> statement, statements_type& statements) : base_type (statements.connection ().database ()), diff --git a/odb/sqlite/no-id-object-statements.hxx b/odb/sqlite/no-id-object-statements.hxx index 04d46ce..93aedb0 100644 --- a/odb/sqlite/no-id-object-statements.hxx +++ b/odb/sqlite/no-id-object-statements.hxx @@ -34,7 +34,7 @@ namespace odb { public: typedef T object_type; - typedef odb::object_traits<object_type> object_traits; + typedef object_traits_impl<object_type, id_sqlite> object_traits; typedef typename object_traits::pointer_type pointer_type; typedef typename object_traits::image_type image_type; diff --git a/odb/sqlite/polymorphic-object-result.hxx b/odb/sqlite/polymorphic-object-result.hxx index 54f4092..6023248 100644 --- a/odb/sqlite/polymorphic-object-result.hxx +++ b/odb/sqlite/polymorphic-object-result.hxx @@ -14,7 +14,7 @@ #include <odb/details/shared-ptr.hxx> #include <odb/sqlite/version.hxx> -#include <odb/sqlite/forward.hxx> // query +#include <odb/sqlite/forward.hxx> // query_base #include <odb/sqlite/result.hxx> #include <odb/sqlite/statement.hxx> @@ -30,23 +30,24 @@ namespace odb public: typedef odb::polymorphic_object_result_impl<T> base_type; - typedef typename base_type::object_type object_type; - typedef typename base_type::object_traits object_traits; typedef typename base_type::id_type id_type; - + typedef typename base_type::object_type object_type; typedef typename base_type::pointer_type pointer_type; + + typedef object_traits_impl<object_type, id_sqlite> object_traits; typedef typename base_type::pointer_traits pointer_traits; typedef typename base_type::root_type root_type; - typedef typename base_type::root_traits root_traits; typedef typename base_type::discriminator_type discriminator_type; + typedef object_traits_impl<root_type, id_sqlite> root_traits; + typedef typename object_traits::statements_type statements_type; virtual ~polymorphic_object_result_impl (); - polymorphic_object_result_impl (const query&, + polymorphic_object_result_impl (const query_base&, details::shared_ptr<select_statement>, statements_type&); diff --git a/odb/sqlite/polymorphic-object-result.txx b/odb/sqlite/polymorphic-object-result.txx index dfff9ff..7e751b3 100644 --- a/odb/sqlite/polymorphic-object-result.txx +++ b/odb/sqlite/polymorphic-object-result.txx @@ -23,7 +23,7 @@ namespace odb template <typename T> polymorphic_object_result_impl<T>:: - polymorphic_object_result_impl (const query& q, + polymorphic_object_result_impl (const query_base& q, details::shared_ptr<select_statement> st, statements_type& sts) : base_type (sts.connection ().database ()), @@ -179,7 +179,7 @@ namespace odb { // Derived type version. // - typedef object_traits<T> traits; + typedef object_traits_impl<T, id_sqlite> traits; static bool rebind (typename traits::statements_type& sts) @@ -204,7 +204,7 @@ namespace odb { // Root type version. // - typedef object_traits<R> traits; + typedef object_traits_impl<R, id_sqlite> traits; static bool rebind (typename traits::statements_type& sts) diff --git a/odb/sqlite/polymorphic-object-statements.hxx b/odb/sqlite/polymorphic-object-statements.hxx index 54319ee..286b9e3 100644 --- a/odb/sqlite/polymorphic-object-statements.hxx +++ b/odb/sqlite/polymorphic-object-statements.hxx @@ -156,7 +156,7 @@ namespace odb { public: typedef T object_type; - typedef odb::object_traits<object_type> object_traits; + typedef object_traits_impl<object_type, id_sqlite> object_traits; typedef typename object_traits::id_type id_type; typedef typename object_traits::pointer_type pointer_type; typedef typename object_traits::id_image_type id_image_type; diff --git a/odb/sqlite/query-const-expr.cxx b/odb/sqlite/query-const-expr.cxx index c4eba2e..9e48ace 100644 --- a/odb/sqlite/query-const-expr.cxx +++ b/odb/sqlite/query-const-expr.cxx @@ -10,6 +10,6 @@ namespace odb { // Sun CC cannot handle this in query.cxx. // - const query query::true_expr (true); + const query_base query_base::true_expr (true); } } diff --git a/odb/sqlite/query.cxx b/odb/sqlite/query.cxx index d979379..15934fb 100644 --- a/odb/sqlite/query.cxx +++ b/odb/sqlite/query.cxx @@ -124,18 +124,18 @@ namespace odb return r; } - // query + // query_base // - query:: - query (const query& q) + query_base:: + query_base (const query_base& q) : clause_ (q.clause_), parameters_ (new (details::shared) query_params (*q.parameters_)) { } - query& query:: - operator= (const query& q) + query_base& query_base:: + operator= (const query_base& q) { if (this != &q) { @@ -146,15 +146,15 @@ namespace odb return *this; } - query& query:: - operator+= (const query& q) + query_base& query_base:: + operator+= (const query_base& q) { clause_.insert (clause_.end (), q.clause_.begin (), q.clause_.end ()); *parameters_ += *q.parameters_; return *this; } - void query:: + void query_base:: append (const string& q) { if (!clause_.empty () && clause_.back ().kind == clause_part::native) @@ -177,7 +177,7 @@ namespace odb clause_.push_back (clause_part (clause_part::native, q)); } - void query:: + void query_base:: append (const char* table, const char* column) { string s (table); @@ -187,7 +187,7 @@ namespace odb clause_.push_back (clause_part (clause_part::column, s)); } - void query:: + void query_base:: add (details::shared_ptr<query_param> p, const char* conv) { clause_.push_back (clause_part (clause_part::param)); @@ -228,7 +228,7 @@ namespace odb return false; } - void query:: + void query_base:: optimize () { // Remove a single TRUE literal or one that is followe by one of @@ -248,7 +248,7 @@ namespace odb } } - const char* query:: + const char* query_base:: clause_prefix () const { if (!clause_.empty ()) @@ -264,7 +264,7 @@ namespace odb return ""; } - string query:: + string query_base:: clause () const { string r; @@ -336,8 +336,8 @@ namespace odb return clause_prefix () + r; } - query - operator&& (const query& x, const query& y) + query_base + operator&& (const query_base& x, const query_base& y) { // Optimize cases where one or both sides are constant truth. // @@ -352,7 +352,7 @@ namespace odb if (yt) return x; - query r ("("); + query_base r ("("); r += x; r += ") AND ("; r += y; @@ -360,10 +360,10 @@ namespace odb return r; } - query - operator|| (const query& x, const query& y) + query_base + operator|| (const query_base& x, const query_base& y) { - query r ("("); + query_base r ("("); r += x; r += ") OR ("; r += y; @@ -371,10 +371,10 @@ namespace odb return r; } - query - operator! (const query& x) + query_base + operator! (const query_base& x) { - query r ("NOT ("); + query_base r ("NOT ("); r += x; r += ")"; return r; diff --git a/odb/sqlite/query.hxx b/odb/sqlite/query.hxx index ffd3559..fdae3a2 100644 --- a/odb/sqlite/query.hxx +++ b/odb/sqlite/query.hxx @@ -75,7 +75,7 @@ namespace odb const void* value_; }; - class query; + class query_base; class LIBODB_SQLITE_EXPORT query_params: public details::shared_base { @@ -86,7 +86,7 @@ namespace odb binding (); private: - friend class query; + friend class query_base; query_params (): binding_ (0, 0) {} query_params (const query_params&); @@ -113,7 +113,7 @@ namespace odb template <typename T, database_type_id ID> struct query_column; - class LIBODB_SQLITE_EXPORT query + class LIBODB_SQLITE_EXPORT query_base { public: struct clause_part @@ -135,7 +135,7 @@ namespace odb bool bool_part; }; - query () + query_base () : parameters_ (new (details::shared) query_params) { } @@ -143,27 +143,27 @@ namespace odb // True or false literal. // explicit - query (bool v) + query_base (bool v) : parameters_ (new (details::shared) query_params) { clause_.push_back (clause_part (v)); } explicit - query (const char* native) + query_base (const char* native) : parameters_ (new (details::shared) query_params) { clause_.push_back (clause_part (clause_part::native, native)); } explicit - query (const std::string& native) + query_base (const std::string& native) : parameters_ (new (details::shared) query_params) { clause_.push_back (clause_part (clause_part::native, native)); } - query (const char* table, const char* column) + query_base (const char* table, const char* column) : parameters_ (new (details::shared) query_params) { append (table, column); @@ -171,7 +171,7 @@ namespace odb template <typename T> explicit - query (val_bind<T> v) + query_base (val_bind<T> v) : parameters_ (new (details::shared) query_params) { append<T, type_traits<T>::db_type_id> ( @@ -180,7 +180,7 @@ namespace odb template <typename T> explicit - query (ref_bind<T> r) + query_base (ref_bind<T> r) : parameters_ (new (details::shared) query_params) { append<T, type_traits<T>::db_type_id> ( @@ -188,12 +188,12 @@ namespace odb } template <database_type_id ID> - query (const query_column<bool, ID>&); + query_base (const query_column<bool, ID>&); - query (const query&); + query_base (const query_base&); - query& - operator= (const query&); + query_base& + operator= (const query_base&); public: std::string @@ -215,7 +215,7 @@ namespace odb return clause_.empty (); } - static const query true_expr; + static const query_base true_expr; bool const_true () const @@ -244,10 +244,10 @@ namespace odb } public: - query& - operator+= (const query&); + query_base& + operator+= (const query_base&); - query& + query_base& operator+= (const std::string& q) { append (q); @@ -255,7 +255,7 @@ namespace odb } template <typename T> - query& + query_base& operator+= (val_bind<T> v) { append<T, type_traits<T>::db_type_id> ( @@ -264,7 +264,7 @@ namespace odb } template <typename T> - query& + query_base& operator+= (ref_bind<T> r) { append<T, type_traits<T>::db_type_id> ( @@ -298,114 +298,114 @@ namespace odb details::shared_ptr<query_params> parameters_; }; - inline query - operator+ (const query& x, const query& y) + inline query_base + operator+ (const query_base& x, const query_base& y) { - query r (x); + query_base r (x); r += y; return r; } template <typename T> - inline query - operator+ (const query& q, val_bind<T> b) + inline query_base + operator+ (const query_base& q, val_bind<T> b) { - query r (q); + query_base r (q); r += b; return r; } template <typename T> - inline query - operator+ (const query& q, ref_bind<T> b) + inline query_base + operator+ (const query_base& q, ref_bind<T> b) { - query r (q); + query_base r (q); r += b; return r; } template <typename T> - inline query - operator+ (val_bind<T> b, const query& q) + inline query_base + operator+ (val_bind<T> b, const query_base& q) { - query r; + query_base r; r += b; r += q; return r; } template <typename T> - inline query - operator+ (ref_bind<T> b, const query& q) + inline query_base + operator+ (ref_bind<T> b, const query_base& q) { - query r; + query_base r; r += b; r += q; return r; } - inline query - operator+ (const query& q, const std::string& s) + inline query_base + operator+ (const query_base& q, const std::string& s) { - query r (q); + query_base r (q); r += s; return r; } - inline query - operator+ (const std::string& s, const query& q) + inline query_base + operator+ (const std::string& s, const query_base& q) { - query r (s); + query_base r (s); r += q; return r; } template <typename T> - inline query + inline query_base operator+ (const std::string& s, val_bind<T> b) { - query r (s); + query_base r (s); r += b; return r; } template <typename T> - inline query + inline query_base operator+ (const std::string& s, ref_bind<T> b) { - query r (s); + query_base r (s); r += b; return r; } template <typename T> - inline query + inline query_base operator+ (val_bind<T> b, const std::string& s) { - query r; + query_base r; r += b; r += s; return r; } template <typename T> - inline query + inline query_base operator+ (ref_bind<T> b, const std::string& s) { - query r; + query_base r; r += b; r += s; return r; } - LIBODB_SQLITE_EXPORT query - operator&& (const query&, const query&); + LIBODB_SQLITE_EXPORT query_base + operator&& (const query_base&, const query_base&); - LIBODB_SQLITE_EXPORT query - operator|| (const query&, const query&); + LIBODB_SQLITE_EXPORT query_base + operator|| (const query_base&, const query_base&); - LIBODB_SQLITE_EXPORT query - operator! (const query&); + LIBODB_SQLITE_EXPORT query_base + operator! (const query_base&); // query_column // @@ -458,18 +458,18 @@ namespace odb // is_null, is_not_null // public: - query + query_base is_null () const { - query q (table_, column_); + query_base q (table_, column_); q += "IS NULL"; return q; } - query + query_base is_not_null () const { - query q (table_, column_); + query_base q (table_, column_); q += "IS NOT NULL"; return q; } @@ -477,102 +477,102 @@ namespace odb // in // public: - query + query_base in (const T&, const T&) const; - query + query_base in (const T&, const T&, const T&) const; - query + query_base in (const T&, const T&, const T&, const T&) const; - query + query_base in (const T&, const T&, const T&, const T&, const T&) const; template <typename I> - query + query_base in_range (I begin, I end) const; // = // public: - query + query_base equal (const T& v) const { return equal (val_bind<T> (v)); } - query + query_base equal (val_bind<T> v) const { - query q (table_, column_); + query_base q (table_, column_); q += "="; q.append<T, ID> (v, conversion_); return q; } template <typename T2> - query + query_base equal (val_bind<T2> v) const { copy_bind<T, T2> c (v.val); return equal (c); } - query + query_base equal (ref_bind<T> r) const { - query q (table_, column_); + query_base q (table_, column_); q += "="; q.append<T, ID> (r, conversion_); return q; } - friend query + friend query_base operator== (const query_column& c, const T& v) { return c.equal (v); } - friend query + friend query_base operator== (const T& v, const query_column& c) { return c.equal (v); } - friend query + friend query_base operator== (const query_column& c, val_bind<T> v) { return c.equal (v); } - friend query + friend query_base operator== (val_bind<T> v, const query_column& c) { return c.equal (v); } template <typename T2> - friend query + friend query_base operator== (const query_column& c, val_bind<T2> v) { return c.equal (v); } template <typename T2> - friend query + friend query_base operator== (val_bind<T2> v, const query_column& c) { return c.equal (v); } - friend query + friend query_base operator== (const query_column& c, ref_bind<T> r) { return c.equal (r); } - friend query + friend query_base operator== (ref_bind<T> r, const query_column& c) { return c.equal (r); @@ -581,83 +581,83 @@ namespace odb // != // public: - query + query_base unequal (const T& v) const { return unequal (val_bind<T> (v)); } - query + query_base unequal (val_bind<T> v) const { - query q (table_, column_); + query_base q (table_, column_); q += "!="; q.append<T, ID> (v, conversion_); return q; } template <typename T2> - query + query_base unequal (val_bind<T2> v) const { copy_bind<T, T2> c (v.val); return unequal (c); } - query + query_base unequal (ref_bind<T> r) const { - query q (table_, column_); + query_base q (table_, column_); q += "!="; q.append<T, ID> (r, conversion_); return q; } - friend query + friend query_base operator!= (const query_column& c, const T& v) { return c.unequal (v); } - friend query + friend query_base operator!= (const T& v, const query_column& c) { return c.unequal (v); } - friend query + friend query_base operator!= (const query_column& c, val_bind<T> v) { return c.unequal (v); } - friend query + friend query_base operator!= (val_bind<T> v, const query_column& c) { return c.unequal (v); } template <typename T2> - friend query + friend query_base operator!= (const query_column& c, val_bind<T2> v) { return c.unequal (v); } template <typename T2> - friend query + friend query_base operator!= (val_bind<T2> v, const query_column& c) { return c.unequal (v); } - friend query + friend query_base operator!= (const query_column& c, ref_bind<T> r) { return c.unequal (r); } - friend query + friend query_base operator!= (ref_bind<T> r, const query_column& c) { return c.unequal (r); @@ -666,83 +666,83 @@ namespace odb // < // public: - query + query_base less (const T& v) const { return less (val_bind<T> (v)); } - query + query_base less (val_bind<T> v) const { - query q (table_, column_); + query_base q (table_, column_); q += "<"; q.append<T, ID> (v, conversion_); return q; } template <typename T2> - query + query_base less (val_bind<T2> v) const { copy_bind<T, T2> c (v.val); return less (c); } - query + query_base less (ref_bind<T> r) const { - query q (table_, column_); + query_base q (table_, column_); q += "<"; q.append<T, ID> (r, conversion_); return q; } - friend query + friend query_base operator< (const query_column& c, const T& v) { return c.less (v); } - friend query + friend query_base operator< (const T& v, const query_column& c) { return c.greater (v); } - friend query + friend query_base operator< (const query_column& c, val_bind<T> v) { return c.less (v); } - friend query + friend query_base operator< (val_bind<T> v, const query_column& c) { return c.greater (v); } template <typename T2> - friend query + friend query_base operator< (const query_column& c, val_bind<T2> v) { return c.less (v); } template <typename T2> - friend query + friend query_base operator< (val_bind<T2> v, const query_column& c) { return c.greater (v); } - friend query + friend query_base operator< (const query_column& c, ref_bind<T> r) { return c.less (r); } - friend query + friend query_base operator< (ref_bind<T> r, const query_column& c) { return c.greater (r); @@ -751,83 +751,83 @@ namespace odb // > // public: - query + query_base greater (const T& v) const { return greater (val_bind<T> (v)); } - query + query_base greater (val_bind<T> v) const { - query q (table_, column_); + query_base q (table_, column_); q += ">"; q.append<T, ID> (v, conversion_); return q; } template <typename T2> - query + query_base greater (val_bind<T2> v) const { copy_bind<T, T2> c (v.val); return greater (c); } - query + query_base greater (ref_bind<T> r) const { - query q (table_, column_); + query_base q (table_, column_); q += ">"; q.append<T, ID> (r, conversion_); return q; } - friend query + friend query_base operator> (const query_column& c, const T& v) { return c.greater (v); } - friend query + friend query_base operator> (const T& v, const query_column& c) { return c.less (v); } - friend query + friend query_base operator> (const query_column& c, val_bind<T> v) { return c.greater (v); } - friend query + friend query_base operator> (val_bind<T> v, const query_column& c) { return c.less (v); } template <typename T2> - friend query + friend query_base operator> (const query_column& c, val_bind<T2> v) { return c.greater (v); } template <typename T2> - friend query + friend query_base operator> (val_bind<T2> v, const query_column& c) { return c.less (v); } - friend query + friend query_base operator> (const query_column& c, ref_bind<T> r) { return c.greater (r); } - friend query + friend query_base operator> (ref_bind<T> r, const query_column& c) { return c.less (r); @@ -836,83 +836,83 @@ namespace odb // <= // public: - query + query_base less_equal (const T& v) const { return less_equal (val_bind<T> (v)); } - query + query_base less_equal (val_bind<T> v) const { - query q (table_, column_); + query_base q (table_, column_); q += "<="; q.append<T, ID> (v, conversion_); return q; } template <typename T2> - query + query_base less_equal (val_bind<T2> v) const { copy_bind<T, T2> c (v.val); return less_equal (c); } - query + query_base less_equal (ref_bind<T> r) const { - query q (table_, column_); + query_base q (table_, column_); q += "<="; q.append<T, ID> (r, conversion_); return q; } - friend query + friend query_base operator<= (const query_column& c, const T& v) { return c.less_equal (v); } - friend query + friend query_base operator<= (const T& v, const query_column& c) { return c.greater_equal (v); } - friend query + friend query_base operator<= (const query_column& c, val_bind<T> v) { return c.less_equal (v); } - friend query + friend query_base operator<= (val_bind<T> v, const query_column& c) { return c.greater_equal (v); } template <typename T2> - friend query + friend query_base operator<= (const query_column& c, val_bind<T2> v) { return c.less_equal (v); } template <typename T2> - friend query + friend query_base operator<= (val_bind<T2> v, const query_column& c) { return c.greater_equal (v); } - friend query + friend query_base operator<= (const query_column& c, ref_bind<T> r) { return c.less_equal (r); } - friend query + friend query_base operator<= (ref_bind<T> r, const query_column& c) { return c.greater_equal (r); @@ -921,83 +921,83 @@ namespace odb // >= // public: - query + query_base greater_equal (const T& v) const { return greater_equal (val_bind<T> (v)); } - query + query_base greater_equal (val_bind<T> v) const { - query q (table_, column_); + query_base q (table_, column_); q += ">="; q.append<T, ID> (v, conversion_); return q; } template <typename T2> - query + query_base greater_equal (val_bind<T2> v) const { copy_bind<T, T2> c (v.val); return greater_equal (c); } - query + query_base greater_equal (ref_bind<T> r) const { - query q (table_, column_); + query_base q (table_, column_); q += ">="; q.append<T, ID> (r, conversion_); return q; } - friend query + friend query_base operator>= (const query_column& c, const T& v) { return c.greater_equal (v); } - friend query + friend query_base operator>= (const T& v, const query_column& c) { return c.less_equal (v); } - friend query + friend query_base operator>= (const query_column& c, val_bind<T> v) { return c.greater_equal (v); } - friend query + friend query_base operator>= (val_bind<T> v, const query_column& c) { return c.less_equal (v); } template <typename T2> - friend query + friend query_base operator>= (const query_column& c, val_bind<T2> v) { return c.greater_equal (v); } template <typename T2> - friend query + friend query_base operator>= (val_bind<T2> v, const query_column& c) { return c.less_equal (v); } - friend query + friend query_base operator>= (const query_column& c, ref_bind<T> r) { return c.greater_equal (r); } - friend query + friend query_base operator>= (ref_bind<T> r, const query_column& c) { return c.less_equal (r); @@ -1007,84 +1007,84 @@ namespace odb // public: template <typename T2, database_type_id ID2> - query + query_base operator== (const query_column<T2, ID2>& c) const { // We can compare columns only if we can compare their C++ types. // (void) (sizeof (type_instance<T> () == type_instance<T2> ())); - query q (table_, column_); + query_base q (table_, column_); q += "="; q.append (c.table (), c.column ()); return q; } template <typename T2, database_type_id ID2> - query + query_base operator!= (const query_column<T2, ID2>& c) const { // We can compare columns only if we can compare their C++ types. // (void) (sizeof (type_instance<T> () != type_instance<T2> ())); - query q (table_, column_); + query_base q (table_, column_); q += "!="; q.append (c.table (), c.column ()); return q; } template <typename T2, database_type_id ID2> - query + query_base operator< (const query_column<T2, ID2>& c) const { // We can compare columns only if we can compare their C++ types. // (void) (sizeof (type_instance<T> () < type_instance<T2> ())); - query q (table_, column_); + query_base q (table_, column_); q += "<"; q.append (c.table (), c.column ()); return q; } template <typename T2, database_type_id ID2> - query + query_base operator> (const query_column<T2, ID2>& c) const { // We can compare columns only if we can compare their C++ types. // (void) (sizeof (type_instance<T> () > type_instance<T2> ())); - query q (table_, column_); + query_base q (table_, column_); q += ">"; q.append (c.table (), c.column ()); return q; } template <typename T2, database_type_id ID2> - query + query_base operator<= (const query_column<T2, ID2>& c) const { // We can compare columns only if we can compare their C++ types. // (void) (sizeof (type_instance<T> () <= type_instance<T2> ())); - query q (table_, column_); + query_base q (table_, column_); q += "<="; q.append (c.table (), c.column ()); return q; } template <typename T2, database_type_id ID2> - query + query_base operator>= (const query_column<T2, ID2>& c) const { // We can compare columns only if we can compare their C++ types. // (void) (sizeof (type_instance<T> () >= type_instance<T2> ())); - query q (table_, column_); + query_base q (table_, column_); q += ">="; q.append (c.table (), c.column ()); return q; @@ -1100,37 +1100,37 @@ namespace odb // query fragments (e.g., ORDER BY). // template <typename T, database_type_id ID> - inline query + inline query_base operator+ (const query_column<T, ID>& c, const std::string& s) { - query q (c.table (), c.column ()); + query_base q (c.table (), c.column ()); q += s; return q; } template <typename T, database_type_id ID> - inline query + inline query_base operator+ (const std::string& s, const query_column<T, ID>& c) { - query q (s); + query_base q (s); q.append (c.table (), c.column ()); return q; } template <typename T, database_type_id ID> - inline query - operator+ (const query_column<T, ID>& c, const query& q) + inline query_base + operator+ (const query_column<T, ID>& c, const query_base& q) { - query r (c.table (), c.column ()); + query_base r (c.table (), c.column ()); r += q; return r; } template <typename T, database_type_id ID> - inline query - operator+ (const query& q, const query_column<T, ID>& c) + inline query_base + operator+ (const query_base& q, const query_column<T, ID>& c) { - query r (q); + query_base r (q); r.append (c.table (), c.column ()); return r; } @@ -1284,13 +1284,75 @@ namespace odb } } -// odb::query specialization for SQLite. +// odb::sqlite::query and odb::query specialization for SQLite. // namespace odb { + namespace sqlite + { + template <typename T> + class query: public query_base, + public query_selector<T, id_sqlite>::columns_type + { + public: + // We don't define any typedefs here since they may clash with + // column names defined by our base type. + // + + query () + { + } + + explicit + query (bool v) + : query_base (v) + { + } + + explicit + query (const char* q) + : query_base (q) + { + } + + explicit + query (const std::string& q) + : query_base (q) + { + } + + template <typename T2> + explicit + query (val_bind<T2> v) + : query_base (v) + { + } + + template <typename T2> + explicit + query (ref_bind<T2> r) + : query_base (r) + { + } + + query (const query_base& q) + : query_base (q) + { + } + + template <database_type_id ID> + query (const query_column<bool, ID>& qc) + : query_base (qc) + { + } + }; + } + + // Derive odb::query from odb::sqlite::query so that it can be + // implicitly converted in sqlite::database::query() calls. + // template <typename T> - class query<T, sqlite::query>: public sqlite::query, - public query_selector<T>::columns_type + class query<T, sqlite::query_base>: public sqlite::query<T> { public: // We don't define any typedefs here since they may clash with @@ -1303,44 +1365,44 @@ namespace odb explicit query (bool v) - : sqlite::query (v) + : sqlite::query<T> (v) { } explicit query (const char* q) - : sqlite::query (q) + : sqlite::query<T> (q) { } explicit query (const std::string& q) - : sqlite::query (q) + : sqlite::query<T> (q) { } template <typename T2> explicit query (sqlite::val_bind<T2> v) - : sqlite::query (sqlite::query (v)) + : sqlite::query<T> (v) { } template <typename T2> explicit query (sqlite::ref_bind<T2> r) - : sqlite::query (sqlite::query (r)) + : sqlite::query<T> (r) { } - query (const sqlite::query& q) - : sqlite::query (q) + query (const sqlite::query_base& q) + : sqlite::query<T> (q) { } template <sqlite::database_type_id ID> query (const sqlite::query_column<bool, ID>& qc) - : sqlite::query (qc) + : sqlite::query<T> (qc) { } }; diff --git a/odb/sqlite/query.ixx b/odb/sqlite/query.ixx index 113b376..631749f 100644 --- a/odb/sqlite/query.ixx +++ b/odb/sqlite/query.ixx @@ -6,20 +6,20 @@ namespace odb { namespace sqlite { - inline binding& query:: + inline binding& query_base:: parameters_binding () const { return parameters_->binding (); } - inline details::shared_ptr<query_params> query:: + inline details::shared_ptr<query_params> query_base:: parameters () const { return parameters_; } template <typename T, database_type_id ID> - inline void query:: + inline void query_base:: append (val_bind<T> v, const char* conv) { add ( @@ -29,7 +29,7 @@ namespace odb } template <typename T, database_type_id ID> - inline void query:: + inline void query_base:: append (ref_bind<T> r, const char* conv) { add ( diff --git a/odb/sqlite/query.txx b/odb/sqlite/query.txx index ba3fac1..f719ece 100644 --- a/odb/sqlite/query.txx +++ b/odb/sqlite/query.txx @@ -6,12 +6,12 @@ namespace odb { namespace sqlite { - // query + // query_base // template <database_type_id ID> - query:: - query (const query_column<bool, ID>& c) + query_base:: + query_base (const query_column<bool, ID>& c) : parameters_ (new (details::shared) query_params) { // Cannot use IS TRUE here since database type can be a non- @@ -25,10 +25,10 @@ namespace odb // query_column // template <typename T, database_type_id ID> - query query_column<T, ID>:: + query_base query_column<T, ID>:: in (const T& v1, const T& v2) const { - query q (table_, column_); + query_base q (table_, column_); q += "IN ("; q.append<T, ID> (val_bind<T> (v1), conversion_); q += ","; @@ -38,10 +38,10 @@ namespace odb } template <typename T, database_type_id ID> - query query_column<T, ID>:: + query_base query_column<T, ID>:: in (const T& v1, const T& v2, const T& v3) const { - query q (table_, column_); + query_base q (table_, column_); q += "IN ("; q.append<T, ID> (val_bind<T> (v1), conversion_); q += ","; @@ -53,10 +53,10 @@ namespace odb } template <typename T, database_type_id ID> - query query_column<T, ID>:: + query_base query_column<T, ID>:: in (const T& v1, const T& v2, const T& v3, const T& v4) const { - query q (table_, column_); + query_base q (table_, column_); q += "IN ("; q.append<T, ID> (val_bind<T> (v1), conversion_); q += ","; @@ -70,10 +70,10 @@ namespace odb } template <typename T, database_type_id ID> - query query_column<T, ID>:: + query_base query_column<T, ID>:: in (const T& v1, const T& v2, const T& v3, const T& v4, const T& v5) const { - query q (table_, column_); + query_base q (table_, column_); q += "IN ("; q.append<T, ID> (val_bind<T> (v1), conversion_); q += ","; @@ -90,10 +90,10 @@ namespace odb template <typename T, database_type_id ID> template <typename I> - query query_column<T, ID>:: + query_base query_column<T, ID>:: in_range (I begin, I end) const { - query q (table_, column_); + query_base q (table_, column_); q += "IN ("; for (I i (begin); i != end; ++i) @@ -103,6 +103,7 @@ namespace odb q.append<T, ID> (val_bind<T> (*i), conversion_); } + q += ")"; return q; } diff --git a/odb/sqlite/result.cxx b/odb/sqlite/result.cxx index 2c950d0..f8b1073 100644 --- a/odb/sqlite/result.cxx +++ b/odb/sqlite/result.cxx @@ -10,7 +10,8 @@ namespace odb namespace sqlite { result_impl_base:: - result_impl_base (const query& q, details::shared_ptr<select_statement> s) + result_impl_base (const query_base& q, + details::shared_ptr<select_statement> s) : params_ (q.parameters ()), statement_ (s) { } diff --git a/odb/sqlite/result.hxx b/odb/sqlite/result.hxx index 92c1bb1..cd2d376 100644 --- a/odb/sqlite/result.hxx +++ b/odb/sqlite/result.hxx @@ -10,7 +10,7 @@ #include <odb/details/shared-ptr.hxx> #include <odb/sqlite/version.hxx> -#include <odb/sqlite/forward.hxx> // query, query_params +#include <odb/sqlite/forward.hxx> // query_base, query_params #include <odb/sqlite/statement.hxx> #include <odb/sqlite/details/export.hxx> @@ -22,7 +22,8 @@ namespace odb class LIBODB_SQLITE_EXPORT result_impl_base { public: - result_impl_base (const query&, details::shared_ptr<select_statement>); + result_impl_base (const query_base&, + details::shared_ptr<select_statement>); protected: // We need to hold on to the query parameters because SQLite uses diff --git a/odb/sqlite/simple-object-result.hxx b/odb/sqlite/simple-object-result.hxx index 8c748bc..08132b1 100644 --- a/odb/sqlite/simple-object-result.hxx +++ b/odb/sqlite/simple-object-result.hxx @@ -14,7 +14,7 @@ #include <odb/details/shared-ptr.hxx> #include <odb/sqlite/version.hxx> -#include <odb/sqlite/forward.hxx> // query +#include <odb/sqlite/forward.hxx> // query_base #include <odb/sqlite/result.hxx> #include <odb/sqlite/statement.hxx> @@ -29,11 +29,11 @@ namespace odb public: typedef odb::object_result_impl<T> base_type; - typedef typename base_type::object_traits object_traits; - typedef typename base_type::object_type object_type; typedef typename base_type::id_type id_type; - + typedef typename base_type::object_type object_type; typedef typename base_type::pointer_type pointer_type; + + typedef object_traits_impl<object_type, id_sqlite> object_traits; typedef typename base_type::pointer_traits pointer_traits; typedef typename object_traits::statements_type statements_type; @@ -41,7 +41,7 @@ namespace odb virtual ~object_result_impl (); - object_result_impl (const query&, + object_result_impl (const query_base&, details::shared_ptr<select_statement>, statements_type&); diff --git a/odb/sqlite/simple-object-result.txx b/odb/sqlite/simple-object-result.txx index 2152a21..34eaab5 100644 --- a/odb/sqlite/simple-object-result.txx +++ b/odb/sqlite/simple-object-result.txx @@ -23,7 +23,7 @@ namespace odb template <typename T> object_result_impl<T>:: - object_result_impl (const query& q, + object_result_impl (const query_base& q, details::shared_ptr<select_statement> statement, statements_type& statements) : base_type (statements.connection ().database ()), diff --git a/odb/sqlite/simple-object-statements.hxx b/odb/sqlite/simple-object-statements.hxx index 90f2494..66dc0f9 100644 --- a/odb/sqlite/simple-object-statements.hxx +++ b/odb/sqlite/simple-object-statements.hxx @@ -147,7 +147,7 @@ namespace odb struct optimistic_data<T, true> { typedef T object_type; - typedef odb::object_traits<object_type> object_traits; + typedef object_traits_impl<object_type, id_sqlite> object_traits; optimistic_data (bind*); @@ -170,7 +170,7 @@ namespace odb { public: typedef T object_type; - typedef odb::object_traits<object_type> object_traits; + typedef object_traits_impl<object_type, id_sqlite> object_traits; typedef typename object_traits::id_type id_type; typedef typename object_traits::pointer_type pointer_type; typedef typename object_traits::image_type image_type; diff --git a/odb/sqlite/statement-cache.hxx b/odb/sqlite/statement-cache.hxx index 5d94296..b08e4c7 100644 --- a/odb/sqlite/statement-cache.hxx +++ b/odb/sqlite/statement-cache.hxx @@ -69,7 +69,7 @@ namespace odb } template <typename T> - typename object_traits<T>::statements_type& + typename object_traits_impl<T, id_sqlite>::statements_type& find_object (); template <typename T> diff --git a/odb/sqlite/statement-cache.txx b/odb/sqlite/statement-cache.txx index b702712..775a6a8 100644 --- a/odb/sqlite/statement-cache.txx +++ b/odb/sqlite/statement-cache.txx @@ -7,10 +7,13 @@ namespace odb namespace sqlite { template <typename T> - typename object_traits<T>::statements_type& statement_cache:: + typename object_traits_impl<T, id_sqlite>::statements_type& + statement_cache:: find_object () { - typedef typename object_traits<T>::statements_type statements_type; + typedef + typename object_traits_impl<T, id_sqlite>::statements_type + statements_type; map::iterator i (map_.find (&typeid (T))); diff --git a/odb/sqlite/view-result.hxx b/odb/sqlite/view-result.hxx index 82910db..846504f 100644 --- a/odb/sqlite/view-result.hxx +++ b/odb/sqlite/view-result.hxx @@ -14,7 +14,7 @@ #include <odb/details/shared-ptr.hxx> #include <odb/sqlite/version.hxx> -#include <odb/sqlite/forward.hxx> // query, view_statements +#include <odb/sqlite/forward.hxx> // query_base, view_statements #include <odb/sqlite/statement.hxx> namespace odb @@ -29,9 +29,9 @@ namespace odb typedef odb::view_result_impl<T> base_type; typedef typename base_type::view_type view_type; - typedef typename base_type::view_traits view_traits; - typedef typename base_type::pointer_type pointer_type; + + typedef view_traits_impl<view_type, id_sqlite> view_traits; typedef typename base_type::pointer_traits pointer_traits; typedef view_statements<view_type> statements_type; @@ -39,7 +39,7 @@ namespace odb virtual ~view_result_impl (); - view_result_impl (const query&, + view_result_impl (const query_base&, details::shared_ptr<select_statement>, statements_type&); diff --git a/odb/sqlite/view-result.txx b/odb/sqlite/view-result.txx index f2170c9..7d8ac5f 100644 --- a/odb/sqlite/view-result.txx +++ b/odb/sqlite/view-result.txx @@ -21,7 +21,7 @@ namespace odb template <typename T> view_result_impl<T>:: - view_result_impl (const query& q, + view_result_impl (const query_base& q, details::shared_ptr<select_statement> statement, statements_type& statements) : base_type (statements.connection ().database ()), diff --git a/odb/sqlite/view-statements.hxx b/odb/sqlite/view-statements.hxx index 9a4f566..ca99bb1 100644 --- a/odb/sqlite/view-statements.hxx +++ b/odb/sqlite/view-statements.hxx @@ -26,7 +26,7 @@ namespace odb { public: typedef T view_type; - typedef odb::view_traits<view_type> view_traits; + typedef view_traits_impl<view_type, id_sqlite> view_traits; typedef typename view_traits::pointer_type pointer_type; typedef typename view_traits::image_type image_type; |