aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--odb/oracle/database.cxx9
-rw-r--r--odb/oracle/database.hxx186
-rw-r--r--odb/oracle/database.ixx378
-rw-r--r--odb/oracle/forward.hxx3
-rw-r--r--odb/oracle/no-id-object-result.hxx8
-rw-r--r--odb/oracle/no-id-object-result.txx2
-rw-r--r--odb/oracle/no-id-object-statements.hxx2
-rw-r--r--odb/oracle/polymorphic-object-result.hxx13
-rw-r--r--odb/oracle/polymorphic-object-result.txx6
-rw-r--r--odb/oracle/polymorphic-object-statements.hxx2
-rw-r--r--odb/oracle/query-const-expr.cxx2
-rw-r--r--odb/oracle/query.cxx46
-rw-r--r--odb/oracle/query.hxx430
-rw-r--r--odb/oracle/query.ixx4
-rw-r--r--odb/oracle/query.txx27
-rw-r--r--odb/oracle/simple-object-result.hxx10
-rw-r--r--odb/oracle/simple-object-result.txx2
-rw-r--r--odb/oracle/simple-object-statements.hxx4
-rw-r--r--odb/oracle/statement-cache.hxx2
-rw-r--r--odb/oracle/statement-cache.txx7
-rw-r--r--odb/oracle/view-result.hxx8
-rw-r--r--odb/oracle/view-result.txx2
-rw-r--r--odb/oracle/view-statements.hxx2
23 files changed, 894 insertions, 261 deletions
diff --git a/odb/oracle/database.cxx b/odb/oracle/database.cxx
index bb086f6..e71eb40 100644
--- a/odb/oracle/database.cxx
+++ b/odb/oracle/database.cxx
@@ -28,7 +28,8 @@ namespace odb
ub2 ncharset,
OCIEnv* environment,
transfer_ptr<connection_factory> factory)
- : user_ (user),
+ : odb::database (id_oracle),
+ user_ (user),
password_ (password),
db_ (db),
port_ (0),
@@ -67,7 +68,8 @@ namespace odb
ub2 ncharset,
OCIEnv* environment,
transfer_ptr<connection_factory> factory)
- : user_ (user),
+ : odb::database (id_oracle),
+ user_ (user),
password_ (password),
service_ (service),
host_ (host),
@@ -125,7 +127,8 @@ namespace odb
ub2 ncharset,
OCIEnv* environment,
transfer_ptr<connection_factory> factory)
- : port_ (0),
+ : odb::database (id_oracle),
+ port_ (0),
charset_ (charset),
ncharset_ (ncharset),
environment_ (environment),
diff --git a/odb/oracle/database.hxx b/odb/oracle/database.hxx
index b92f00d..da98228 100644
--- a/odb/oracle/database.hxx
+++ b/odb/oracle/database.hxx
@@ -17,6 +17,7 @@
#include <odb/oracle/version.hxx>
#include <odb/oracle/forward.hxx>
+#include <odb/oracle/query.hxx>
#include <odb/oracle/tracer.hxx>
#include <odb/oracle/connection.hxx>
#include <odb/oracle/connection-factory.hxx>
@@ -82,6 +83,191 @@ namespace odb
static void
print_usage (std::ostream&);
+ // 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 oracle::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 oracle::query<T>&);
+
public:
virtual transaction_impl*
begin ();
diff --git a/odb/oracle/database.ixx b/odb/oracle/database.ixx
index be4c748..6d60d1e 100644
--- a/odb/oracle/database.ixx
+++ b/odb/oracle/database.ixx
@@ -15,5 +15,383 @@ namespace odb
return connection_ptr (
static_cast<oracle::connection*> (connection_ ()));
}
+
+ template <typename T>
+ inline typename object_traits<T>::id_type database::
+ persist (T& obj)
+ {
+ return persist_<T, id_oracle> (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_oracle> (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_oracle> (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_oracle> (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_oracle> (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_oracle> (id);
+ }
+
+ template <typename T>
+ inline void database::
+ load (const typename object_traits<T>::id_type& id, T& obj)
+ {
+ return load_<T, id_oracle> (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_oracle> (id);
+ }
+
+ template <typename T>
+ inline bool database::
+ find (const typename object_traits<T>::id_type& id, T& obj)
+ {
+ return find_<T, id_oracle> (id, obj);
+ }
+
+ template <typename T>
+ inline void database::
+ reload (T& obj)
+ {
+ reload_<T, id_oracle> (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_oracle> (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_oracle> (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_oracle> (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_oracle> (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_oracle> (pobj);
+ }
+
+ template <typename T>
+ inline void database::
+ erase (const typename object_traits<T>::id_type& id)
+ {
+ return erase_<T, id_oracle> (id);
+ }
+
+ template <typename T>
+ inline void database::
+ erase (T& obj)
+ {
+ return erase_<T, id_oracle> (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_oracle> (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_oracle> (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_oracle> (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_oracle> (pobj);
+ }
+
+ template <typename T>
+ inline unsigned long long database::
+ erase_query ()
+ {
+ // T is always object_type.
+ //
+ return erase_query<T> (oracle::query<T> ());
+ }
+
+ template <typename T>
+ inline unsigned long long database::
+ erase_query (const char* q)
+ {
+ // T is always object_type.
+ //
+ return erase_query<T> (oracle::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> (oracle::query<T> (q));
+ }
+
+ template <typename T>
+ inline unsigned long long database::
+ erase_query (const oracle::query<T>& q)
+ {
+ // T is always object_type.
+ //
+ return object_traits_impl<T, id_oracle>::erase_query (*this, q);
+ }
+
+ template <typename T>
+ inline result<T> database::
+ query ()
+ {
+ return query<T> (oracle::query<T> ());
+ }
+
+ template <typename T>
+ inline result<T> database::
+ query (const char* q)
+ {
+ return query<T> (oracle::query<T> (q));
+ }
+
+ template <typename T>
+ inline result<T> database::
+ query (const std::string& q)
+ {
+ return query<T> (oracle::query<T> (q));
+ }
+
+ template <typename T>
+ inline result<T> database::
+ query (const oracle::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_oracle>::call (*this, q);
+ }
}
}
diff --git a/odb/oracle/forward.hxx b/odb/oracle/forward.hxx
index 484fbfc..24dbf44 100644
--- a/odb/oracle/forward.hxx
+++ b/odb/oracle/forward.hxx
@@ -20,7 +20,6 @@ namespace odb
class statement;
class transaction;
class tracer;
- class query;
// Implementation details.
//
@@ -51,6 +50,8 @@ namespace odb
template <typename T>
class container_statements;
+
+ class query_base;
}
namespace details
diff --git a/odb/oracle/no-id-object-result.hxx b/odb/oracle/no-id-object-result.hxx
index bd00b15..499c1b6 100644
--- a/odb/oracle/no-id-object-result.hxx
+++ b/odb/oracle/no-id-object-result.hxx
@@ -14,7 +14,7 @@
#include <odb/details/shared-ptr.hxx>
#include <odb/oracle/version.hxx>
-#include <odb/oracle/forward.hxx> // query
+#include <odb/oracle/forward.hxx> // query_base
#include <odb/oracle/statement.hxx>
namespace odb
@@ -28,9 +28,9 @@ namespace odb
typedef odb::no_id_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::pointer_type pointer_type;
+
+ typedef object_traits_impl<object_type, id_oracle> object_traits;
typedef typename base_type::pointer_traits pointer_traits;
typedef typename object_traits::statements_type statements_type;
@@ -38,7 +38,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/oracle/no-id-object-result.txx b/odb/oracle/no-id-object-result.txx
index 3d1f63b..405d139 100644
--- a/odb/oracle/no-id-object-result.txx
+++ b/odb/oracle/no-id-object-result.txx
@@ -31,7 +31,7 @@ namespace odb
template <typename T>
no_id_object_result_impl<T>::
- no_id_object_result_impl (const query&,
+ no_id_object_result_impl (const query_base&,
details::shared_ptr<select_statement> statement,
statements_type& statements)
: base_type (statements.connection ().database ()),
diff --git a/odb/oracle/no-id-object-statements.hxx b/odb/oracle/no-id-object-statements.hxx
index 0aa5cf0..613da39 100644
--- a/odb/oracle/no-id-object-statements.hxx
+++ b/odb/oracle/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_oracle> object_traits;
typedef typename object_traits::pointer_type pointer_type;
typedef typename object_traits::image_type image_type;
diff --git a/odb/oracle/polymorphic-object-result.hxx b/odb/oracle/polymorphic-object-result.hxx
index 2137c1d..5092aa7 100644
--- a/odb/oracle/polymorphic-object-result.hxx
+++ b/odb/oracle/polymorphic-object-result.hxx
@@ -14,7 +14,7 @@
#include <odb/details/shared-ptr.hxx>
#include <odb/oracle/version.hxx>
-#include <odb/oracle/forward.hxx> // query
+#include <odb/oracle/forward.hxx> // query_base
#include <odb/oracle/statement.hxx>
namespace odb
@@ -28,24 +28,25 @@ 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_oracle> 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_oracle> root_traits;
+
typedef typename object_traits::image_type image_type;
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/oracle/polymorphic-object-result.txx b/odb/oracle/polymorphic-object-result.txx
index af9f8eb..9db06cc 100644
--- a/odb/oracle/polymorphic-object-result.txx
+++ b/odb/oracle/polymorphic-object-result.txx
@@ -35,7 +35,7 @@ namespace odb
template <typename T>
polymorphic_object_result_impl<T>::
- polymorphic_object_result_impl (const query&,
+ polymorphic_object_result_impl (const query_base&,
details::shared_ptr<select_statement> st,
statements_type& sts)
: base_type (sts.connection ().database ()),
@@ -191,7 +191,7 @@ namespace odb
{
// Derived type version.
//
- typedef object_traits<T> traits;
+ typedef object_traits_impl<T, id_oracle> traits;
static void
rebind (typename traits::statements_type& sts)
@@ -223,7 +223,7 @@ namespace odb
{
// Root type version.
//
- typedef object_traits<R> traits;
+ typedef object_traits_impl<R, id_oracle> traits;
static void
rebind (typename traits::statements_type& sts)
diff --git a/odb/oracle/polymorphic-object-statements.hxx b/odb/oracle/polymorphic-object-statements.hxx
index dce30c3..88ed575 100644
--- a/odb/oracle/polymorphic-object-statements.hxx
+++ b/odb/oracle/polymorphic-object-statements.hxx
@@ -148,7 +148,7 @@ namespace odb
{
public:
typedef T object_type;
- typedef odb::object_traits<object_type> object_traits;
+ typedef object_traits_impl<object_type, id_oracle> 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/oracle/query-const-expr.cxx b/odb/oracle/query-const-expr.cxx
index 33b41bc..c11f677 100644
--- a/odb/oracle/query-const-expr.cxx
+++ b/odb/oracle/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/oracle/query.cxx b/odb/oracle/query.cxx
index e66d9e4..df6a629 100644
--- a/odb/oracle/query.cxx
+++ b/odb/oracle/query.cxx
@@ -21,10 +21,10 @@ namespace odb
{
}
- // query
+ // query_base
//
- query::
- query (const query& q)
+ query_base::
+ query_base (const query_base& q)
: clause_ (q.clause_),
parameters_ (q.parameters_),
bind_ (q.bind_),
@@ -44,8 +44,8 @@ namespace odb
}
}
- query& query::
- operator= (const query& q)
+ query_base& query_base::
+ operator= (const query_base& q)
{
if (this != &q)
{
@@ -62,8 +62,8 @@ 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 ());
@@ -85,7 +85,7 @@ namespace odb
return *this;
}
- void query::
+ void query_base::
append (const string& q)
{
if (!clause_.empty () && clause_.back ().kind == clause_part::native)
@@ -108,7 +108,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);
@@ -118,7 +118,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));
@@ -137,7 +137,7 @@ namespace odb
p->bind (b);
}
- binding& query::
+ binding& query_base::
parameters_binding () const
{
size_t n (parameters_.size ());
@@ -199,7 +199,7 @@ namespace odb
return false;
}
- void query::
+ void query_base::
optimize ()
{
// Remove a single TRUE literal or one that is followe by one of
@@ -219,7 +219,7 @@ namespace odb
}
}
- const char* query::
+ const char* query_base::
clause_prefix () const
{
if (!clause_.empty ())
@@ -235,7 +235,7 @@ namespace odb
return "";
}
- string query::
+ string query_base::
clause () const
{
string r;
@@ -316,8 +316,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.
//
@@ -332,7 +332,7 @@ namespace odb
if (yt)
return x;
- query r ("(");
+ query_base r ("(");
r += x;
r += ") AND (";
r += y;
@@ -340,10 +340,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;
@@ -351,10 +351,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/oracle/query.hxx b/odb/oracle/query.hxx
index d6e5a6c..aaba740 100644
--- a/odb/oracle/query.hxx
+++ b/odb/oracle/query.hxx
@@ -103,7 +103,7 @@ namespace odb
template <typename T, database_type_id ID>
struct query_column;
- class LIBODB_ORACLE_EXPORT query
+ class LIBODB_ORACLE_EXPORT query_base
{
public:
struct clause_part
@@ -125,7 +125,7 @@ namespace odb
bool bool_part;
};
- query ()
+ query_base ()
: binding_ (0, 0)
{
}
@@ -133,27 +133,27 @@ namespace odb
// True or false literal.
//
explicit
- query (bool v)
+ query_base (bool v)
: binding_ (0, 0)
{
clause_.push_back (clause_part (v));
}
explicit
- query (const char* native)
+ query_base (const char* native)
: binding_ (0, 0)
{
clause_.push_back (clause_part (clause_part::native, native));
}
explicit
- query (const std::string& native)
+ query_base (const std::string& native)
: binding_ (0, 0)
{
clause_.push_back (clause_part (clause_part::native, native));
}
- query (const char* table, const char* column)
+ query_base (const char* table, const char* column)
: binding_ (0, 0)
{
append (table, column);
@@ -161,7 +161,7 @@ namespace odb
template <typename T>
explicit
- query (val_bind<T> v)
+ query_base (val_bind<T> v)
: binding_ (0, 0)
{
append<T, type_traits<T>::db_type_id> (
@@ -170,7 +170,7 @@ namespace odb
template <typename T>
explicit
- query (ref_bind<T> r)
+ query_base (ref_bind<T> r)
: binding_ (0, 0)
{
append<T, type_traits<T>::db_type_id> (
@@ -178,12 +178,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
@@ -202,7 +202,7 @@ namespace odb
return clause_.empty ();
}
- static const query true_expr;
+ static const query_base true_expr;
bool
const_true () const
@@ -231,10 +231,10 @@ namespace odb
}
public:
- query&
- operator+= (const query&);
+ query_base&
+ operator+= (const query_base&);
- query&
+ query_base&
operator+= (const std::string& q)
{
append (q);
@@ -242,7 +242,7 @@ namespace odb
}
template <typename T>
- query&
+ query_base&
operator+= (val_bind<T> v)
{
append<T, type_traits<T>::db_type_id> (
@@ -251,7 +251,7 @@ namespace odb
}
template <typename T>
- query&
+ query_base&
operator+= (ref_bind<T> r)
{
append<T, type_traits<T>::db_type_id> (
@@ -288,114 +288,114 @@ namespace odb
mutable binding binding_;
};
- 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_ORACLE_EXPORT query
- operator&& (const query& x, const query& y);
+ LIBODB_ORACLE_EXPORT query_base
+ operator&& (const query_base& x, const query_base& y);
- LIBODB_ORACLE_EXPORT query
- operator|| (const query& x, const query& y);
+ LIBODB_ORACLE_EXPORT query_base
+ operator|| (const query_base& x, const query_base& y);
- LIBODB_ORACLE_EXPORT query
- operator! (const query& x);
+ LIBODB_ORACLE_EXPORT query_base
+ operator! (const query_base& x);
// query_column
//
@@ -465,18 +465,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;
}
@@ -484,108 +484,108 @@ 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
{
v.prec = prec_;
v.scale = scale_;
- 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
{
r.prec = prec_;
r.scale = scale_;
- 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);
@@ -594,89 +594,89 @@ 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
{
v.prec = prec_;
v.scale = scale_;
- 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
{
r.prec = prec_;
r.scale = scale_;
- 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);
@@ -685,89 +685,89 @@ 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
{
v.prec = prec_;
v.scale = scale_;
- 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
{
r.prec = prec_;
r.scale = scale_;
- 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);
@@ -776,89 +776,89 @@ 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
{
v.prec = prec_;
v.scale = scale_;
- 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
{
r.prec = prec_;
r.scale = scale_;
- 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);
@@ -867,89 +867,89 @@ 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
{
v.prec = prec_;
v.scale = scale_;
- 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
{
r.prec = prec_;
r.scale = scale_;
- 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);
@@ -958,89 +958,89 @@ 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
{
v.prec = prec_;
v.scale = scale_;
- 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
{
r.prec = prec_;
r.scale = scale_;
- 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);
@@ -1050,84 +1050,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;
@@ -1174,18 +1174,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;
}
@@ -1226,37 +1226,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;
}
@@ -1538,7 +1538,6 @@ namespace odb
query_param_impl (val_bind<T> v)
: query_param (0),
image_ (0) // Don't cache, don't free.
-
{
init (v.val);
}
@@ -1585,7 +1584,6 @@ namespace odb
query_param_impl (val_bind<T> v)
: query_param (0),
image_ (0) // Don't cache, don't free.
-
{
init (v.val);
}
@@ -1826,13 +1824,75 @@ namespace odb
}
}
-// odb::query specialization for Oracle.
+// odb::oracle::query and odb::query specialization for Oracle.
//
namespace odb
{
+ namespace oracle
+ {
+ template <typename T>
+ class query: public query_base,
+ public query_selector<T, id_oracle>::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::oracle::query so that it can be
+ // implicitly converted in oracle::database::query() calls.
+ //
template <typename T>
- class query<T, oracle::query>: public oracle::query,
- public query_selector<T>::columns_type
+ class query<T, oracle::query_base>: public oracle::query<T>
{
public:
// We don't define any typedefs here since they may clash with
@@ -1845,44 +1905,44 @@ namespace odb
explicit
query (bool v)
- : oracle::query (v)
+ : oracle::query<T> (v)
{
}
explicit
query (const char* q)
- : oracle::query (q)
+ : oracle::query<T> (q)
{
}
explicit
query (const std::string& q)
- : oracle::query (q)
+ : oracle::query<T> (q)
{
}
template <typename T2>
explicit
query (oracle::val_bind<T2> v)
- : oracle::query (oracle::query (v))
+ : oracle::query<T> (v)
{
}
template <typename T2>
explicit
query (oracle::ref_bind<T2> r)
- : oracle::query (oracle::query (r))
+ : oracle::query<T> (r)
{
}
- query (const oracle::query& q)
- : oracle::query (q)
+ query (const oracle::query_base& q)
+ : oracle::query<T> (q)
{
}
template <oracle::database_type_id ID>
query (const oracle::query_column<bool, ID>& qc)
- : oracle::query (qc)
+ : oracle::query<T> (qc)
{
}
};
diff --git a/odb/oracle/query.ixx b/odb/oracle/query.ixx
index 2a41ae4..75e7bfe 100644
--- a/odb/oracle/query.ixx
+++ b/odb/oracle/query.ixx
@@ -7,7 +7,7 @@ namespace odb
namespace oracle
{
template <typename T, database_type_id ID>
- inline void query::
+ inline void query_base::
append (val_bind<T> v, const char* conv)
{
add (
@@ -17,7 +17,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/oracle/query.txx b/odb/oracle/query.txx
index 47bf513..5921efe 100644
--- a/odb/oracle/query.txx
+++ b/odb/oracle/query.txx
@@ -6,12 +6,12 @@ namespace odb
{
namespace oracle
{
- // 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)
: binding_ (0, 0)
{
// Cannot use IS TRUE here since database type can be a non-
@@ -26,10 +26,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, prec_, scale_), conversion_);
q += ",";
@@ -39,10 +39,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, prec_, scale_), conversion_);
q += ",";
@@ -54,10 +54,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, prec_, scale_), conversion_);
q += ",";
@@ -71,10 +71,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, prec_, scale_), conversion_);
q += ",";
@@ -91,10 +91,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)
@@ -104,6 +104,7 @@ namespace odb
q.append<T, ID> (val_bind<T> (*i, prec_, scale_), conversion_);
}
+
q += ")";
return q;
}
diff --git a/odb/oracle/simple-object-result.hxx b/odb/oracle/simple-object-result.hxx
index cbfe8c5..cde1a18 100644
--- a/odb/oracle/simple-object-result.hxx
+++ b/odb/oracle/simple-object-result.hxx
@@ -14,7 +14,7 @@
#include <odb/details/shared-ptr.hxx>
#include <odb/oracle/version.hxx>
-#include <odb/oracle/forward.hxx> // query
+#include <odb/oracle/forward.hxx> // query_base
#include <odb/oracle/statement.hxx>
namespace odb
@@ -27,11 +27,11 @@ namespace odb
public:
typedef odb::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_oracle> object_traits;
typedef typename base_type::pointer_traits pointer_traits;
typedef typename object_traits::statements_type statements_type;
@@ -39,7 +39,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/oracle/simple-object-result.txx b/odb/oracle/simple-object-result.txx
index ec0d1f5..b36eb3b 100644
--- a/odb/oracle/simple-object-result.txx
+++ b/odb/oracle/simple-object-result.txx
@@ -33,7 +33,7 @@ namespace odb
template <typename T>
object_result_impl<T>::
- object_result_impl (const query&,
+ object_result_impl (const query_base&,
details::shared_ptr<select_statement> statement,
statements_type& statements)
: base_type (statements.connection ().database ()),
diff --git a/odb/oracle/simple-object-statements.hxx b/odb/oracle/simple-object-statements.hxx
index e33a7e7..46ed9ca 100644
--- a/odb/oracle/simple-object-statements.hxx
+++ b/odb/oracle/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_oracle> 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_oracle> 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/oracle/statement-cache.hxx b/odb/oracle/statement-cache.hxx
index d4d65ca..4163b36 100644
--- a/odb/oracle/statement-cache.hxx
+++ b/odb/oracle/statement-cache.hxx
@@ -32,7 +32,7 @@ namespace odb
statement_cache (connection& conn): conn_ (conn) {}
template <typename T>
- typename object_traits<T>::statements_type&
+ typename object_traits_impl<T, id_oracle>::statements_type&
find_object ();
template <typename T>
diff --git a/odb/oracle/statement-cache.txx b/odb/oracle/statement-cache.txx
index 6f62b8f..77bed7e 100644
--- a/odb/oracle/statement-cache.txx
+++ b/odb/oracle/statement-cache.txx
@@ -7,10 +7,13 @@ namespace odb
namespace oracle
{
template <typename T>
- typename object_traits<T>::statements_type& statement_cache::
+ typename object_traits_impl<T, id_oracle>::statements_type&
+ statement_cache::
find_object ()
{
- typedef typename object_traits<T>::statements_type statements_type;
+ typedef
+ typename object_traits_impl<T, id_oracle>::statements_type
+ statements_type;
map::iterator i (map_.find (&typeid (T)));
diff --git a/odb/oracle/view-result.hxx b/odb/oracle/view-result.hxx
index f44911a..ccbf57b 100644
--- a/odb/oracle/view-result.hxx
+++ b/odb/oracle/view-result.hxx
@@ -14,7 +14,7 @@
#include <odb/details/shared-ptr.hxx>
#include <odb/oracle/version.hxx>
-#include <odb/oracle/forward.hxx> // query, view_statements
+#include <odb/oracle/forward.hxx> // query_base, view_statements
#include <odb/oracle/statement.hxx>
namespace odb
@@ -28,9 +28,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_oracle> view_traits;
typedef typename base_type::pointer_traits pointer_traits;
typedef view_statements<view_type> statements_type;
@@ -38,7 +38,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/oracle/view-result.txx b/odb/oracle/view-result.txx
index dc5cd6a..248ef76 100644
--- a/odb/oracle/view-result.txx
+++ b/odb/oracle/view-result.txx
@@ -31,7 +31,7 @@ namespace odb
template <typename T>
view_result_impl<T>::
- view_result_impl (const query&,
+ view_result_impl (const query_base&,
details::shared_ptr<select_statement> statement,
statements_type& statements)
: base_type (statements.connection ().database ()),
diff --git a/odb/oracle/view-statements.hxx b/odb/oracle/view-statements.hxx
index 4794e4f..aadf094 100644
--- a/odb/oracle/view-statements.hxx
+++ b/odb/oracle/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_oracle> view_traits;
typedef typename view_traits::pointer_type pointer_type;
typedef typename view_traits::image_type image_type;
generated by cgit v1.1 at 2024-11-01 05:23:58 +0000