aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--odb/mssql/database.cxx15
-rw-r--r--odb/mssql/database.hxx186
-rw-r--r--odb/mssql/database.ixx378
-rw-r--r--odb/mssql/forward.hxx3
-rw-r--r--odb/mssql/no-id-object-result.hxx8
-rw-r--r--odb/mssql/no-id-object-result.txx2
-rw-r--r--odb/mssql/no-id-object-statements.hxx2
-rw-r--r--odb/mssql/polymorphic-object-result.hxx13
-rw-r--r--odb/mssql/polymorphic-object-result.txx6
-rw-r--r--odb/mssql/polymorphic-object-statements.hxx2
-rw-r--r--odb/mssql/query-const-expr.cxx2
-rw-r--r--odb/mssql/query.cxx46
-rw-r--r--odb/mssql/query.hxx420
-rw-r--r--odb/mssql/query.ixx4
-rw-r--r--odb/mssql/query.txx27
-rw-r--r--odb/mssql/simple-object-result.hxx10
-rw-r--r--odb/mssql/simple-object-result.txx2
-rw-r--r--odb/mssql/simple-object-statements.hxx4
-rw-r--r--odb/mssql/statement-cache.hxx2
-rw-r--r--odb/mssql/statement-cache.txx7
-rw-r--r--odb/mssql/view-result.hxx8
-rw-r--r--odb/mssql/view-result.txx2
-rw-r--r--odb/mssql/view-statements.hxx2
23 files changed, 894 insertions, 257 deletions
diff --git a/odb/mssql/database.cxx b/odb/mssql/database.cxx
index a56181f..1c42c80 100644
--- a/odb/mssql/database.cxx
+++ b/odb/mssql/database.cxx
@@ -29,7 +29,8 @@ namespace odb
const std::string& extra_connect_string,
SQLHENV environment,
transfer_ptr<connection_factory> factory)
- : user_ (user),
+ : odb::database (id_mssql),
+ user_ (user),
password_ (password),
db_ (db),
protocol_ (protocol_auto),
@@ -54,7 +55,8 @@ namespace odb
const std::string& extra_connect_string,
SQLHENV environment,
transfer_ptr<connection_factory> factory)
- : user_ (user),
+ : odb::database (id_mssql),
+ user_ (user),
password_ (password),
db_ (db),
protocol_ (protocol),
@@ -79,7 +81,8 @@ namespace odb
const std::string& extra_connect_string,
SQLHENV environment,
transfer_ptr<connection_factory> factory)
- : user_ (user),
+ : odb::database (id_mssql),
+ user_ (user),
password_ (password),
db_ (db),
protocol_ (protocol_tcp),
@@ -97,7 +100,8 @@ namespace odb
database (const string& connect_string,
SQLHENV environment,
transfer_ptr<connection_factory> factory)
- : protocol_ (protocol_auto),
+ : odb::database (id_mssql),
+ protocol_ (protocol_auto),
port_ (0),
connect_string_ (connect_string),
environment_ (environment),
@@ -113,7 +117,8 @@ namespace odb
const std::string& extra_connect_string,
SQLHENV environment,
transfer_ptr<connection_factory> factory)
- : protocol_ (protocol_auto),
+ : odb::database (id_mssql),
+ protocol_ (protocol_auto),
port_ (0),
extra_connect_string_ (extra_connect_string),
environment_ (environment),
diff --git a/odb/mssql/database.hxx b/odb/mssql/database.hxx
index 66b3a86..1bd419b 100644
--- a/odb/mssql/database.hxx
+++ b/odb/mssql/database.hxx
@@ -18,6 +18,7 @@
#include <odb/mssql/mssql-fwd.hxx>
#include <odb/mssql/version.hxx>
#include <odb/mssql/forward.hxx>
+#include <odb/mssql/query.hxx>
#include <odb/mssql/tracer.hxx>
#include <odb/mssql/connection.hxx>
#include <odb/mssql/connection-factory.hxx>
@@ -125,6 +126,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 mssql::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 mssql::query<T>&);
+
public:
virtual transaction_impl*
begin ();
diff --git a/odb/mssql/database.ixx b/odb/mssql/database.ixx
index 258f74b..d73332e 100644
--- a/odb/mssql/database.ixx
+++ b/odb/mssql/database.ixx
@@ -15,5 +15,383 @@ namespace odb
return connection_ptr (
static_cast<mssql::connection*> (connection_ ()));
}
+
+ template <typename T>
+ inline typename object_traits<T>::id_type database::
+ persist (T& obj)
+ {
+ return persist_<T, id_mssql> (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_mssql> (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_mssql> (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_mssql> (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_mssql> (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_mssql> (id);
+ }
+
+ template <typename T>
+ inline void database::
+ load (const typename object_traits<T>::id_type& id, T& obj)
+ {
+ return load_<T, id_mssql> (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_mssql> (id);
+ }
+
+ template <typename T>
+ inline bool database::
+ find (const typename object_traits<T>::id_type& id, T& obj)
+ {
+ return find_<T, id_mssql> (id, obj);
+ }
+
+ template <typename T>
+ inline void database::
+ reload (T& obj)
+ {
+ reload_<T, id_mssql> (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_mssql> (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_mssql> (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_mssql> (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_mssql> (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_mssql> (pobj);
+ }
+
+ template <typename T>
+ inline void database::
+ erase (const typename object_traits<T>::id_type& id)
+ {
+ return erase_<T, id_mssql> (id);
+ }
+
+ template <typename T>
+ inline void database::
+ erase (T& obj)
+ {
+ return erase_<T, id_mssql> (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_mssql> (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_mssql> (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_mssql> (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_mssql> (pobj);
+ }
+
+ template <typename T>
+ inline unsigned long long database::
+ erase_query ()
+ {
+ // T is always object_type.
+ //
+ return erase_query<T> (mssql::query<T> ());
+ }
+
+ template <typename T>
+ inline unsigned long long database::
+ erase_query (const char* q)
+ {
+ // T is always object_type.
+ //
+ return erase_query<T> (mssql::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> (mssql::query<T> (q));
+ }
+
+ template <typename T>
+ inline unsigned long long database::
+ erase_query (const mssql::query<T>& q)
+ {
+ // T is always object_type.
+ //
+ return object_traits_impl<T, id_mssql>::erase_query (*this, q);
+ }
+
+ template <typename T>
+ inline result<T> database::
+ query ()
+ {
+ return query<T> (mssql::query<T> ());
+ }
+
+ template <typename T>
+ inline result<T> database::
+ query (const char* q)
+ {
+ return query<T> (mssql::query<T> (q));
+ }
+
+ template <typename T>
+ inline result<T> database::
+ query (const std::string& q)
+ {
+ return query<T> (mssql::query<T> (q));
+ }
+
+ template <typename T>
+ inline result<T> database::
+ query (const mssql::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_mssql>::call (*this, q);
+ }
}
}
diff --git a/odb/mssql/forward.hxx b/odb/mssql/forward.hxx
index 5fbaacf..2a91c62 100644
--- a/odb/mssql/forward.hxx
+++ b/odb/mssql/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/mssql/no-id-object-result.hxx b/odb/mssql/no-id-object-result.hxx
index d0246aa..97f49f9 100644
--- a/odb/mssql/no-id-object-result.hxx
+++ b/odb/mssql/no-id-object-result.hxx
@@ -14,7 +14,7 @@
#include <odb/details/shared-ptr.hxx>
#include <odb/mssql/version.hxx>
-#include <odb/mssql/forward.hxx> // query
+#include <odb/mssql/forward.hxx> // query_base
#include <odb/mssql/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_mssql> 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/mssql/no-id-object-result.txx b/odb/mssql/no-id-object-result.txx
index f3674fb..c7e9914 100644
--- a/odb/mssql/no-id-object-result.txx
+++ b/odb/mssql/no-id-object-result.txx
@@ -32,7 +32,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/mssql/no-id-object-statements.hxx b/odb/mssql/no-id-object-statements.hxx
index 468b632..8eae7c7 100644
--- a/odb/mssql/no-id-object-statements.hxx
+++ b/odb/mssql/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_mssql> object_traits;
typedef typename object_traits::pointer_type pointer_type;
typedef typename object_traits::image_type image_type;
diff --git a/odb/mssql/polymorphic-object-result.hxx b/odb/mssql/polymorphic-object-result.hxx
index e370661..d9e5c1e 100644
--- a/odb/mssql/polymorphic-object-result.hxx
+++ b/odb/mssql/polymorphic-object-result.hxx
@@ -14,7 +14,7 @@
#include <odb/details/shared-ptr.hxx>
#include <odb/mssql/version.hxx>
-#include <odb/mssql/forward.hxx> // query
+#include <odb/mssql/forward.hxx> // query_base
#include <odb/mssql/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_mssql> 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_mssql> 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/mssql/polymorphic-object-result.txx b/odb/mssql/polymorphic-object-result.txx
index 02e2cd1..e469511 100644
--- a/odb/mssql/polymorphic-object-result.txx
+++ b/odb/mssql/polymorphic-object-result.txx
@@ -36,7 +36,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 ()),
@@ -195,7 +195,7 @@ namespace odb
{
// Derived type version.
//
- typedef object_traits<T> traits;
+ typedef object_traits_impl<T, id_mssql> traits;
static void
rebind (typename traits::statements_type& sts)
@@ -217,7 +217,7 @@ namespace odb
{
// Root type version.
//
- typedef object_traits<R> traits;
+ typedef object_traits_impl<R, id_mssql> traits;
static void
rebind (typename traits::statements_type& sts)
diff --git a/odb/mssql/polymorphic-object-statements.hxx b/odb/mssql/polymorphic-object-statements.hxx
index 79e9875..bc58f6f 100644
--- a/odb/mssql/polymorphic-object-statements.hxx
+++ b/odb/mssql/polymorphic-object-statements.hxx
@@ -147,7 +147,7 @@ namespace odb
{
public:
typedef T object_type;
- typedef odb::object_traits<object_type> object_traits;
+ typedef object_traits_impl<object_type, id_mssql> 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/mssql/query-const-expr.cxx b/odb/mssql/query-const-expr.cxx
index ea35dba..5413704 100644
--- a/odb/mssql/query-const-expr.cxx
+++ b/odb/mssql/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/mssql/query.cxx b/odb/mssql/query.cxx
index 953835f..a0371c7 100644
--- a/odb/mssql/query.cxx
+++ b/odb/mssql/query.cxx
@@ -20,10 +20,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_),
@@ -43,8 +43,8 @@ namespace odb
}
}
- query& query::
- operator= (const query& q)
+ query_base& query_base::
+ operator= (const query_base& q)
{
if (this != &q)
{
@@ -61,8 +61,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 ());
@@ -84,7 +84,7 @@ namespace odb
return *this;
}
- void query::
+ void query_base::
append (const string& q)
{
if (!clause_.empty () && clause_.back ().kind == clause_part::native)
@@ -107,7 +107,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);
@@ -117,7 +117,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));
@@ -136,7 +136,7 @@ namespace odb
p->bind (b);
}
- binding& query::
+ binding& query_base::
parameters_binding () const
{
size_t n (parameters_.size ());
@@ -198,7 +198,7 @@ namespace odb
return false;
}
- void query::
+ void query_base::
optimize ()
{
// Remove a single TRUE literal or one that is followe by one of
@@ -218,7 +218,7 @@ namespace odb
}
}
- const char* query::
+ const char* query_base::
clause_prefix () const
{
if (!clause_.empty ())
@@ -234,7 +234,7 @@ namespace odb
return "";
}
- string query::
+ string query_base::
clause () const
{
string r;
@@ -311,8 +311,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.
//
@@ -327,7 +327,7 @@ namespace odb
if (yt)
return x;
- query r ("(");
+ query_base r ("(");
r += x;
r += ") AND (";
r += y;
@@ -335,10 +335,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;
@@ -346,10 +346,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/mssql/query.hxx b/odb/mssql/query.hxx
index 636b7b6..08e3319 100644
--- a/odb/mssql/query.hxx
+++ b/odb/mssql/query.hxx
@@ -104,7 +104,7 @@ namespace odb
template <typename T, database_type_id ID>
struct query_column;
- class LIBODB_MSSQL_EXPORT query
+ class LIBODB_MSSQL_EXPORT query_base
{
public:
struct clause_part
@@ -126,7 +126,7 @@ namespace odb
bool bool_part;
};
- query ()
+ query_base ()
: binding_ (0, 0)
{
}
@@ -134,27 +134,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);
@@ -162,7 +162,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> (
@@ -171,7 +171,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> (
@@ -179,12 +179,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
@@ -203,7 +203,7 @@ namespace odb
return clause_.empty ();
}
- static const query true_expr;
+ static const query_base true_expr;
bool
const_true () const
@@ -232,10 +232,10 @@ namespace odb
}
public:
- query&
- operator+= (const query&);
+ query_base&
+ operator+= (const query_base&);
- query&
+ query_base&
operator+= (const std::string& q)
{
append (q);
@@ -243,7 +243,7 @@ namespace odb
}
template <typename T>
- query&
+ query_base&
operator+= (val_bind<T> v)
{
append<T, type_traits<T>::db_type_id> (
@@ -252,7 +252,7 @@ namespace odb
}
template <typename T>
- query&
+ query_base&
operator+= (ref_bind<T> r)
{
append<T, type_traits<T>::db_type_id> (
@@ -289,114 +289,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_MSSQL_EXPORT query
- operator&& (const query& x, const query& y);
+ LIBODB_MSSQL_EXPORT query_base
+ operator&& (const query_base& x, const query_base& y);
- LIBODB_MSSQL_EXPORT query
- operator|| (const query& x, const query& y);
+ LIBODB_MSSQL_EXPORT query_base
+ operator|| (const query_base& x, const query_base& y);
- LIBODB_MSSQL_EXPORT query
- operator! (const query& x);
+ LIBODB_MSSQL_EXPORT query_base
+ operator! (const query_base& x);
// query_column
//
@@ -466,18 +466,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;
}
@@ -485,108 +485,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);
@@ -595,89 +595,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);
@@ -686,89 +686,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);
@@ -777,89 +777,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);
@@ -868,89 +868,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);
@@ -959,89 +959,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);
@@ -1051,84 +1051,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;
@@ -1147,37 +1147,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;
}
@@ -2262,13 +2262,75 @@ namespace odb
}
}
-// odb::query specialization for SQL Server.
+// odb::mssql::query and odb::query specialization for SQL Server.
//
namespace odb
{
+ namespace mssql
+ {
+ template <typename T>
+ class query: public query_base,
+ public query_selector<T, id_mssql>::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::mssql::query so that it can be
+ // implicitly converted in mssql::database::query() calls.
+ //
template <typename T>
- class query<T, mssql::query>: public mssql::query,
- public query_selector<T>::columns_type
+ class query<T, mssql::query_base>: public mssql::query<T>
{
public:
// We don't define any typedefs here since they may clash with
@@ -2281,44 +2343,44 @@ namespace odb
explicit
query (bool v)
- : mssql::query (v)
+ : mssql::query<T> (v)
{
}
explicit
query (const char* q)
- : mssql::query (q)
+ : mssql::query<T> (q)
{
}
explicit
query (const std::string& q)
- : mssql::query (q)
+ : mssql::query<T> (q)
{
}
template <typename T2>
explicit
query (mssql::val_bind<T2> v)
- : mssql::query (mssql::query (v))
+ : mssql::query<T> (v)
{
}
template <typename T2>
explicit
query (mssql::ref_bind<T2> r)
- : mssql::query (mssql::query (r))
+ : mssql::query<T> (r)
{
}
- query (const mssql::query& q)
- : mssql::query (q)
+ query (const mssql::query_base& q)
+ : mssql::query<T> (q)
{
}
template <mssql::database_type_id ID>
query (const mssql::query_column<bool, ID>& qc)
- : mssql::query (qc)
+ : mssql::query<T> (qc)
{
}
};
diff --git a/odb/mssql/query.ixx b/odb/mssql/query.ixx
index 0476b26..18b856c 100644
--- a/odb/mssql/query.ixx
+++ b/odb/mssql/query.ixx
@@ -7,7 +7,7 @@ namespace odb
namespace mssql
{
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/mssql/query.txx b/odb/mssql/query.txx
index 522059a..d77ea83 100644
--- a/odb/mssql/query.txx
+++ b/odb/mssql/query.txx
@@ -6,12 +6,12 @@ namespace odb
{
namespace mssql
{
- // 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/mssql/simple-object-result.hxx b/odb/mssql/simple-object-result.hxx
index 3fa101b..bdbd3ec 100644
--- a/odb/mssql/simple-object-result.hxx
+++ b/odb/mssql/simple-object-result.hxx
@@ -14,7 +14,7 @@
#include <odb/details/shared-ptr.hxx>
#include <odb/mssql/version.hxx>
-#include <odb/mssql/forward.hxx> // query
+#include <odb/mssql/forward.hxx> // query_base
#include <odb/mssql/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_mssql> 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/mssql/simple-object-result.txx b/odb/mssql/simple-object-result.txx
index 3606f68..68f4316 100644
--- a/odb/mssql/simple-object-result.txx
+++ b/odb/mssql/simple-object-result.txx
@@ -34,7 +34,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/mssql/simple-object-statements.hxx b/odb/mssql/simple-object-statements.hxx
index f892153..fc46f5b 100644
--- a/odb/mssql/simple-object-statements.hxx
+++ b/odb/mssql/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_mssql> 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_mssql> 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/mssql/statement-cache.hxx b/odb/mssql/statement-cache.hxx
index 9f2cb47..5d70af2 100644
--- a/odb/mssql/statement-cache.hxx
+++ b/odb/mssql/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_mssql>::statements_type&
find_object ();
template <typename T>
diff --git a/odb/mssql/statement-cache.txx b/odb/mssql/statement-cache.txx
index 655f861..73acb87 100644
--- a/odb/mssql/statement-cache.txx
+++ b/odb/mssql/statement-cache.txx
@@ -7,10 +7,13 @@ namespace odb
namespace mssql
{
template <typename T>
- typename object_traits<T>::statements_type& statement_cache::
+ typename object_traits_impl<T, id_mssql>::statements_type&
+ statement_cache::
find_object ()
{
- typedef typename object_traits<T>::statements_type statements_type;
+ typedef
+ typename object_traits_impl<T, id_mssql>::statements_type
+ statements_type;
map::iterator i (map_.find (&typeid (T)));
diff --git a/odb/mssql/view-result.hxx b/odb/mssql/view-result.hxx
index a847306..7215641 100644
--- a/odb/mssql/view-result.hxx
+++ b/odb/mssql/view-result.hxx
@@ -14,7 +14,7 @@
#include <odb/details/shared-ptr.hxx>
#include <odb/mssql/version.hxx>
-#include <odb/mssql/forward.hxx> // query, view_statements
+#include <odb/mssql/forward.hxx> // query_base, view_statements
#include <odb/mssql/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_mssql> 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/mssql/view-result.txx b/odb/mssql/view-result.txx
index 5058dc7..208d511 100644
--- a/odb/mssql/view-result.txx
+++ b/odb/mssql/view-result.txx
@@ -32,7 +32,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/mssql/view-statements.hxx b/odb/mssql/view-statements.hxx
index db23460..5a93e03 100644
--- a/odb/mssql/view-statements.hxx
+++ b/odb/mssql/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_mssql> view_traits;
typedef typename view_traits::pointer_type pointer_type;
typedef typename view_traits::image_type image_type;