aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorBoris Kolpackov <boris@codesynthesis.com>2012-10-08 16:09:08 +0200
committerBoris Kolpackov <boris@codesynthesis.com>2012-10-08 16:09:08 +0200
commit382035d872a2cbb22fc14d3c87db93b1f39b407b (patch)
treeeae01dfdad70ffc916e3dc23a6f279a1a25a1556
parentd8fed1d9dbab80e14033b385c604abb41cc84390 (diff)
Ground work for multi-database support
All generated code now includes database id. The database-specific database class interface has been updated to include all the database operations. The database-specific tests now use this interface.
-rw-r--r--odb/sqlite/database.cxx9
-rw-r--r--odb/sqlite/database.hxx186
-rw-r--r--odb/sqlite/database.ixx378
-rw-r--r--odb/sqlite/forward.hxx2
-rw-r--r--odb/sqlite/no-id-object-result.hxx8
-rw-r--r--odb/sqlite/no-id-object-result.txx2
-rw-r--r--odb/sqlite/no-id-object-statements.hxx2
-rw-r--r--odb/sqlite/polymorphic-object-result.hxx13
-rw-r--r--odb/sqlite/polymorphic-object-result.txx6
-rw-r--r--odb/sqlite/polymorphic-object-statements.hxx2
-rw-r--r--odb/sqlite/query-const-expr.cxx2
-rw-r--r--odb/sqlite/query.cxx44
-rw-r--r--odb/sqlite/query.hxx424
-rw-r--r--odb/sqlite/query.ixx8
-rw-r--r--odb/sqlite/query.txx27
-rw-r--r--odb/sqlite/result.cxx3
-rw-r--r--odb/sqlite/result.hxx5
-rw-r--r--odb/sqlite/simple-object-result.hxx10
-rw-r--r--odb/sqlite/simple-object-result.txx2
-rw-r--r--odb/sqlite/simple-object-statements.hxx4
-rw-r--r--odb/sqlite/statement-cache.hxx2
-rw-r--r--odb/sqlite/statement-cache.txx7
-rw-r--r--odb/sqlite/view-result.hxx8
-rw-r--r--odb/sqlite/view-result.txx2
-rw-r--r--odb/sqlite/view-statements.hxx2
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;