diff options
23 files changed, 1588 insertions, 537 deletions
diff --git a/odb/pgsql/binding.hxx b/odb/pgsql/binding.hxx index 9bb8d4a..cc68723 100644 --- a/odb/pgsql/binding.hxx +++ b/odb/pgsql/binding.hxx @@ -21,7 +21,6 @@ namespace odb class LIBODB_PGSQL_EXPORT native_binding { public: - native_binding (char** v, int* l, int* f, @@ -45,6 +44,8 @@ namespace odb public: typedef pgsql::bind bind_type; + binding (): bind (0), count (0), version (0) {} + binding (bind_type* b, std::size_t n) : bind (b), count (n), version (0) { diff --git a/odb/pgsql/forward.hxx b/odb/pgsql/forward.hxx index c56deb8..96b2266 100644 --- a/odb/pgsql/forward.hxx +++ b/odb/pgsql/forward.hxx @@ -38,7 +38,13 @@ namespace odb class object_statements; template <typename T> - class object_statements_no_id; + class polymorphic_root_object_statements; + + template <typename T> + class polymorphic_derived_object_statements; + + template <typename T> + class no_id_object_statements; template <typename T> class view_statements; diff --git a/odb/pgsql/makefile b/odb/pgsql/makefile index 37fedd8..004f061 100644 --- a/odb/pgsql/makefile +++ b/odb/pgsql/makefile @@ -4,22 +4,22 @@ include $(dir $(lastword $(MAKEFILE_LIST)))../../build/bootstrap.make -cxx := \ -auto-handle.cxx \ -connection.cxx \ -connection-factory.cxx \ -database.cxx \ -error.cxx \ -exceptions.cxx \ -object-statements.cxx \ -statement.cxx \ -statements-base.cxx \ -tracer.cxx \ -traits.cxx \ -transaction.cxx \ -transaction-impl.cxx \ -query.cxx \ -query-const-expr.cxx \ +cxx := \ +auto-handle.cxx \ +connection.cxx \ +connection-factory.cxx \ +database.cxx \ +error.cxx \ +exceptions.cxx \ +query.cxx \ +query-const-expr.cxx \ +simple-object-statements.cxx \ +statement.cxx \ +statements-base.cxx \ +tracer.cxx \ +traits.cxx \ +transaction.cxx \ +transaction-impl.cxx \ details/endian-traits.cxx cli_tun := details/options.cli diff --git a/odb/pgsql/no-id-object-result.hxx b/odb/pgsql/no-id-object-result.hxx new file mode 100644 index 0000000..0bd3bee --- /dev/null +++ b/odb/pgsql/no-id-object-result.hxx @@ -0,0 +1,70 @@ +// file : odb/pgsql/no-id-object-result.hxx +// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_PGSQL_NO_ID_OBJECT_RESULT_HXX +#define ODB_PGSQL_NO_ID_OBJECT_RESULT_HXX + +#include <odb/pre.hxx> + +#include <cstddef> // std::size_t + +#include <odb/no-id-object-result.hxx> + +#include <odb/details/shared-ptr.hxx> + +#include <odb/pgsql/version.hxx> +#include <odb/pgsql/forward.hxx> // query +#include <odb/pgsql/statement.hxx> + +namespace odb +{ + namespace pgsql + { + template <typename T> + class no_id_object_result_impl: public odb::no_id_object_result_impl<T> + { + public: + 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 typename base_type::pointer_traits pointer_traits; + + typedef typename object_traits::statements_type statements_type; + + virtual + ~no_id_object_result_impl (); + + no_id_object_result_impl (const query&, + details::shared_ptr<select_statement>, + statements_type&); + + virtual void + load (object_type&); + + virtual void + next (); + + virtual void + cache (); + + virtual std::size_t + size (); + + using base_type::current; + + private: + details::shared_ptr<select_statement> statement_; + statements_type& statements_; + }; + } +} + +#include <odb/pgsql/no-id-object-result.txx> + +#include <odb/post.hxx> + +#endif // ODB_PGSQL_NO_ID_OBJECT_RESULT_HXX diff --git a/odb/pgsql/no-id-object-result.txx b/odb/pgsql/no-id-object-result.txx new file mode 100644 index 0000000..98e1b48 --- /dev/null +++ b/odb/pgsql/no-id-object-result.txx @@ -0,0 +1,99 @@ +// file : odb/pgsql/no-id-object-result.txx +// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include <odb/callback.hxx> + +#include <odb/pgsql/no-id-object-statements.hxx> + +namespace odb +{ + namespace pgsql + { + template <typename T> + no_id_object_result_impl<T>:: + ~no_id_object_result_impl () + { + if (!this->end_) + statement_->free_result (); + } + + template <typename T> + no_id_object_result_impl<T>:: + no_id_object_result_impl (const query&, + details::shared_ptr<select_statement> statement, + statements_type& statements) + : base_type (statements.connection ().database ()), + statement_ (statement), + statements_ (statements) + { + } + + template <typename T> + void no_id_object_result_impl<T>:: + load (object_type& obj) + { + // The image can grow between calls to load() as a result of other + // statements execution. + // + typename object_traits::image_type& im (statements_.image ()); + + if (im.version != statements_.select_image_version ()) + { + binding& b (statements_.select_image_binding ()); + object_traits::bind (b.bind, im, statement_select); + statements_.select_image_version (im.version); + b.version++; + } + + select_statement::result r (statement_->load ()); + + if (r == select_statement::truncated) + { + if (object_traits::grow (im, statements_.select_image_truncated ())) + im.version++; + + if (im.version != statements_.select_image_version ()) + { + binding& b (statements_.select_image_binding ()); + object_traits::bind (b.bind, im, statement_select); + statements_.select_image_version (im.version); + b.version++; + statement_->reload (); + } + } + + odb::database& db (this->database ()); + + object_traits::callback (db, obj, callback_event::pre_load); + object_traits::init (obj, im, &db); + object_traits::callback (db, obj, callback_event::post_load); + } + + template <typename T> + void no_id_object_result_impl<T>:: + next () + { + this->current (pointer_type ()); + + if (!statement_->next ()) + { + statement_->free_result (); + this->end_ = true; + } + } + + template <typename T> + void no_id_object_result_impl<T>:: + cache () + { + } + + template <typename T> + std::size_t no_id_object_result_impl<T>:: + size () + { + return statement_->result_size (); + } + } +} diff --git a/odb/pgsql/no-id-object-statements.hxx b/odb/pgsql/no-id-object-statements.hxx new file mode 100644 index 0000000..98e6a48 --- /dev/null +++ b/odb/pgsql/no-id-object-statements.hxx @@ -0,0 +1,143 @@ +// file : odb/pgsql/no-id-object-statements.hxx +// copyright : Copyright (c) 2005-2012 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_PGSQL_NO_ID_OBJECT_STATEMENTS_HXX +#define ODB_PGSQL_NO_ID_OBJECT_STATEMENTS_HXX + +#include <odb/pre.hxx> + +#include <cstddef> // std::size_t + +#include <odb/forward.hxx> +#include <odb/traits.hxx> + +#include <odb/details/shared-ptr.hxx> + +#include <odb/pgsql/version.hxx> +#include <odb/pgsql/forward.hxx> +#include <odb/pgsql/pgsql-types.hxx> +#include <odb/pgsql/binding.hxx> +#include <odb/pgsql/statement.hxx> +#include <odb/pgsql/statements-base.hxx> + +namespace odb +{ + namespace pgsql + { + // + // Implementation for objects without object id. + // + + template <typename T> + class no_id_object_statements: public statements_base + { + public: + typedef T object_type; + typedef odb::object_traits<object_type> object_traits; + typedef typename object_traits::pointer_type pointer_type; + typedef typename object_traits::image_type image_type; + + typedef pgsql::insert_statement insert_statement_type; + + public: + no_id_object_statements (connection_type&); + + virtual + ~no_id_object_statements (); + + // Object image. + // + image_type& + image () {return image_;} + + // Insert binding. + // + std::size_t + insert_image_version () const { return insert_image_version_;} + + void + insert_image_version (std::size_t v) {insert_image_version_ = v;} + + binding& + insert_image_binding () {return insert_image_binding_;} + + // Select binding (needed for query support). + // + std::size_t + select_image_version () const { return select_image_version_;} + + void + select_image_version (std::size_t v) {select_image_version_ = v;} + + binding& + select_image_binding () {return select_image_binding_;} + + bool* + select_image_truncated () {return select_image_truncated_;} + + // Statements. + // + insert_statement_type& + persist_statement () + { + if (persist_ == 0) + persist_.reset ( + new (details::shared) insert_statement_type ( + conn_, + object_traits::persist_statement_name, + object_traits::persist_statement, + object_traits::persist_statement_types, + insert_column_count, + insert_image_binding_, + insert_image_native_binding_, + false, + false)); + + return *persist_; + } + + public: + // select = total + // insert = total - inverse; inverse == 0 for object without id + // + static const std::size_t insert_column_count = + object_traits::column_count; + + static const std::size_t select_column_count = + object_traits::column_count; + + private: + no_id_object_statements (const no_id_object_statements&); + no_id_object_statements& operator= (const no_id_object_statements&); + + private: + image_type image_; + + // Select binding. + // + std::size_t select_image_version_; + binding select_image_binding_; + bind select_image_bind_[select_column_count]; + bool select_image_truncated_[select_column_count]; + + // Insert binding. + // + std::size_t insert_image_version_; + binding insert_image_binding_; + bind insert_image_bind_[insert_column_count]; + native_binding insert_image_native_binding_; + char* insert_image_values_[insert_column_count]; + int insert_image_lengths_[insert_column_count]; + int insert_image_formats_[insert_column_count]; + + details::shared_ptr<insert_statement_type> persist_; + }; + } +} + +#include <odb/pgsql/no-id-object-statements.txx> + +#include <odb/post.hxx> + +#endif // ODB_PGSQL_NO_ID_OBJECT_STATEMENTS_HXX diff --git a/odb/pgsql/no-id-object-statements.txx b/odb/pgsql/no-id-object-statements.txx new file mode 100644 index 0000000..3fec01c --- /dev/null +++ b/odb/pgsql/no-id-object-statements.txx @@ -0,0 +1,47 @@ +// file : odb/pgsql/no-id-object-statements.txx +// copyright : Copyright (c) 2005-2012 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include <cstring> // std::memset + +namespace odb +{ + namespace pgsql + { + // + // no_id_object_statements + // + + template <typename T> + no_id_object_statements<T>:: + ~no_id_object_statements () + { + } + + template <typename T> + no_id_object_statements<T>:: + no_id_object_statements (connection_type& conn) + : statements_base (conn), + // select + select_image_binding_ (select_image_bind_, select_column_count), + // insert + insert_image_binding_ (insert_image_bind_, insert_column_count), + insert_image_native_binding_ (insert_image_values_, + insert_image_lengths_, + insert_image_formats_, + insert_column_count) + { + image_.version = 0; + select_image_version_ = 0; + insert_image_version_ = 0; + + std::memset (insert_image_bind_, 0, sizeof (insert_image_bind_)); + std::memset (select_image_bind_, 0, sizeof (select_image_bind_)); + std::memset ( + select_image_truncated_, 0, sizeof (select_image_truncated_)); + + for (std::size_t i (0); i < select_column_count; ++i) + select_image_bind_[i].truncated = select_image_truncated_ + i; + } + } +} diff --git a/odb/pgsql/object-result.hxx b/odb/pgsql/object-result.hxx deleted file mode 100644 index 72d38dd..0000000 --- a/odb/pgsql/object-result.hxx +++ /dev/null @@ -1,113 +0,0 @@ -// file : odb/pgsql/object-result.hxx -// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC -// license : GNU GPL v2; see accompanying LICENSE file - -#ifndef ODB_PGSQL_OBJECT_RESULT_HXX -#define ODB_PGSQL_OBJECT_RESULT_HXX - -#include <odb/pre.hxx> - -#include <cstddef> // std::size_t - -#include <odb/details/shared-ptr.hxx> - -#include <odb/pgsql/version.hxx> -#include <odb/pgsql/forward.hxx> // query, object_statements -#include <odb/pgsql/result.hxx> -#include <odb/pgsql/statement.hxx> - -namespace odb -{ - namespace pgsql - { - template <typename T> - class object_result_impl: public odb::object_result_impl<T> - { - 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::pointer_type pointer_type; - typedef typename base_type::pointer_traits pointer_traits; - - virtual - ~object_result_impl (); - - object_result_impl (const query&, - details::shared_ptr<select_statement>, - object_statements<object_type>&); - - virtual void - load (object_type&, bool fetch); - - virtual id_type - load_id (); - - virtual void - next (); - - virtual void - cache (); - - virtual std::size_t - size (); - - using base_type::current; - - private: - void - load_image (); - - private: - details::shared_ptr<select_statement> statement_; - object_statements<object_type>& statements_; - }; - - template <typename T> - class object_result_impl_no_id: public odb::object_result_impl_no_id<T> - { - public: - typedef odb::object_result_impl_no_id<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 typename base_type::pointer_traits pointer_traits; - - virtual - ~object_result_impl_no_id (); - - object_result_impl_no_id (const query&, - details::shared_ptr<select_statement>, - object_statements_no_id<object_type>&); - - virtual void - load (object_type&); - - virtual void - next (); - - virtual void - cache (); - - virtual std::size_t - size (); - - using base_type::current; - - private: - details::shared_ptr<select_statement> statement_; - object_statements_no_id<object_type>& statements_; - }; - } -} - -#include <odb/pgsql/object-result.txx> - -#include <odb/post.hxx> - -#endif // ODB_PGSQL_OBJECT_RESULT_HXX diff --git a/odb/pgsql/polymorphic-object-result.hxx b/odb/pgsql/polymorphic-object-result.hxx new file mode 100644 index 0000000..9dc8dcd --- /dev/null +++ b/odb/pgsql/polymorphic-object-result.hxx @@ -0,0 +1,86 @@ +// file : odb/pgsql/polymorphic-object-result.hxx +// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_PGSQL_POLYMORPHIC_OBJECT_RESULT_HXX +#define ODB_PGSQL_POLYMORPHIC_OBJECT_RESULT_HXX + +#include <odb/pre.hxx> + +#include <cstddef> // std::size_t + +#include <odb/polymorphic-object-result.hxx> + +#include <odb/details/shared-ptr.hxx> + +#include <odb/pgsql/version.hxx> +#include <odb/pgsql/forward.hxx> // query +#include <odb/pgsql/statement.hxx> + +namespace odb +{ + namespace pgsql + { + template <typename T> + class polymorphic_object_result_impl: + public odb::polymorphic_object_result_impl<T> + { + 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::pointer_type pointer_type; + 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 typename object_traits::statements_type statements_type; + + virtual + ~polymorphic_object_result_impl (); + + polymorphic_object_result_impl (const query&, + details::shared_ptr<select_statement>, + statements_type&); + + virtual void + load (object_type*, bool fetch); + + virtual id_type + load_id (); + + virtual discriminator_type + load_discriminator (); + + virtual void + next (); + + virtual void + cache (); + + virtual std::size_t + size (); + + using base_type::current; + + private: + void + load_image (); + + private: + details::shared_ptr<select_statement> statement_; + statements_type& statements_; + }; + } +} + +#include <odb/pgsql/polymorphic-object-result.txx> + +#include <odb/post.hxx> + +#endif // ODB_PGSQL_POLYMORPHIC_OBJECT_RESULT_HXX diff --git a/odb/pgsql/polymorphic-object-result.txx b/odb/pgsql/polymorphic-object-result.txx new file mode 100644 index 0000000..14104d0 --- /dev/null +++ b/odb/pgsql/polymorphic-object-result.txx @@ -0,0 +1,266 @@ +// file : odb/pgsql/polymorphic-object-result.txx +// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include <cassert> + +#include <odb/callback.hxx> +#include <odb/cache-traits.hxx> +#include <odb/exceptions.hxx> // object_not_persistent + +#include <odb/pgsql/polymorphic-object-statements.hxx> + +namespace odb +{ + namespace pgsql + { + template <typename T> + polymorphic_object_result_impl<T>:: + ~polymorphic_object_result_impl () + { + if (!this->end_) + statement_->free_result (); + } + + template <typename T> + polymorphic_object_result_impl<T>:: + polymorphic_object_result_impl (const query&, + details::shared_ptr<select_statement> st, + statements_type& sts) + : base_type (sts.connection ().database ()), + statement_ (st), + statements_ (sts) + { + } + + template <typename T> + void polymorphic_object_result_impl<T>:: + load (object_type* pobj, bool fetch) + { + if (fetch) + load_image (); + + typename statements_type::root_statements_type& rsts ( + statements_.root_statements ()); + + // This is a top-level call so the statements cannot be locked. + // + assert (!rsts.locked ()); + typename statements_type::auto_lock l (rsts); + + odb::database& db (this->database ()); + typename object_traits::image_type& i (statements_.image ()); + typename root_traits::image_type& ri (rsts.image ()); + + id_type id (root_traits::id (ri)); + + // Determine this object's dynamic type. + // + typedef typename root_traits::info_type info_type; + discriminator_type d (root_traits::discriminator (ri)); + discriminator_type disc (d); + + // Use the polymorphic_info() helper to get concrete_info if + // object_type is concrete and NULL if it is abstract. + // + const info_type* spi (polymorphic_info (object_traits::info)); + const info_type& pi ( + spi != 0 && spi->discriminator == d + ? *spi + : root_traits::map->find (d)); + + typedef typename root_traits::pointer_type root_pointer_type; + typedef typename root_traits::pointer_traits root_pointer_traits; + + typename object_traits::pointer_cache_traits::insert_guard ig; + + if (pobj == 0) + { + // Need to create a new instance of the dynamic type. + // + root_pointer_type rp (pi.create ()); + pointer_type p ( + root_pointer_traits::template static_pointer_cast<object_type> (rp)); + + // Insert it as a root pointer (for non-unique pointers, rp should + // still be valid and for unique pointers this is a no-op). + // + ig.reset (object_traits::pointer_cache_traits::insert (db, id, rp)); + + pobj = &pointer_traits::get_ref (p); + current (p); + } + else + { + // We are loading into an existing instance. If the static and + // dynamic types differ, then make sure the instance is at least + // of the dynamic type. + // + if (&pi != &object_traits::info) + { + const info_type& dpi (root_traits::map->find (typeid (*pobj))); + + if (&dpi != &pi && dpi.derived (pi)) + throw object_not_persistent (); // @@ type_mismatch ? + } + } + + callback_event ce (callback_event::pre_load); + pi.dispatch (info_type::call_callback, db, pobj, &ce); + + object_traits::init (*pobj, i, &db); + + // Initialize the id image and binding and load the rest of the object + // (containers, dynamic part, etc). + // + typename object_traits::id_image_type& idi (statements_.id_image ()); + root_traits::init (idi, id); + + binding& idb (statements_.id_image_binding ()); + if (idi.version != statements_.id_image_version () || idb.version == 0) + { + object_traits::bind (idb.bind, idi); + statements_.id_image_version (idi.version); + idb.version++; + } + + object_traits::load_ (statements_, *pobj); + + // Load the dynamic part of the object unless static and dynamic + // types are the same. + // + if (&pi != &object_traits::info) + { + std::size_t d (object_traits::depth); + pi.dispatch (info_type::call_load, db, pobj, &d); + }; + + rsts.load_delayed (); + l.unlock (); + + ce = callback_event::post_load; + pi.dispatch (info_type::call_callback, db, pobj, &ce); + ig.release (); + } + + template <typename T> + typename polymorphic_object_result_impl<T>::id_type + polymorphic_object_result_impl<T>:: + load_id () + { + load_image (); + return root_traits::id (statements_.root_statements ().image ()); + } + + template <typename T> + typename polymorphic_object_result_impl<T>::discriminator_type + polymorphic_object_result_impl<T>:: + load_discriminator () + { + load_image (); + return root_traits::discriminator ( + statements_.root_statements ().image ()); + } + + template <typename T> + void polymorphic_object_result_impl<T>:: + next () + { + this->current (pointer_type ()); + + if (!statement_->next ()) + { + statement_->free_result (); + this->end_ = true; + } + } + + template <typename T, typename R> + struct polymorphic_image_rebind + { + // Derived type version. + // + typedef object_traits<T> traits; + + static bool + rebind (typename traits::statements_type& sts) + { + typename traits::image_type& im (sts.image ()); + + if (traits::check_version (sts.select_image_versions (), im)) + { + binding& b (sts.select_image_binding (traits::depth)); + traits::bind (b.bind, 0, 0, im, statement_select); + traits::update_version ( + sts.select_image_versions (), im, sts.select_image_bindings ()); + return true; + } + + return false; + } + }; + + template <typename R> + struct polymorphic_image_rebind<R, R> + { + // Root type version. + // + typedef object_traits<R> traits; + + static bool + rebind (typename traits::statements_type& sts) + { + typename traits::image_type& im (sts.image ()); + + if (im.version != sts.select_image_version ()) + { + binding& b (sts.select_image_binding ()); + traits::bind (b.bind, im, statement_select); + sts.select_image_version (im.version); + b.version++; + return true; + } + + return false; + } + }; + + template <typename T> + void polymorphic_object_result_impl<T>:: + load_image () + { + typedef polymorphic_image_rebind<object_type, root_type> image_rebind; + + // The image can grow between calls to load() as a result of other + // statements execution. + // + image_rebind::rebind (statements_); + + select_statement::result r (statement_->load ()); + + if (r == select_statement::truncated) + { + typename object_traits::image_type& im (statements_.image ()); + + if (object_traits::grow (im, statements_.select_image_truncated ())) + im.version++; + + if (image_rebind::rebind (statements_)) + statement_->reload (); + } + } + + template <typename T> + void polymorphic_object_result_impl<T>:: + cache () + { + } + + template <typename T> + std::size_t polymorphic_object_result_impl<T>:: + size () + { + return statement_->result_size (); + } + } +} diff --git a/odb/pgsql/polymorphic-object-statements.hxx b/odb/pgsql/polymorphic-object-statements.hxx new file mode 100644 index 0000000..43dd55e --- /dev/null +++ b/odb/pgsql/polymorphic-object-statements.hxx @@ -0,0 +1,475 @@ +// file : odb/pgsql/polymorphic-object-statements.hxx +// copyright : Copyright (c) 2005-2012 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_PGSQL_POLYMORPHIC_OBJECT_STATEMENTS_HXX +#define ODB_PGSQL_POLYMORPHIC_OBJECT_STATEMENTS_HXX + +#include <odb/pre.hxx> + +#include <cstddef> // std::size_t + +#include <odb/forward.hxx> +#include <odb/traits.hxx> + +#include <odb/details/shared-ptr.hxx> + +#include <odb/pgsql/version.hxx> +#include <odb/pgsql/forward.hxx> +#include <odb/pgsql/pgsql-types.hxx> +#include <odb/pgsql/binding.hxx> +#include <odb/pgsql/statement.hxx> +#include <odb/pgsql/statements-base.hxx> +#include <odb/pgsql/simple-object-statements.hxx> + +namespace odb +{ + namespace pgsql + { + // + // Implementation for polymorphic objects. + // + + template <typename T> + class polymorphic_root_object_statements: public object_statements<T> + { + public: + typedef typename object_statements<T>::connection_type connection_type; + typedef typename object_statements<T>::object_traits object_traits; + typedef typename object_statements<T>::id_image_type id_image_type; + + typedef + typename object_traits::discriminator_image_type + discriminator_image_type; + + typedef + typename object_statements<T>::select_statement_type + select_statement_type; + + public: + // Interface compatibility with derived_object_statements. + // + typedef polymorphic_root_object_statements root_statements_type; + + root_statements_type& + root_statements () + { + return *this; + } + + public: + // Discriminator binding. + // + discriminator_image_type& + discriminator_image () {return discriminator_image_;} + + std::size_t + discriminator_image_version () const + {return discriminator_image_version_;} + + void + discriminator_image_version (std::size_t v) + {discriminator_image_version_ = v;} + + binding& + discriminator_image_binding () {return discriminator_image_binding_;} + + bool* + discriminator_image_truncated () {return discriminator_image_truncated_;} + + // Id binding for discriminator retrieval. + // + id_image_type& + discriminator_id_image () {return discriminator_id_image_;} + + std::size_t + discriminator_id_image_version () const + {return discriminator_id_image_version_;} + + void + discriminator_id_image_version (std::size_t v) + {discriminator_id_image_version_ = v;} + + binding& + discriminator_id_image_binding () + {return discriminator_id_image_binding_;} + + // Expose id native binding from object_statements. + // + native_binding& + id_image_native_binding () {return this->id_image_native_binding_;} + + // + // + select_statement_type& + find_discriminator_statement () + { + if (find_discriminator_ == 0) + find_discriminator_.reset ( + new (details::shared) select_statement_type ( + this->conn_, + object_traits::find_discriminator_statement_name, + object_traits::find_discriminator_statement, + object_traits::find_statement_types, // The same as find (id). + id_column_count, + discriminator_id_image_binding_, + discriminator_id_image_native_binding_, + discriminator_image_binding_, + false)); + + return *find_discriminator_; + } + + public: + polymorphic_root_object_statements (connection_type&); + + virtual + ~polymorphic_root_object_statements (); + + public: + static const std::size_t id_column_count = + object_statements<T>::id_column_count; + + static const std::size_t discriminator_column_count = + object_traits::discriminator_column_count; + + static const std::size_t managed_optimistic_column_count = + object_traits::managed_optimistic_column_count; + + private: + // Discriminator image. + // + discriminator_image_type discriminator_image_; + std::size_t discriminator_image_version_; + binding discriminator_image_binding_; + bind discriminator_image_bind_[discriminator_column_count + + managed_optimistic_column_count]; + bool discriminator_image_truncated_[discriminator_column_count + + managed_optimistic_column_count]; + + // Id image for discriminator retrieval (only used as a parameter). + // + id_image_type discriminator_id_image_; + std::size_t discriminator_id_image_version_; + binding discriminator_id_image_binding_; + native_binding discriminator_id_image_native_binding_; + bind discriminator_id_image_bind_[id_column_count]; + char* discriminator_id_image_values_[id_column_count]; + int discriminator_id_image_lengths_[id_column_count]; + int discriminator_id_image_formats_[id_column_count]; + + details::shared_ptr<select_statement_type> find_discriminator_; + }; + + template <typename T> + class polymorphic_derived_object_statements: public statements_base + { + public: + typedef T object_type; + typedef odb::object_traits<object_type> 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; + typedef typename object_traits::image_type image_type; + + typedef typename object_traits::root_type root_type; + typedef + polymorphic_root_object_statements<root_type> + root_statements_type; + + typedef typename object_traits::base_type base_type; + typedef + typename object_traits::base_traits::statements_type + base_statements_type; + + typedef + typename object_traits::container_statement_cache_type + container_statement_cache_type; + + typedef pgsql::insert_statement insert_statement_type; + typedef pgsql::select_statement select_statement_type; + typedef pgsql::update_statement update_statement_type; + typedef pgsql::delete_statement delete_statement_type; + + typedef typename root_statements_type::auto_lock auto_lock; + + public: + polymorphic_derived_object_statements (connection_type&); + + virtual + ~polymorphic_derived_object_statements (); + + public: + // Delayed loading. + // + static void + delayed_loader (odb::database&, const id_type&, root_type&); + + public: + // Root and immediate base statements. + // + root_statements_type& + root_statements () + { + return root_statements_; + } + + base_statements_type& + base_statements () + { + return base_statements_; + } + + public: + // Object image. + // + image_type& + image () + { + return image_; + } + + // Insert binding. + // + std::size_t + insert_image_version () const { return insert_image_version_;} + + void + insert_image_version (std::size_t v) {insert_image_version_ = v;} + + std::size_t + insert_id_binding_version () const { return insert_id_binding_version_;} + + void + insert_id_binding_version (std::size_t v) {insert_id_binding_version_ = v;} + + binding& + insert_image_binding () {return insert_image_binding_;} + + // Update binding. + // + std::size_t + update_image_version () const { return update_image_version_;} + + void + update_image_version (std::size_t v) {update_image_version_ = v;} + + std::size_t + update_id_binding_version () const { return update_id_binding_version_;} + + void + update_id_binding_version (std::size_t v) {update_id_binding_version_ = v;} + + binding& + update_image_binding () {return update_image_binding_;} + + // Select binding. + // + std::size_t* + select_image_versions () { return select_image_versions_;} + + binding* + select_image_bindings () {return select_image_bindings_;} + + binding& + select_image_binding (std::size_t d) + { + return select_image_bindings_[object_traits::depth - d]; + } + + bool* + select_image_truncated () {return select_image_truncated_;} + + // Object id binding (comes from the root statements). + // + id_image_type& + id_image () {return root_statements_.id_image ();} + + std::size_t + id_image_version () const {return root_statements_.id_image_version ();} + + void + id_image_version (std::size_t v) {root_statements_.id_image_version (v);} + + binding& + id_image_binding () {return root_statements_.id_image_binding ();} + + // Statements. + // + insert_statement_type& + persist_statement () + { + if (persist_ == 0) + persist_.reset ( + new (details::shared) insert_statement_type ( + conn_, + object_traits::persist_statement_name, + object_traits::persist_statement, + object_traits::persist_statement_types, + insert_column_count, + insert_image_binding_, + insert_image_native_binding_, + object_traits::auto_id, + false)); + + return *persist_; + } + + select_statement_type& + find_statement (std::size_t d) + { + std::size_t i (object_traits::depth - d); + details::shared_ptr<select_statement_type>& p (find_[i]); + + if (p == 0) + p.reset ( + new (details::shared) select_statement_type ( + conn_, + object_traits::find_statement_names[i], + object_traits::find_statements[i], + object_traits::find_statement_types, + id_column_count, + root_statements_.id_image_binding (), + root_statements_.id_image_native_binding (), + select_image_bindings_[i], + false)); + + return *p; + } + + update_statement_type& + update_statement () + { + if (update_ == 0) + update_.reset ( + new (details::shared) update_statement_type ( + conn_, + object_traits::update_statement_name, + object_traits::update_statement, + object_traits::update_statement_types, + update_column_count + id_column_count, + update_image_binding_, + update_image_native_binding_, + false)); + + return *update_; + } + + delete_statement_type& + erase_statement () + { + if (erase_ == 0) + erase_.reset ( + new (details::shared) delete_statement_type ( + conn_, + object_traits::erase_statement_name, + object_traits::erase_statement, + object_traits::find_statement_types, // The same as find (id). + id_column_count, + root_statements_.id_image_binding (), + root_statements_.id_image_native_binding (), + false)); + + return *erase_; + } + + // Container statement cache. + // + container_statement_cache_type& + container_statment_cache () + { + return container_statement_cache_; + } + + public: + // select = total - id + base::select + // insert = total - inverse + // update = total - inverse - id - readonly + // + static const std::size_t id_column_count = + object_traits::id_column_count; + + static const std::size_t select_column_count = + object_traits::column_count - id_column_count + + base_statements_type::select_column_count; + + static const std::size_t insert_column_count = + object_traits::column_count - object_traits::inverse_column_count; + + static const std::size_t update_column_count = insert_column_count - + object_traits::id_column_count - object_traits::readonly_column_count; + + private: + polymorphic_derived_object_statements ( + const polymorphic_derived_object_statements&); + + polymorphic_derived_object_statements& + operator= (const polymorphic_derived_object_statements&); + + private: + root_statements_type& root_statements_; + base_statements_type& base_statements_; + + container_statement_cache_type container_statement_cache_; + + image_type image_; + + // Select binding. Here we are have an array of statements/bindings + // one for each depth. In other words, if we have classes root, base, + // and derived, then we have the following array of statements: + // + // [0] d + b + r + // [1] d + b + // [2] d + // + // Also, because we have a chain of images bound to these statements, + // we have an array of versions, one entry for each base plus one for + // our own image. + // + // A poly-abstract class only needs the first statement and in this + // case we have only one entry in the the bindings and statements + // arrays (but not versions; we still have a chain of images). + // + std::size_t select_image_versions_[object_traits::depth]; + binding select_image_bindings_[ + object_traits::abstract ? 1 : object_traits::depth]; + bind select_image_bind_[select_column_count]; + bool select_image_truncated_[select_column_count]; + + // Insert binding. The id binding is copied from the hierarchy root. + // + std::size_t insert_image_version_; + std::size_t insert_id_binding_version_; + binding insert_image_binding_; + bind insert_image_bind_[insert_column_count]; + native_binding insert_image_native_binding_; + char* insert_image_values_[insert_column_count]; + int insert_image_lengths_[insert_column_count]; + int insert_image_formats_[insert_column_count]; + + // Update binding. The id suffix binding is copied from the hierarchy + // root. + // + std::size_t update_image_version_; + std::size_t update_id_binding_version_; + binding update_image_binding_; + bind update_image_bind_[update_column_count + id_column_count]; + native_binding update_image_native_binding_; + char* update_image_values_[update_column_count + id_column_count]; + int update_image_lengths_[update_column_count + id_column_count]; + int update_image_formats_[update_column_count + id_column_count]; + + details::shared_ptr<insert_statement_type> persist_; + details::shared_ptr<select_statement_type> find_[ + object_traits::abstract ? 1 : object_traits::depth]; + details::shared_ptr<update_statement_type> update_; + details::shared_ptr<delete_statement_type> erase_; + }; + } +} + +#include <odb/pgsql/polymorphic-object-statements.txx> + +#include <odb/post.hxx> + +#endif // ODB_PGSQL_POLYMORPHIC_OBJECT_STATEMENTS_HXX diff --git a/odb/pgsql/polymorphic-object-statements.txx b/odb/pgsql/polymorphic-object-statements.txx new file mode 100644 index 0000000..2f10b22 --- /dev/null +++ b/odb/pgsql/polymorphic-object-statements.txx @@ -0,0 +1,154 @@ +// file : odb/pgsql/polymorphic-object-statements.txx +// copyright : Copyright (c) 2005-2012 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include <cstring> // std::memset + +#include <odb/callback.hxx> +#include <odb/exceptions.hxx> + +#include <odb/pgsql/connection.hxx> +#include <odb/pgsql/transaction.hxx> +#include <odb/pgsql/statement-cache.hxx> + +namespace odb +{ + namespace pgsql + { + // + // polymorphic_root_object_statements + // + + template <typename T> + polymorphic_root_object_statements<T>:: + ~polymorphic_root_object_statements () + { + } + + template <typename T> + polymorphic_root_object_statements<T>:: + polymorphic_root_object_statements (connection_type& conn) + : object_statements<T> (conn), + discriminator_image_binding_ (discriminator_image_bind_, + discriminator_column_count + + managed_optimistic_column_count), + discriminator_id_image_binding_ (discriminator_id_image_bind_, + id_column_count), + discriminator_id_image_native_binding_ ( + discriminator_id_image_values_, + discriminator_id_image_lengths_, + discriminator_id_image_formats_, + id_column_count) + { + discriminator_image_.version = 0; + discriminator_id_image_.version = 0; + + discriminator_image_version_ = 0; + discriminator_id_image_version_ = 0; + + std::memset (discriminator_image_bind_, + 0, + sizeof (discriminator_image_bind_)); + std::memset (discriminator_id_image_bind_, + 0, + sizeof (discriminator_id_image_bind_)); + std::memset (discriminator_image_truncated_, + 0, + sizeof (discriminator_image_truncated_)); + + for (std::size_t i (0); + i < discriminator_column_count + managed_optimistic_column_count; + ++i) + { + discriminator_image_bind_[i].truncated = + discriminator_image_truncated_ + i; + } + } + + // + // polymorphic_derived_object_statements + // + + template <typename T> + polymorphic_derived_object_statements<T>:: + ~polymorphic_derived_object_statements () + { + } + + template <typename T> + polymorphic_derived_object_statements<T>:: + polymorphic_derived_object_statements (connection_type& conn) + : statements_base (conn), + root_statements_ (conn.statement_cache ().find_object<root_type> ()), + base_statements_ (conn.statement_cache ().find_object<base_type> ()), + container_statement_cache_ (conn), + insert_image_binding_ (insert_image_bind_, insert_column_count), + insert_image_native_binding_ (insert_image_values_, + insert_image_lengths_, + insert_image_formats_, + insert_column_count), + update_image_binding_ (update_image_bind_, + update_column_count + id_column_count), + update_image_native_binding_ (update_image_values_, + update_image_lengths_, + update_image_formats_, + update_column_count + id_column_count) + { + image_.base = &base_statements_.image (); + image_.version = 0; + + for (std::size_t i (0); i < object_traits::depth; ++i) + select_image_versions_[i] = 0; + + for (std::size_t i (0); + i < (object_traits::abstract ? 1 : object_traits::depth); + ++i) + { + select_image_bindings_[i].bind = select_image_bind_; + select_image_bindings_[i].count = object_traits::find_column_counts[i]; + } + + insert_image_version_ = 0; + insert_id_binding_version_ = 0; + update_image_version_ = 0; + update_id_binding_version_ = 0; + + std::memset (insert_image_bind_, 0, sizeof (insert_image_bind_)); + std::memset (update_image_bind_, 0, sizeof (update_image_bind_)); + std::memset (select_image_bind_, 0, sizeof (select_image_bind_)); + std::memset ( + select_image_truncated_, 0, sizeof (select_image_truncated_)); + + for (std::size_t i (0); i < select_column_count; ++i) + select_image_bind_[i].truncated = select_image_truncated_ + i; + } + + template <typename T> + void polymorphic_derived_object_statements<T>:: + delayed_loader (odb::database& db, const id_type& id, root_type& robj) + { + connection_type& conn (transaction::current ().connection ()); + polymorphic_derived_object_statements& sts ( + conn.statement_cache ().find_object<object_type> ()); + root_statements_type& rsts (sts.root_statements ()); + + object_type& obj (static_cast<object_type&> (robj)); + + // The same code as in object_statements::load_delayed_(). + // + if (!object_traits::find_ (sts, &id)) + throw object_not_persistent (); + + object_traits::callback (db, obj, callback_event::pre_load); + object_traits::init (obj, sts.image (), &db); + object_traits::load_ (sts, obj); // Load containers, etc. + + rsts.load_delayed (); + + { + typename root_statements_type::auto_unlock u (rsts); + object_traits::callback (db, obj, callback_event::post_load); + } + } + } +} diff --git a/odb/pgsql/result.hxx b/odb/pgsql/result.hxx deleted file mode 100644 index 0862f27..0000000 --- a/odb/pgsql/result.hxx +++ /dev/null @@ -1,25 +0,0 @@ -// file : odb/pgsql/result.hxx -// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC -// license : GNU GPL v2; see accompanying LICENSE file - -#ifndef ODB_PGSQL_RESULT_HXX -#define ODB_PGSQL_RESULT_HXX - -#include <odb/pre.hxx> - -#include <odb/traits.hxx> -#include <odb/result.hxx> - -#include <odb/pgsql/version.hxx> -#include <odb/pgsql/forward.hxx> - -#include <odb/post.hxx> - -#endif // ODB_PGSQL_RESULT_HXX - -// Include result specializations so that the user code only needs -// to include this header. -// - -#include <odb/pgsql/object-result.hxx> -#include <odb/pgsql/view-result.hxx> diff --git a/odb/pgsql/simple-object-result.hxx b/odb/pgsql/simple-object-result.hxx new file mode 100644 index 0000000..5edee2c --- /dev/null +++ b/odb/pgsql/simple-object-result.hxx @@ -0,0 +1,78 @@ +// file : odb/pgsql/simple-object-result.hxx +// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_PGSQL_SIMPLE_OBJECT_RESULT_HXX +#define ODB_PGSQL_SIMPLE_OBJECT_RESULT_HXX + +#include <odb/pre.hxx> + +#include <cstddef> // std::size_t + +#include <odb/simple-object-result.hxx> + +#include <odb/details/shared-ptr.hxx> + +#include <odb/pgsql/version.hxx> +#include <odb/pgsql/forward.hxx> // query +#include <odb/pgsql/statement.hxx> + +namespace odb +{ + namespace pgsql + { + template <typename T> + class object_result_impl: public odb::object_result_impl<T> + { + 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::pointer_type pointer_type; + typedef typename base_type::pointer_traits pointer_traits; + + typedef typename object_traits::statements_type statements_type; + + virtual + ~object_result_impl (); + + object_result_impl (const query&, + details::shared_ptr<select_statement>, + statements_type&); + + virtual void + load (object_type&, bool fetch); + + virtual id_type + load_id (); + + virtual void + next (); + + virtual void + cache (); + + virtual std::size_t + size (); + + using base_type::current; + + private: + void + load_image (); + + private: + details::shared_ptr<select_statement> statement_; + statements_type& statements_; + }; + } +} + +#include <odb/pgsql/simple-object-result.txx> + +#include <odb/post.hxx> + +#endif // ODB_PGSQL_SIMPLE_OBJECT_RESULT_HXX diff --git a/odb/pgsql/object-result.txx b/odb/pgsql/simple-object-result.txx index c5334cc..f7b2e1c 100644 --- a/odb/pgsql/object-result.txx +++ b/odb/pgsql/simple-object-result.txx @@ -1,4 +1,4 @@ -// file : odb/pgsql/object-result.txx +// file : odb/pgsql/simple-object-result.txx // copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC // license : GNU GPL v2; see accompanying LICENSE file @@ -6,16 +6,12 @@ #include <odb/callback.hxx> -#include <odb/pgsql/object-statements.hxx> +#include <odb/pgsql/simple-object-statements.hxx> namespace odb { namespace pgsql { - // - // object_result_impl - // - template <typename T> object_result_impl<T>:: ~object_result_impl () @@ -28,7 +24,7 @@ namespace odb object_result_impl<T>:: object_result_impl (const query&, details::shared_ptr<select_statement> statement, - object_statements<object_type>& statements) + statements_type& statements) : base_type (statements.connection ().database ()), statement_ (statement), statements_ (statements) @@ -45,7 +41,7 @@ namespace odb // This is a top-level call so the statements cannot be locked. // assert (!statements_.locked ()); - typename object_statements<object_type>::auto_lock l (statements_); + typename statements_type::auto_lock l (statements_); odb::database& db (this->database ()); object_traits::callback (db, obj, callback_event::pre_load); @@ -142,95 +138,5 @@ namespace odb { return statement_->result_size (); } - - // - // object_result_impl_no_id - // - - template <typename T> - object_result_impl_no_id<T>:: - ~object_result_impl_no_id () - { - if (!this->end_) - statement_->free_result (); - } - - template <typename T> - object_result_impl_no_id<T>:: - object_result_impl_no_id (const query&, - details::shared_ptr<select_statement> statement, - object_statements_no_id<object_type>& statements) - : base_type (statements.connection ().database ()), - statement_ (statement), - statements_ (statements) - { - } - - template <typename T> - void object_result_impl_no_id<T>:: - load (object_type& obj) - { - // The image can grow between calls to load() as a result of other - // statements execution. - // - typename object_traits::image_type& im (statements_.image ()); - - if (im.version != statements_.select_image_version ()) - { - binding& b (statements_.select_image_binding ()); - object_traits::bind (b.bind, im, statement_select); - statements_.select_image_version (im.version); - b.version++; - } - - select_statement::result r (statement_->load ()); - - if (r == select_statement::truncated) - { - if (object_traits::grow (im, statements_.select_image_truncated ())) - im.version++; - - if (im.version != statements_.select_image_version ()) - { - binding& b (statements_.select_image_binding ()); - object_traits::bind (b.bind, im, statement_select); - statements_.select_image_version (im.version); - b.version++; - statement_->reload (); - } - } - - odb::database& db (this->database ()); - - object_traits::callback (db, obj, callback_event::pre_load); - object_traits::init (obj, im, &db); - object_traits::callback (db, obj, callback_event::post_load); - } - - template <typename T> - void object_result_impl_no_id<T>:: - next () - { - this->current (pointer_type ()); - - if (!statement_->next ()) - { - statement_->free_result (); - this->end_ = true; - } - } - - template <typename T> - void object_result_impl_no_id<T>:: - cache () - { - } - - template <typename T> - std::size_t object_result_impl_no_id<T>:: - size () - { - return statement_->result_size (); - } } } diff --git a/odb/pgsql/object-statements.cxx b/odb/pgsql/simple-object-statements.cxx index 6e07a11..4788812 100644 --- a/odb/pgsql/object-statements.cxx +++ b/odb/pgsql/simple-object-statements.cxx @@ -1,8 +1,8 @@ -// file : odb/pgsql/object-statements.cxx +// file : odb/pgsql/simple-object-statements.cxx // copyright : Copyright (c) 2005-2012 Code Synthesis Tools CC // license : GNU GPL v2; see accompanying LICENSE file -#include <odb/pgsql/object-statements.hxx> +#include <odb/pgsql/simple-object-statements.hxx> namespace odb { diff --git a/odb/pgsql/object-statements.hxx b/odb/pgsql/simple-object-statements.hxx index 215d5e6..37bd16c 100644 --- a/odb/pgsql/object-statements.hxx +++ b/odb/pgsql/simple-object-statements.hxx @@ -1,9 +1,9 @@ -// file : odb/pgsql/object-statements.hxx +// file : odb/pgsql/simple-object-statements.hxx // copyright : Copyright (c) 2005-2012 Code Synthesis Tools CC // license : GNU GPL v2; see accompanying LICENSE file -#ifndef ODB_PGSQL_OBJECT_STATEMENTS_HXX -#define ODB_PGSQL_OBJECT_STATEMENTS_HXX +#ifndef ODB_PGSQL_SIMPLE_OBJECT_STATEMENTS_HXX +#define ODB_PGSQL_SIMPLE_OBJECT_STATEMENTS_HXX #include <odb/pre.hxx> @@ -18,6 +18,8 @@ #include <odb/details/shared-ptr.hxx> #include <odb/pgsql/version.hxx> +#include <odb/pgsql/forward.hxx> +#include <odb/pgsql/pgsql-types.hxx> #include <odb/pgsql/binding.hxx> #include <odb/pgsql/statement.hxx> #include <odb/pgsql/statements-base.hxx> @@ -28,24 +30,6 @@ namespace odb { namespace pgsql { - template <typename T> - class object_statements; - - template <typename T> - class object_statements_no_id; - - template <typename T, typename ID = typename object_traits<T>::id_type> - struct object_statements_selector - { - typedef object_statements<T> type; - }; - - template <typename T> - struct object_statements_selector<T, void> - { - typedef object_statements_no_id<T> type; - }; - // // Implementation for objects with object id. // @@ -75,16 +59,6 @@ namespace odb return locked_; } - public: - virtual - ~object_statements_base (); - - protected: - object_statements_base (connection_type& conn) - : statements_base (conn), locked_ (false) - { - } - struct auto_unlock { // Unlocks the statement on construction and re-locks it on @@ -101,6 +75,16 @@ namespace odb object_statements_base& s_; }; + public: + virtual + ~object_statements_base (); + + protected: + object_statements_base (connection_type& conn) + : statements_base (conn), locked_ (false) + { + } + protected: bool locked_; }; @@ -142,7 +126,9 @@ namespace odb typedef typename object_traits::image_type image_type; typedef typename object_traits::id_image_type id_image_type; - typedef pointer_cache_traits<pointer_type> object_cache_traits; + typedef + typename object_traits::pointer_cache_traits + pointer_cache_traits; typedef typename object_traits::container_statement_cache_type @@ -196,12 +182,16 @@ namespace odb // Delayed loading. // + typedef void (*loader_function) ( + odb::database&, const id_type&, object_type&); + void delay_load (const id_type& id, object_type& obj, - const typename object_cache_traits::position_type& p) + const typename pointer_cache_traits::position_type& p, + loader_function l = 0) { - delayed_.push_back (delayed_load (id, obj, p)); + delayed_.push_back (delayed_load (id, obj, p, l)); } void @@ -298,7 +288,6 @@ namespace odb persist_statement () { if (persist_ == 0) - { persist_.reset ( new (details::shared) insert_statement_type ( conn_, @@ -310,7 +299,6 @@ namespace odb insert_image_native_binding_, object_traits::auto_id, false)); - } return *persist_; } @@ -319,7 +307,6 @@ namespace odb find_statement () { if (find_ == 0) - { find_.reset ( new (details::shared) select_statement_type ( conn_, @@ -331,7 +318,6 @@ namespace odb id_image_native_binding_, select_image_binding_, false)); - } return *find_; } @@ -340,7 +326,6 @@ namespace odb update_statement () { if (update_ == 0) - { update_.reset ( new (details::shared) update_statement_type ( conn_, @@ -351,7 +336,6 @@ namespace odb update_image_binding_, update_image_native_binding_, false)); - } return *update_; } @@ -360,18 +344,16 @@ namespace odb erase_statement () { if (erase_ == 0) - { erase_.reset ( new (details::shared) delete_statement_type ( conn_, object_traits::erase_statement_name, object_traits::erase_statement, - object_traits::erase_statement_types, + object_traits::find_statement_types, // The same as find (id). id_column_count, id_image_binding_, id_image_native_binding_, false)); - } return *erase_; } @@ -380,7 +362,6 @@ namespace odb optimistic_erase_statement () { if (od_.erase_ == 0) - { od_.erase_.reset ( new (details::shared) delete_statement_type ( conn_, @@ -391,7 +372,6 @@ namespace odb od_.id_image_binding_, od_.id_image_native_binding_, false)); - } return *od_.erase_; } @@ -404,18 +384,7 @@ namespace odb return container_statement_cache_; } - private: - object_statements (const object_statements&); - object_statements& operator= (const object_statements&); - - private: - void - load_delayed_ (); - - void - clear_delayed_ (); - - private: + public: // select = total // insert = total - inverse - managed_optimistic // update = total - inverse - managed_optimistic - id - readonly @@ -437,6 +406,17 @@ namespace odb object_traits::managed_optimistic_column_count; private: + object_statements (const object_statements&); + object_statements& operator= (const object_statements&); + + private: + void + load_delayed_ (); + + void + clear_delayed_ (); + + protected: container_statement_cache_type container_statement_cache_; image_type image_; @@ -500,17 +480,21 @@ namespace odb // struct delayed_load { - typedef typename object_cache_traits::position_type position_type; + typedef typename pointer_cache_traits::position_type position_type; delayed_load () {} - delayed_load (const id_type& i, object_type& o, const position_type& p) - : id (i), obj (&o), pos (p) + delayed_load (const id_type& i, + object_type& o, + const position_type& p, + loader_function l) + : id (i), obj (&o), pos (p), loader (l) { } id_type id; object_type* obj; position_type pos; + loader_function loader; }; typedef std::vector<delayed_load> delayed_loads; @@ -538,123 +522,12 @@ namespace odb delayed_loads& dl_; }; }; - - // - // Implementation for objects without object id. - // - - template <typename T> - class object_statements_no_id: public statements_base - { - public: - typedef T object_type; - typedef odb::object_traits<object_type> object_traits; - typedef typename object_traits::pointer_type pointer_type; - typedef typename object_traits::image_type image_type; - - typedef pgsql::insert_statement insert_statement_type; - - public: - object_statements_no_id (connection_type&); - - virtual - ~object_statements_no_id (); - - // Object image. - // - image_type& - image () {return image_;} - - // Insert binding. - // - std::size_t - insert_image_version () const { return insert_image_version_;} - - void - insert_image_version (std::size_t v) {insert_image_version_ = v;} - - binding& - insert_image_binding () {return insert_image_binding_;} - - // Select binding (needed for query support). - // - std::size_t - select_image_version () const { return select_image_version_;} - - void - select_image_version (std::size_t v) {select_image_version_ = v;} - - binding& - select_image_binding () {return select_image_binding_;} - - bool* - select_image_truncated () {return select_image_truncated_;} - - // Statements. - // - insert_statement_type& - persist_statement () - { - if (persist_ == 0) - { - persist_.reset ( - new (details::shared) insert_statement_type ( - conn_, - object_traits::persist_statement_name, - object_traits::persist_statement, - object_traits::persist_statement_types, - insert_column_count, - insert_image_binding_, - insert_image_native_binding_, - false, - false)); - } - - return *persist_; - } - - private: - object_statements_no_id (const object_statements_no_id&); - object_statements_no_id& operator= (const object_statements_no_id&); - - private: - // select = total - // insert = total - inverse; inverse == 0 for object without id - // - static const std::size_t insert_column_count = - object_traits::column_count; - - static const std::size_t select_column_count = - object_traits::column_count; - - private: - image_type image_; - - // Select binding. - // - std::size_t select_image_version_; - binding select_image_binding_; - bind select_image_bind_[select_column_count]; - bool select_image_truncated_[select_column_count]; - - // Insert binding. - // - std::size_t insert_image_version_; - binding insert_image_binding_; - bind insert_image_bind_[insert_column_count]; - native_binding insert_image_native_binding_; - char* insert_image_values_[insert_column_count]; - int insert_image_lengths_[insert_column_count]; - int insert_image_formats_[insert_column_count]; - - details::shared_ptr<insert_statement_type> persist_; - }; } } -#include <odb/pgsql/object-statements.ixx> -#include <odb/pgsql/object-statements.txx> +#include <odb/pgsql/simple-object-statements.ixx> +#include <odb/pgsql/simple-object-statements.txx> #include <odb/post.hxx> -#endif // ODB_PGSQL_OBJECT_STATEMENTS_HXX +#endif // ODB_PGSQL_SIMPLE_OBJECT_STATEMENTS_HXX diff --git a/odb/pgsql/object-statements.ixx b/odb/pgsql/simple-object-statements.ixx index 5a82b42..6f2d209 100644 --- a/odb/pgsql/object-statements.ixx +++ b/odb/pgsql/simple-object-statements.ixx @@ -1,4 +1,4 @@ -// file : odb/pgsql/object-statements.ixx +// file : odb/pgsql/simple-object-statements.ixx // copyright : Copyright (c) 2005-2012 Code Synthesis Tools CC // license : GNU GPL v2; see accompanying LICENSE file diff --git a/odb/pgsql/object-statements.txx b/odb/pgsql/simple-object-statements.txx index 2b21f76..8e391d7 100644 --- a/odb/pgsql/object-statements.txx +++ b/odb/pgsql/simple-object-statements.txx @@ -1,8 +1,7 @@ -// file : odb/pgsql/object-statements.txx +// file : odb/pgsql/simple-object-statements.txx // copyright : Copyright (c) 2005-2012 Code Synthesis Tools CC // license : GNU GPL v2; see accompanying LICENSE file -#include <cstddef> // std::size_t #include <cstring> // std::memset #include <odb/session.hxx> @@ -111,36 +110,41 @@ namespace odb while (!dls.empty ()) { delayed_load l (dls.back ()); - typename object_cache_traits::insert_guard g (l.pos); + typename pointer_cache_traits::insert_guard g (l.pos); dls.pop_back (); - if (!object_traits::find_ (*this, l.id)) - throw object_not_persistent (); - - object_traits::callback (db, *l.obj, callback_event::pre_load); - - // Our calls to init/load below can result in additional delayed - // loads being added to the delayed_ vector. We need to process - // those before we call the post callback. - // - object_traits::init (*l.obj, image (), &db); - object_traits::load_ (*this, *l.obj); // Load containers, etc. - - if (!delayed_.empty ()) - load_delayed_ (); - - // Temporarily unlock the statement for the post_load call so that - // it can load objects of this type recursively. This is safe to do - // because we have completely loaded the current object. Also the - // delayed_ list is clear before the unlock and should be clear on - // re-lock (since a callback can only call public API functions - // which will make sure all the delayed loads are processed before - // returning). - // + if (l.loader == 0) { - auto_unlock u (*this); - object_traits::callback (db, *l.obj, callback_event::post_load); + if (!object_traits::find_ (*this, &l.id)) + throw object_not_persistent (); + + object_traits::callback (db, *l.obj, callback_event::pre_load); + + // Our calls to init/load below can result in additional delayed + // loads being added to the delayed_ vector. We need to process + // those before we call the post callback. + // + object_traits::init (*l.obj, image (), &db); + object_traits::load_ (*this, *l.obj); // Load containers, etc. + + if (!delayed_.empty ()) + load_delayed_ (); + + // Temporarily unlock the statement for the post_load call so that + // it can load objects of this type recursively. This is safe to do + // because we have completely loaded the current object. Also the + // delayed_ list is clear before the unlock and should be clear on + // re-lock (since a callback can only call public API functions + // which will make sure all the delayed loads are processed before + // returning). + // + { + auto_unlock u (*this); + object_traits::callback (db, *l.obj, callback_event::post_load); + } } + else + l.loader (db, l.id, *l.obj); g.release (); } @@ -157,47 +161,11 @@ namespace odb for (typename delayed_loads::iterator i (delayed_.begin ()), e (delayed_.end ()); i != e; ++i) { - object_cache_traits::erase (i->pos); + pointer_cache_traits::erase (i->pos); } } delayed_.clear (); } - - // - // object_statements_no_id - // - - template <typename T> - object_statements_no_id<T>:: - ~object_statements_no_id () - { - } - - template <typename T> - object_statements_no_id<T>:: - object_statements_no_id (connection_type& conn) - : statements_base (conn), - // select - select_image_binding_ (select_image_bind_, select_column_count), - // insert - insert_image_binding_ (insert_image_bind_, insert_column_count), - insert_image_native_binding_ (insert_image_values_, - insert_image_lengths_, - insert_image_formats_, - insert_column_count) - { - image_.version = 0; - select_image_version_ = 0; - insert_image_version_ = 0; - - std::memset (insert_image_bind_, 0, sizeof (insert_image_bind_)); - std::memset (select_image_bind_, 0, sizeof (select_image_bind_)); - std::memset ( - select_image_truncated_, 0, sizeof (select_image_truncated_)); - - for (std::size_t i (0); i < select_column_count; ++i) - select_image_bind_[i].truncated = select_image_truncated_ + i; - } } } diff --git a/odb/pgsql/statement-cache.hxx b/odb/pgsql/statement-cache.hxx index dc9d171..90bc2f6 100644 --- a/odb/pgsql/statement-cache.hxx +++ b/odb/pgsql/statement-cache.hxx @@ -11,14 +11,14 @@ #include <typeinfo> #include <odb/forward.hxx> +#include <odb/traits.hxx> #include <odb/details/shared-ptr.hxx> #include <odb/details/type-info.hxx> #include <odb/pgsql/version.hxx> +#include <odb/pgsql/forward.hxx> #include <odb/pgsql/statements-base.hxx> -#include <odb/pgsql/object-statements.hxx> -#include <odb/pgsql/view-statements.hxx> #include <odb/pgsql/details/export.hxx> @@ -26,49 +26,18 @@ namespace odb { namespace pgsql { - class connection; - class LIBODB_PGSQL_EXPORT statement_cache { public: - statement_cache (connection& conn) - : conn_ (conn) - { - } + statement_cache (connection& conn): conn_ (conn) {} template <typename T> - typename object_statements_selector<T>::type& - find_object () - { - typedef typename object_statements_selector<T>::type object_statements; - - map::iterator i (map_.find (&typeid (T))); - - if (i != map_.end ()) - return static_cast<object_statements&> (*i->second); - - details::shared_ptr<object_statements> p ( - new (details::shared) object_statements (conn_)); - - map_.insert (map::value_type (&typeid (T), p)); - return *p; - } + typename object_traits<T>::statements_type& + find_object (); template <typename T> view_statements<T>& - find_view () - { - map::iterator i (map_.find (&typeid (T))); - - if (i != map_.end ()) - return static_cast<view_statements<T>&> (*i->second); - - details::shared_ptr<view_statements<T> > p ( - new (details::shared) view_statements<T> (conn_)); - - map_.insert (map::value_type (&typeid (T), p)); - return *p; - } + find_view (); private: typedef std::map<const std::type_info*, @@ -81,6 +50,8 @@ namespace odb } } +#include <odb/pgsql/statement-cache.txx> + #include <odb/post.hxx> #endif // ODB_PGSQL_STATEMENT_CACHE_HXX diff --git a/odb/pgsql/statement-cache.txx b/odb/pgsql/statement-cache.txx new file mode 100644 index 0000000..40ed170 --- /dev/null +++ b/odb/pgsql/statement-cache.txx @@ -0,0 +1,43 @@ +// file : odb/pgsql/statement-cache.txx +// copyright : Copyright (c) 2005-2012 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace pgsql + { + template <typename T> + typename object_traits<T>::statements_type& statement_cache:: + find_object () + { + typedef typename object_traits<T>::statements_type statements_type; + + map::iterator i (map_.find (&typeid (T))); + + if (i != map_.end ()) + return static_cast<statements_type&> (*i->second); + + details::shared_ptr<statements_type> p ( + new (details::shared) statements_type (conn_)); + + map_.insert (map::value_type (&typeid (T), p)); + return *p; + } + + template <typename T> + view_statements<T>& statement_cache:: + find_view () + { + map::iterator i (map_.find (&typeid (T))); + + if (i != map_.end ()) + return static_cast<view_statements<T>&> (*i->second); + + details::shared_ptr<view_statements<T> > p ( + new (details::shared) view_statements<T> (conn_)); + + map_.insert (map::value_type (&typeid (T), p)); + return *p; + } + } +} diff --git a/odb/pgsql/view-result.hxx b/odb/pgsql/view-result.hxx index 84a910d..341065d 100644 --- a/odb/pgsql/view-result.hxx +++ b/odb/pgsql/view-result.hxx @@ -9,11 +9,12 @@ #include <cstddef> // std::size_t +#include <odb/view-result.hxx> + #include <odb/details/shared-ptr.hxx> #include <odb/pgsql/version.hxx> #include <odb/pgsql/forward.hxx> // query, view_statements -#include <odb/pgsql/result.hxx> #include <odb/pgsql/statement.hxx> namespace odb @@ -32,12 +33,14 @@ namespace odb typedef typename base_type::pointer_type pointer_type; typedef typename base_type::pointer_traits pointer_traits; + typedef view_statements<view_type> statements_type; + virtual ~view_result_impl (); view_result_impl (const query&, details::shared_ptr<select_statement>, - view_statements<view_type>&); + statements_type&); virtual void load (view_type&); @@ -55,7 +58,7 @@ namespace odb private: details::shared_ptr<select_statement> statement_; - view_statements<view_type>& statements_; + statements_type& statements_; }; } } diff --git a/odb/pgsql/view-result.txx b/odb/pgsql/view-result.txx index 2219463..932d19b 100644 --- a/odb/pgsql/view-result.txx +++ b/odb/pgsql/view-result.txx @@ -22,7 +22,7 @@ namespace odb view_result_impl<T>:: view_result_impl (const query&, details::shared_ptr<select_statement> statement, - view_statements<view_type>& statements) + statements_type& statements) : base_type (statements.connection ().database ()), statement_ (statement), statements_ (statements) |