diff options
| -rw-r--r-- | odb/database.hxx | 61 | ||||
| -rw-r--r-- | odb/database.ixx | 228 | ||||
| -rw-r--r-- | odb/database.txx | 99 | ||||
| -rw-r--r-- | odb/forward.hxx | 35 | ||||
| -rw-r--r-- | odb/polymorphic-info.hxx | 6 | ||||
| -rw-r--r-- | odb/polymorphic-map.hxx | 33 | ||||
| -rw-r--r-- | odb/polymorphic-map.ixx | 12 | ||||
| -rw-r--r-- | odb/polymorphic-map.txx | 8 | ||||
| -rw-r--r-- | odb/query.hxx | 37 | ||||
| -rw-r--r-- | odb/schema-catalog-impl.hxx | 3 | ||||
| -rw-r--r-- | odb/schema-catalog.cxx | 11 | ||||
| -rw-r--r-- | odb/traits.hxx | 77 |
12 files changed, 398 insertions, 212 deletions
diff --git a/odb/database.hxx b/odb/database.hxx index 64f9d44..99205e7 100644 --- a/odb/database.hxx +++ b/odb/database.hxx @@ -63,7 +63,7 @@ namespace odb typename object_traits<T>::id_type persist (const typename object_traits<T>::pointer_type& obj_ptr); - // Throw object_not_persistent if not found. + // Load an object. Throw object_not_persistent if not found. // template <typename T> typename object_traits<T>::pointer_type @@ -73,6 +73,8 @@ namespace odb void load (const typename object_traits<T>::id_type& id, T& object); + // Reload an object. + // template <typename T> void reload (T& object); @@ -101,7 +103,7 @@ namespace odb void reload (const typename object_traits<T>::pointer_type& obj_ptr); - // Return NULL/false if not found. + // Loan an object if found. Return NULL/false if not found. // template <typename T> typename object_traits<T>::pointer_type @@ -250,8 +252,14 @@ namespace odb tracer_type* tracer () const; + // Database id. + // + public: + database_id + id () const; + protected: - database (); + database (database_id); private: database (const database&); @@ -264,22 +272,61 @@ namespace odb connection_ () = 0; protected: - template <typename T> + template <typename T, database_id DB> + typename object_traits<T>::id_type + persist_ (T&); + + template <typename T, database_id DB> typename object_traits<T>::id_type persist_ (const typename object_traits<T>::pointer_type&); - template <typename T> + template <typename T, database_id DB> + typename object_traits<T>::pointer_type + load_ (const typename object_traits<T>::id_type&); + + template <typename T, database_id DB> + void + load_ (const typename object_traits<T>::id_type&, T&); + + template <typename T, database_id DB> + void + reload_ (T&); + + template <typename T, database_id DB> + typename object_traits<T>::pointer_type + find_ (const typename object_traits<T>::id_type&); + + template <typename T, database_id DB> + bool + find_ (const typename object_traits<T>::id_type&, T&); + + template <typename T, database_id DB> + void + update_ (T&); + + template <typename T, database_id DB> void update_ (const typename object_traits<T>::pointer_type&); - template <typename T> + template <typename T, database_id DB> + void + erase_ (const typename object_traits<T>::id_type&); + + template <typename T, database_id DB> + void + erase_ (T&); + + template <typename T, database_id DB> void erase_ (const typename object_traits<T>::pointer_type&); - template <typename T, class_kind kind> + template <typename T, + database_id DB, + class_kind kind = class_traits<T>::kind> struct query_; protected: + database_id id_; tracer_type* tracer_; }; } diff --git a/odb/database.ixx b/odb/database.ixx index 4a00a74..aeffdec 100644 --- a/odb/database.ixx +++ b/odb/database.ixx @@ -7,11 +7,17 @@ namespace odb { inline database:: - database () - : tracer_ (0) + database (database_id id) + : id_ (id), tracer_ (0) { } + inline database_id database:: + id () const + { + return id_; + } + inline connection_ptr database:: connection () { @@ -38,6 +44,13 @@ namespace odb template <typename T> inline typename object_traits<T>::id_type database:: + persist (T& obj) + { + return persist_<T, id_default> (obj); + } + + template <typename T> + inline typename object_traits<T>::id_type database:: persist (T* p) { typedef typename object_traits<T>::pointer_type object_pointer; @@ -48,7 +61,7 @@ namespace odb // const object_pointer& pobj (p); - return persist_<T> (pobj); + return persist_<T, id_default> (pobj); } template <typename T, template <typename> class P> @@ -63,7 +76,7 @@ namespace odb // const object_pointer& pobj (p); - return persist_<T> (pobj); + return persist_<T, id_default> (pobj); } template <typename T, typename A1, template <typename, typename> class P> @@ -78,7 +91,7 @@ namespace odb // const object_pointer& pobj (p); - return persist_<T> (pobj); + return persist_<T, id_default> (pobj); } template <typename T, template <typename> class P> @@ -101,29 +114,42 @@ namespace odb inline typename object_traits<T>::id_type database:: persist (const typename object_traits<T>::pointer_type& pobj) { - return persist_<T> (pobj); + return persist_<T, id_default> (pobj); } template <typename T> inline typename object_traits<T>::pointer_type database:: - find (const typename object_traits<T>::id_type& id) + load (const typename object_traits<T>::id_type& id) { - // T is always object_type. - // + return load_<T, id_default> (id); + } - // Compiler error pointing here? Perhaps the object doesn't have the - // default constructor? - // - return object_traits<T>::find (*this, id); + template <typename T> + inline void database:: + load (const typename object_traits<T>::id_type& id, T& obj) + { + return load_<T, id_default> (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_default> (id); } template <typename T> inline bool database:: find (const typename object_traits<T>::id_type& id, T& obj) { - // T is always object_type. - // - return object_traits<T>::find (*this, id, obj); + return find_<T, id_default> (id, obj); + } + + template <typename T> + inline void database:: + reload (T& obj) + { + reload_<T, id_default> (obj); } template <typename T> @@ -172,6 +198,13 @@ namespace odb template <typename T> inline void database:: + update (T& obj) + { + update_<T, id_default> (obj); + } + + template <typename T> + inline void database:: update (T* p) { typedef typename object_traits<T>::pointer_type object_pointer; @@ -182,7 +215,7 @@ namespace odb // const object_pointer& pobj (p); - update_<T> (pobj); + update_<T, id_default> (pobj); } template <typename T, template <typename> class P> @@ -197,7 +230,7 @@ namespace odb // const object_pointer& pobj (p); - update_<T> (pobj); + update_<T, id_default> (pobj); } template <typename T, typename A1, template <typename, typename> class P> @@ -212,7 +245,7 @@ namespace odb // const object_pointer& pobj (p); - update_<T> (pobj); + update_<T, id_default> (pobj); } template <typename T, template <typename> class P> @@ -235,42 +268,21 @@ namespace odb inline void database:: update (const typename object_traits<T>::pointer_type& pobj) { - update_<T> (pobj); + update_<T, id_default> (pobj); } template <typename T> inline void database:: - update (T& obj) + erase (const typename object_traits<T>::id_type& id) { - // T can be const T while object_type will always be T. - // - typedef typename odb::object_traits<T>::object_type object_type; - typedef odb::object_traits<object_type> object_traits; - - // Compiler error pointing here? Perhaps the object is readonly or - // doesn't have an object id? Such objects cannot be updated. - // - object_traits::update (*this, obj); + return erase_<T, id_default> (id); } template <typename T> inline void database:: - update_ (const typename object_traits<T>::pointer_type& pobj) + erase (T& obj) { - // T can be const T while object_type will always be T. - // - typedef typename odb::object_traits<T>::object_type object_type; - typedef odb::object_traits<object_type> object_traits; - - typedef typename odb::object_traits<T>::pointer_type pointer_type; - typedef odb::pointer_traits<pointer_type> pointer_traits; - - T& obj (pointer_traits::get_ref (pobj)); - - // Compiler error pointing here? Perhaps the object is readonly or - // doesn't have an object id? Such objects cannot be updated. - // - object_traits::update (*this, obj); + return erase_<T, id_default> (obj); } template <typename T> @@ -285,7 +297,7 @@ namespace odb // const object_pointer& pobj (p); - erase_<T> (pobj); + erase_<T, id_default> (pobj); } template <typename T, template <typename> class P> @@ -300,7 +312,7 @@ namespace odb // const object_pointer& pobj (p); - erase_<T> (pobj); + erase_<T, id_default> (pobj); } template <typename T, typename A1, template <typename, typename> class P> @@ -315,7 +327,7 @@ namespace odb // const object_pointer& pobj (p); - erase_<T> (pobj); + erase_<T, id_default> (pobj); } template <typename T, template <typename> class P> @@ -338,37 +350,7 @@ namespace odb inline void database:: erase (const typename object_traits<T>::pointer_type& pobj) { - erase_<T> (pobj); - } - - template <typename T> - inline void database:: - erase_ (const typename object_traits<T>::pointer_type& pobj) - { - typedef typename object_traits<T>::pointer_type pointer_type; - typedef pointer_traits<pointer_type> pointer_traits; - - erase<T> (pointer_traits::get_ref (pobj)); - } - - template <typename T> - inline void database:: - erase (const typename object_traits<T>::id_type& id) - { - // T is always object_type. - // - object_traits<T>::erase (*this, id); - } - - template <typename T> - inline void database:: - erase (T& obj) - { - // T can be const T while object_type will always be T. - // - typedef typename object_traits<T>::object_type object_type; - - object_traits<object_type>::erase (*this, obj); + erase_<T, id_default> (pobj); } template <typename T> @@ -404,7 +386,7 @@ namespace odb { // T is always object_type. // - return object_traits<T>::erase_query (*this, q); + return object_traits_impl<T, id_default>::erase_query (*this, q); } template <typename T> @@ -428,6 +410,92 @@ namespace odb return query<T> (odb::query<T> (q), cache); } + // Implementations (i.e., the *_() functions). + // + template <typename T, database_id DB> + inline typename object_traits<T>::pointer_type database:: + find_ (const typename object_traits<T>::id_type& id) + { + // T is always object_type. + // + + // Compiler error pointing here? Perhaps the object doesn't have the + // default constructor? + // + return object_traits_impl<T, DB>::find (*this, id); + } + + template <typename T, database_id DB> + inline bool database:: + find_ (const typename object_traits<T>::id_type& id, T& obj) + { + // T is always object_type. + // + return object_traits_impl<T, DB>::find (*this, id, obj); + } + + template <typename T, database_id DB> + inline void database:: + update_ (T& obj) + { + // T can be const T while object_type will always be T. + // + typedef typename object_traits<T>::object_type object_type; + + // Compiler error pointing here? Perhaps the object is readonly or + // doesn't have an object id? Such objects cannot be updated. + // + object_traits_impl<object_type, DB>::update (*this, obj); + } + + template <typename T, database_id DB> + inline void database:: + update_ (const typename object_traits<T>::pointer_type& pobj) + { + // T can be const T while object_type will always be T. + // + typedef typename object_traits<T>::object_type object_type; + typedef typename object_traits<T>::pointer_type pointer_type; + + T& obj (pointer_traits<pointer_type>::get_ref (pobj)); + + // Compiler error pointing here? Perhaps the object is readonly or + // doesn't have an object id? Such objects cannot be updated. + // + object_traits_impl<object_type, DB>::update (*this, obj); + } + + template <typename T, database_id DB> + inline void database:: + erase_ (const typename object_traits<T>::id_type& id) + { + // T is always object_type. + // + object_traits_impl<T, DB>::erase (*this, id); + } + + template <typename T, database_id DB> + inline void database:: + erase_ (T& obj) + { + // T can be const T while object_type will always be T. + // + typedef typename object_traits<T>::object_type object_type; + + object_traits_impl<object_type, DB>::erase (*this, obj); + } + + template <typename T, database_id DB> + inline void database:: + erase_ (const typename object_traits<T>::pointer_type& pobj) + { + typedef typename object_traits<T>::pointer_type pointer_type; + + erase_<T, DB> (pointer_traits<pointer_type>::get_ref (pobj)); + } + + // execute() + // inline unsigned long long database:: execute (const char* statement) { diff --git a/odb/database.txx b/odb/database.txx index 7ac19d7..23ea712 100644 --- a/odb/database.txx +++ b/odb/database.txx @@ -10,13 +10,30 @@ namespace odb { template <typename T> + result<T> database:: + query (const odb::query<T>& q, bool cache) + { + // T is always object_type. We also don't need to check for transaction + // here; object_traits::query () does this. + // + result<T> r (query_<T, id_default>::call (*this, q)); + + if (cache) + r.cache (); + + return r; + } + + // Implementations (i.e., the *_() functions). + // + template <typename T, database_id DB> typename object_traits<T>::id_type database:: - persist (T& obj) + persist_ (T& obj) { // T can be const T while object_type will always be T. // - typedef typename odb::object_traits<T>::object_type object_type; - typedef odb::object_traits<object_type> object_traits; + typedef typename object_traits<T>::object_type object_type; + typedef object_traits_impl<object_type, DB> object_traits; object_traits::persist (*this, obj); @@ -26,19 +43,18 @@ namespace odb return object_traits::id (obj); } - template <typename T> + template <typename T, database_id DB> typename object_traits<T>::id_type database:: persist_ (const typename object_traits<T>::pointer_type& pobj) { // T can be const T while object_type will always be T. // - typedef typename odb::object_traits<T>::object_type object_type; - typedef odb::object_traits<object_type> object_traits; + typedef typename object_traits<T>::object_type object_type; + typedef typename object_traits<T>::pointer_type pointer_type; - typedef typename odb::object_traits<T>::pointer_type pointer_type; - typedef odb::pointer_traits<pointer_type> pointer_traits; + typedef object_traits_impl<object_type, DB> object_traits; - T& obj (pointer_traits::get_ref (pobj)); + T& obj (pointer_traits<pointer_type>::get_ref (pobj)); object_traits::persist (*this, obj); // Get the canonical object pointer and insert it into object cache. @@ -49,81 +65,60 @@ namespace odb return object_traits::id (obj); } - template <typename T> + template <typename T, database_id DB> typename object_traits<T>::pointer_type database:: - load (const typename object_traits<T>::id_type& id) + load_ (const typename object_traits<T>::id_type& id) { // T is always object_type. // typedef typename object_traits<T>::pointer_type pointer_type; - typedef odb::pointer_traits<pointer_type> pointer_traits; - pointer_type r (find<T> (id)); + pointer_type r (find_<T, DB> (id)); - if (pointer_traits::null_ptr (r)) + if (pointer_traits<pointer_type>::null_ptr (r)) throw object_not_persistent (); return r; } - template <typename T> + template <typename T, database_id DB> void database:: - load (const typename object_traits<T>::id_type& id, T& obj) + load_ (const typename object_traits<T>::id_type& id, T& obj) { - if (!find<T> (id, obj)) + if (!find_<T, DB> (id, obj)) throw object_not_persistent (); } - template <typename T> + template <typename T, database_id DB> void database:: - reload (T& obj) + reload_ (T& obj) { - // T should be object_type (cannot be const). + // T should be object_type (cannot be const). We also don't need to + // check for transaction here; object_traits::reload () does this. // - typedef odb::object_traits<T> object_traits; - - // We don't need to check for transaction here; - // object_traits::reload () does this. - - if (!object_traits::reload (*this, obj)) + if (!object_traits_impl<T, DB>::reload (*this, obj)) throw object_not_persistent (); } - template <typename T> - struct database::query_<T, class_object> + template <typename T, database_id DB> + struct database::query_<T, DB, class_object> { + template <typename Q> static result<T> - call (database& db, const odb::query<T>& q) + call (database& db, const Q& q) { - return object_traits<T>::query (db, q); + return object_traits_impl<T, DB>::query (db, q); } }; - template <typename T> - struct database::query_<T, class_view> + template <typename T, database_id DB> + struct database::query_<T, DB, class_view> { + template <typename Q> static result<T> - call (database& db, const odb::query<T>& q) + call (database& db, const Q& q) { - return view_traits<T>::query (db, q); + return view_traits_impl<T, DB>::query (db, q); } }; - - template <typename T> - result<T> database:: - query (const odb::query<T>& q, bool cache) - { - // T is always object_type. - // - - // We don't need to check for transaction here; - // object_traits::query () does this. - - result<T> r (query_<T, class_traits<T>::kind>::call (*this, q)); - - if (cache) - r.cache (); - - return r; - } } diff --git a/odb/forward.hxx b/odb/forward.hxx index 4c5e4b9..ff4a531 100644 --- a/odb/forward.hxx +++ b/odb/forward.hxx @@ -7,6 +7,8 @@ #include <odb/pre.hxx> +#include <cstddef> // std::size_t + #include <odb/details/export.hxx> #include <odb/details/shared-ptr-fwd.hxx> @@ -42,25 +44,50 @@ namespace odb // Implementation details. // + // Keep real databases first since their enumerators are used as array + // indexes + // + enum database_id + { + id_mysql, + id_sqlite, + id_pgsql, + id_oracle, + id_mssql, + id_default + }; + + // Number of real databases in the database_id enum. + // + const std::size_t database_count = id_default; + + // Traits. + // class access { public: template <typename T> class object_traits; + template <typename T, database_id DB> + class object_traits_impl; + template <typename T, typename P> class object_factory; template <typename T> class view_traits; + template <typename T, database_id DB> + class view_traits_impl; + template <typename T, typename P> class view_factory; template <typename T, typename P> class pointer_factory; - template <typename T> + template <typename T, database_id DB> class composite_value_traits; template <typename C> @@ -70,9 +97,15 @@ namespace odb template <typename T> struct object_traits; + template <typename T, database_id DB> + struct object_traits_impl; + template <typename T> struct view_traits; + template <typename T, database_id DB> + struct view_traits_impl; + // Cache traits. // template <typename T> struct no_id_pointer_cache_traits; diff --git a/odb/polymorphic-info.hxx b/odb/polymorphic-info.hxx index abed648..54291ce 100644 --- a/odb/polymorphic-info.hxx +++ b/odb/polymorphic-info.hxx @@ -86,14 +86,12 @@ namespace odb // Register concrete type T in the root's map. // - template <typename T> + template <typename T, database_id DB> struct polymorphic_entry { typedef T object_type; - typedef odb::object_traits<object_type> object_traits; - + typedef object_traits_impl<object_type, DB> object_traits; typedef typename object_traits::root_type root_type; - typedef odb::object_traits<root_type> root_traits; polymorphic_entry (); ~polymorphic_entry (); diff --git a/odb/polymorphic-map.hxx b/odb/polymorphic-map.hxx index c3c1374..5d23e6f 100644 --- a/odb/polymorphic-map.hxx +++ b/odb/polymorphic-map.hxx @@ -66,11 +66,11 @@ namespace odb discriminator_map discriminator_map_; }; - template <typename R> + template <typename R, database_id DB> struct polymorphic_entry_impl { typedef R root_type; - typedef object_traits<root_type> root_traits; + typedef object_traits_impl<root_type, DB> root_traits; typedef polymorphic_concrete_info<root_type> info_type; static void @@ -103,18 +103,18 @@ namespace odb return r; } - template <typename T, typename R> + template <typename T, database_id DB, typename R> struct dispatch_load { static void call (database& db, T& obj, std::size_t d) { - object_traits<T>::load_ (db, obj, d); + object_traits_impl<T, DB>::load_ (db, obj, d); } }; - template <typename R> - struct dispatch_load<R, R> + template <typename R, database_id DB> + struct dispatch_load<R, DB, R> { static void call (database&, R&, std::size_t) @@ -123,7 +123,7 @@ namespace odb } }; - template <typename T, bool auto_id> + template <typename T, database_id DB, bool auto_id> struct dispatch_persist { static void @@ -131,23 +131,24 @@ namespace odb { // Top-level call, no dynamic type checking. // - object_traits<T>::persist (db, obj, true, false); + object_traits_impl<T, DB>::persist (db, obj, true, false); } }; - template <typename T> - struct dispatch_persist<T, true> + template <typename T, database_id DB> + struct dispatch_persist<T, DB, true> { static void call (database& db, const T& obj) { // Top-level call, no dynamic type checking. // - object_traits<T>::persist (db, const_cast<T&> (obj), true, false); + object_traits_impl<T, DB>::persist ( + db, const_cast<T&> (obj), true, false); } }; - template <typename T> + template <typename T, database_id DB> bool dispatch_impl ( typename polymorphic_concrete_info< typename object_traits<T>::root_type>::call_type c, @@ -155,9 +156,9 @@ namespace odb const typename object_traits<T>::root_type* pobj, const void* arg) { - typedef object_traits<T> derived_traits; + typedef object_traits_impl<T, DB> derived_traits; typedef typename derived_traits::root_type root_type; - typedef object_traits<root_type> root_traits; + typedef object_traits_impl<root_type, DB> root_traits; typedef typename root_traits::id_type id_type; typedef polymorphic_concrete_info<root_type> info_type; @@ -175,7 +176,7 @@ namespace odb } case info_type::call_persist: { - dispatch_persist<T, root_traits::auto_id>::call ( + dispatch_persist<T, DB, root_traits::auto_id>::call ( db, *static_cast<const T*> (pobj)); break; @@ -208,7 +209,7 @@ namespace odb } case info_type::call_load: { - dispatch_load<T, root_type>::call ( + dispatch_load<T, DB, root_type>::call ( db, *const_cast<T*> (static_cast<const T*> (pobj)), *static_cast<const std::size_t*> (arg)); diff --git a/odb/polymorphic-map.ixx b/odb/polymorphic-map.ixx index 4dbd174..546d997 100644 --- a/odb/polymorphic-map.ixx +++ b/odb/polymorphic-map.ixx @@ -4,17 +4,17 @@ namespace odb { - template <typename T> - inline polymorphic_entry<T>:: + template <typename T, database_id DB> + inline polymorphic_entry<T, DB>:: polymorphic_entry () { - polymorphic_entry_impl<root_type>::insert (object_traits::info); + polymorphic_entry_impl<root_type, DB>::insert (object_traits::info); } - template <typename T> - inline polymorphic_entry<T>:: + template <typename T, database_id DB> + inline polymorphic_entry<T, DB>:: ~polymorphic_entry () { - polymorphic_entry_impl<root_type>::erase (object_traits::info); + polymorphic_entry_impl<root_type, DB>::erase (object_traits::info); } } diff --git a/odb/polymorphic-map.txx b/odb/polymorphic-map.txx index d7b6e36..26534a6 100644 --- a/odb/polymorphic-map.txx +++ b/odb/polymorphic-map.txx @@ -39,8 +39,8 @@ namespace odb // polymorphic_entry_impl // - template <typename R> - void polymorphic_entry_impl<R>:: + template <typename R, database_id DB> + void polymorphic_entry_impl<R, DB>:: insert (const info_type& i) { // VC10 cannot grok constructor call syntax here. @@ -56,8 +56,8 @@ namespace odb pm->discriminator_map_[&i.discriminator] = &i; } - template <typename R> - void polymorphic_entry_impl<R>:: + template <typename R, database_id DB> + void polymorphic_entry_impl<R, DB>:: erase (const info_type& i) { // VC10 cannot grok constructor call syntax here. diff --git a/odb/query.hxx b/odb/query.hxx index 9f889db..d5d0a19 100644 --- a/odb/query.hxx +++ b/odb/query.hxx @@ -7,6 +7,7 @@ #include <odb/pre.hxx> +#include <odb/forward.hxx> #include <odb/traits.hxx> namespace odb @@ -21,16 +22,16 @@ namespace odb // we need straight tables instead of aliases. // // - template <typename T, typename Tag, bool dummy = true> + template <typename T, database_id DB, typename Tag, bool dummy = true> struct alias_traits; - template <typename T> + template <typename T, database_id DB> struct query_columns_base; - template <typename T, typename Alias> + template <typename T, database_id DB, typename Alias> struct query_columns; - template <typename T, typename Alias> + template <typename T, database_id DB, typename Alias> struct pointer_query_columns; // Object pointer syntax wrapper. @@ -56,29 +57,33 @@ namespace odb // we have to use the impl trick below instead of simply having kind // as a second template argument with a default value. // - template <typename T, class_kind kind> + template <typename T, database_id DB, class_kind kind> struct query_selector_impl; - template <typename T> - struct query_selector_impl<T, class_object> + template <typename T, database_id DB> + struct query_selector_impl<T, DB, class_object> { - typedef typename object_traits<T>::query_base_type base_type; - typedef query_columns<T, access::object_traits<T> > columns_type; + typedef typename object_traits_impl<T, DB>::query_base_type base_type; + + typedef + query_columns<T, DB, access::object_traits_impl<T, DB> > + columns_type; }; - template <typename T> - struct query_selector_impl<T, class_view> + template <typename T, database_id DB> + struct query_selector_impl<T, DB, class_view> { - typedef typename view_traits<T>::query_base_type base_type; - typedef typename view_traits<T>::query_columns columns_type; + typedef typename view_traits_impl<T, DB>::query_base_type base_type; + typedef typename view_traits_impl<T, DB>::query_columns columns_type; }; - template <typename T> - struct query_selector: query_selector_impl<T, class_traits<T>::kind> + template <typename T, database_id DB> + struct query_selector: query_selector_impl<T, DB, class_traits<T>::kind> { }; - template <typename T, typename Q = typename query_selector<T>::base_type> + template <typename T, + typename B = typename query_selector<T, id_default>::base_type> class query; namespace core diff --git a/odb/schema-catalog-impl.hxx b/odb/schema-catalog-impl.hxx index 71d5d89..9b94cf1 100644 --- a/odb/schema-catalog-impl.hxx +++ b/odb/schema-catalog-impl.hxx @@ -35,8 +35,9 @@ namespace odb struct LIBODB_EXPORT schema_catalog_entry { schema_catalog_entry ( + database_id id, const char* name, - bool (*entry) (database&, unsigned short pass, bool drop)); + bool (*create_function) (database&, unsigned short pass, bool drop)); }; } diff --git a/odb/schema-catalog.cxx b/odb/schema-catalog.cxx index 7f00c3c..cd1ded4 100644 --- a/odb/schema-catalog.cxx +++ b/odb/schema-catalog.cxx @@ -5,6 +5,7 @@ #include <map> #include <vector> +#include <odb/database.hxx> #include <odb/exceptions.hxx> #include <odb/schema-catalog.hxx> #include <odb/schema-catalog-impl.hxx> @@ -19,8 +20,9 @@ namespace odb // for example, for foreign key generation. // typedef bool (*create_function) (database&, unsigned short pass, bool drop); + typedef pair<database_id, string> key; typedef vector<create_function> create_functions; - struct schema_catalog_impl: map<string, create_functions> {}; + struct schema_catalog_impl: map<key, create_functions> {}; schema_catalog_impl* schema_catalog_init::catalog = 0; size_t schema_catalog_init::count = 0; @@ -29,8 +31,7 @@ namespace odb create_schema (database& db, const string& name) { const schema_catalog_impl& c (*schema_catalog_init::catalog); - - schema_catalog_impl::const_iterator i (c.find (name)); + schema_catalog_impl::const_iterator i (c.find (key (db.id (), name))); if (i == c.end ()) throw unknown_schema (name); @@ -94,9 +95,9 @@ namespace odb // schema_catalog_entry // schema_catalog_entry:: - schema_catalog_entry (const char* name, create_function entry) + schema_catalog_entry (database_id id, const char* name, create_function cf) { schema_catalog_impl& c (*schema_catalog_init::catalog); - c[name].push_back (entry); + c[key(id, name)].push_back (cf); } } diff --git a/odb/traits.hxx b/odb/traits.hxx index 0743dba..3711601 100644 --- a/odb/traits.hxx +++ b/odb/traits.hxx @@ -99,17 +99,16 @@ namespace odb // template <typename T> + // + // If a C++ compiler issues an error pointing to this struct and + // saying that it is incomplete, then you are most likely trying to + // perform a database operation on a C++ type that is not a persistent + // object. Or you forgot to include the corresponding -odb.hxx file. + // struct object_traits: access::object_traits<T>, access::object_factory<T, typename access::object_traits<T>::pointer_type> { - // - // If a C++ compiler issues an error pointing to this struct and - // saying that it is incomplete, then you are most likely trying to - // perform a database operation on a C++ type that is not a persistent - // object. Or you forgot to include the corresponding -odb.hxx file. - // - typedef odb::pointer_traits<typename access::object_traits<T>::pointer_type> pointer_traits; @@ -160,45 +159,64 @@ namespace odb }; template <typename T, template <typename> class P> - struct object_traits< P<T> > + struct object_traits<P<T> > { struct id_type {}; }; template <typename T, typename A1, template <typename, typename> class P> - struct object_traits< P<T, A1> > + struct object_traits<P<T, A1> > { struct id_type {}; }; template <typename T, template <typename> class P> - struct object_traits< const P<T> > + struct object_traits<const P<T> > { struct id_type {}; }; template <typename T, typename A1, template <typename, typename> class P> - struct object_traits< const P<T, A1> > + struct object_traits<const P<T, A1> > { struct id_type {}; }; + template <typename T, database_id DB> + // + // If a C++ compiler issues an error pointing to this struct and + // saying that it is incomplete, then you are most likely trying to + // perform a database operation on a C++ type that is not a persistent + // object. Or you forgot to include the corresponding -odb.hxx file. + // + struct object_traits_impl: + access::object_traits_impl<T, DB>, + access::object_factory<T, typename access::object_traits<T>::pointer_type> + { + typedef + odb::pointer_traits<typename access::object_traits<T>::pointer_type> + pointer_traits; + + typedef typename access::object_traits<T>::object_type object_type; + typedef typename access::object_traits<T>::pointer_type pointer_type; + typedef typename pointer_traits::const_pointer_type const_pointer_type; + }; + // // view_traits // template <typename T> + // + // If a C++ compiler issues an error pointing to this struct and + // saying that it is incomplete, then you are most likely trying to + // perform a database operation on a C++ type that is not a view + // Or you forgot to include the corresponding -odb.hxx file. + // struct view_traits: access::view_traits<T>, access::view_factory<T, typename access::view_traits<T>::pointer_type> { - // - // If a C++ compiler issues an error pointing to this struct and - // saying that it is incomplete, then you are most likely trying to - // perform a database operation on a C++ type that is not a view - // Or you forgot to include the corresponding -odb.hxx file. - // - typedef odb::pointer_traits<typename access::view_traits<T>::pointer_type> pointer_traits; @@ -227,12 +245,31 @@ namespace odb typedef const_pointer_type pointer_type; }; + template <typename T, database_id DB> + // + // If a C++ compiler issues an error pointing to this struct and + // saying that it is incomplete, then you are most likely trying to + // perform a database operation on a C++ type that is not a view + // Or you forgot to include the corresponding -odb.hxx file. + // + struct view_traits_impl: + access::view_traits_impl<T, DB>, + access::view_factory<T, typename access::view_traits<T>::pointer_type> + { + typedef + odb::pointer_traits<typename access::view_traits<T>::pointer_type> + pointer_traits; + + typedef typename access::view_traits<T>::view_type view_type; + typedef typename access::view_traits<T>::pointer_type pointer_type; + }; + // // composite_value_traits // - template <typename T> - struct composite_value_traits: access::composite_value_traits<T> + template <typename T, database_id DB> + struct composite_value_traits: access::composite_value_traits<T, DB> { }; } |