diff options
| -rw-r--r-- | odb/pgsql/container-statements.hxx | 393 | ||||
| -rw-r--r-- | odb/pgsql/container-statements.txx | 145 | ||||
| -rw-r--r-- | odb/pgsql/forward.hxx | 3 | ||||
| -rw-r--r-- | odb/pgsql/polymorphic-object-statements.hxx | 6 | ||||
| -rw-r--r-- | odb/pgsql/simple-object-statements.hxx | 27 |
5 files changed, 365 insertions, 209 deletions
diff --git a/odb/pgsql/container-statements.hxx b/odb/pgsql/container-statements.hxx index cf0e0b8..6ed9f37 100644 --- a/odb/pgsql/container-statements.hxx +++ b/odb/pgsql/container-statements.hxx @@ -16,7 +16,6 @@ #include <odb/pgsql/binding.hxx> #include <odb/pgsql/statement.hxx> #include <odb/pgsql/pgsql-fwd.hxx> // Oid -#include <odb/pgsql/pgsql-oid.hxx> #include <odb/pgsql/details/export.hxx> namespace odb @@ -35,8 +34,6 @@ namespace odb typedef T traits; typedef typename traits::data_image_type data_image_type; - typedef typename traits::cond_image_type cond_image_type; - typedef typename traits::functions_type functions_type; typedef pgsql::insert_statement insert_statement_type; @@ -45,7 +42,10 @@ namespace odb typedef pgsql::connection connection_type; - container_statements (connection_type&); + container_statements (connection_type&, + binding& id, + native_binding& idn, + const Oid* idt); connection_type& connection () @@ -66,227 +66,284 @@ namespace odb const binding& id_binding () { - return *id_binding_; + return id_binding_; } - void - id_binding (const binding& b) + // Data image. The image is split into the id (that comes as a + // binding) and index/key plus value which are in data_image_type. + // The select binding is a subset of the full binding (no id). + // + data_image_type& + data_image () { - id_binding_ = &b; + return data_image_; } - // Condition image. - // - cond_image_type& - cond_image () + bind* + data_bind () { - return cond_image_; + return insert_image_binding_.bind; } - std::size_t - cond_image_version () const + bool + data_binding_test_version () const { - return cond_image_version_; + return data_id_binding_version_ != id_binding_.version || + data_image_version_ != data_image_.version || + insert_image_binding_.version == 0; } void - cond_image_version (std::size_t v) + data_binding_update_version () { - cond_image_version_ = v; + data_id_binding_version_ = id_binding_.version; + data_image_version_ = data_image_.version; + insert_image_binding_.version++; + select_image_binding_.version++; } - std::size_t - cond_id_binding_version () const + bool* + select_image_truncated () { - return cond_id_binding_version_; + return select_image_truncated_; } - void - cond_id_binding_version (std::size_t v) - { - cond_id_binding_version_ = v; - } + // + // Statements. + // - binding& - cond_image_binding () + insert_statement_type& + insert_statement () { - return cond_image_binding_; - } + if (insert_ == 0) + insert_.reset ( + new (details::shared) insert_statement_type ( + conn_, + insert_name_, + insert_text_, + insert_types_, + insert_count_, + insert_image_binding_, + insert_image_native_binding_, + false, + false)); - native_binding& - cond_image_native_binding () - { - return cond_image_native_binding_; + return *insert_; } - // Data image. - // - data_image_type& - data_image () + select_statement_type& + select_statement () { - return data_image_; + if (select_ == 0) + select_.reset ( + new (details::shared) select_statement_type ( + conn_, + select_name_, + select_text_, + id_types_, + id_binding_.count, + id_binding_, + id_native_binding_, + select_image_binding_, + false)); + + return *select_; } - std::size_t - data_image_version () const + delete_statement_type& + delete_statement () { - return data_image_version_; + if (delete_ == 0) + delete_.reset ( + new (details::shared) delete_statement_type ( + conn_, + delete_name_, + delete_text_, + id_types_, + id_binding_.count, + id_binding_, + id_native_binding_, + false)); + + return *delete_; } - void - data_image_version (std::size_t v) + private: + container_statements (const container_statements&); + container_statements& operator= (const container_statements&); + + protected: + connection_type& conn_; + binding& id_binding_; + native_binding& id_native_binding_; + const Oid* id_types_; + + functions_type functions_; + + data_image_type data_image_; + std::size_t data_image_version_; + std::size_t data_id_binding_version_; + + binding insert_image_binding_; + native_binding insert_image_native_binding_; + + binding select_image_binding_; + bool* select_image_truncated_; + + const char* insert_name_; + const char* insert_text_; + const Oid* insert_types_; + std::size_t insert_count_; + + const char* select_name_; + const char* select_text_; + + const char* delete_name_; + const char* delete_text_; + + details::shared_ptr<insert_statement_type> insert_; + details::shared_ptr<select_statement_type> select_; + details::shared_ptr<delete_statement_type> delete_; + }; + + template <typename T> + class smart_container_statements: public container_statements<T> + { + public: + typedef T traits; + typedef typename traits::cond_image_type cond_image_type; + + typedef pgsql::update_statement update_statement_type; + typedef pgsql::delete_statement delete_statement_type; + + typedef pgsql::connection connection_type; + + smart_container_statements (connection_type&, + binding& id, + native_binding& idn, + const Oid* idt); + + // Condition image. The image is split into the id (that comes as + // a binding) and index/key/value which is in cond_image_type. + // + cond_image_type& + cond_image () { - data_image_version_ = v; + return cond_image_; } - std::size_t - data_id_binding_version () const + bind* + cond_bind () { - return data_id_binding_version_; + return cond_image_binding_.bind; } - void - data_id_binding_version (std::size_t v) + bool + cond_binding_test_version () const { - data_id_binding_version_ = v; + return cond_id_binding_version_ != this->id_binding_.version || + cond_image_version_ != cond_image_.version || + cond_image_binding_.version == 0; } - binding& - data_image_binding () + void + cond_binding_update_version () { - return data_image_binding_; + cond_id_binding_version_ = this->id_binding_.version; + cond_image_version_ = cond_image_.version; + cond_image_binding_.version++; } - native_binding& - data_image_native_binding () + // Update image. The image is split as follows: value comes + // from the data image, id comes as binding, and index/key + // comes from the condition image. + // + bind* + update_bind () { - return data_image_native_binding_; + return update_image_binding_.bind; } - binding& - select_image_binding () + bool + update_binding_test_version () const { - return select_image_binding_; + return update_id_binding_version_ != this->id_binding_.version || + update_cond_image_version_ != cond_image_.version || + update_data_image_version_ != this->data_image_.version || + update_image_binding_.version == 0; } - bool* - select_image_truncated () + void + update_binding_update_version () { - return select_image_truncated_; + update_id_binding_version_ = this->id_binding_.version; + update_cond_image_version_ = cond_image_.version; + update_data_image_version_ = this->data_image_.version; + update_image_binding_.version++; } // // Statements. // - insert_statement_type& - insert_one_statement () - { - if (insert_one_ == 0) - { - insert_one_.reset ( - new (details::shared) insert_statement_type ( - conn_, - insert_one_name_, - insert_one_text_, - insert_one_types_, - insert_one_count_, - data_image_binding_, - data_image_native_binding_, - false, - false)); - } - - return *insert_one_; - } - - select_statement_type& - select_all_statement () + delete_statement_type& + delete_statement () { - if (select_all_ == 0) - { - select_all_.reset ( - new (details::shared) select_statement_type ( - conn_, - select_all_name_, - select_all_text_, - select_all_types_, - select_all_count_, + if (this->delete_ == 0) + this->delete_.reset ( + new (details::shared) delete_statement_type ( + this->conn_, + this->delete_name_, + this->delete_text_, + delete_types_, + delete_count_, cond_image_binding_, cond_image_native_binding_, - select_image_binding_, false)); - } - return *select_all_; + return *this->delete_; } - delete_statement_type& - delete_all_statement () + update_statement_type& + update_statement () { - if (delete_all_ == 0) - { - delete_all_.reset ( - new (details::shared) delete_statement_type ( - conn_, - delete_all_name_, - delete_all_text_, - delete_all_types_, - delete_all_count_, - cond_image_binding_, - cond_image_native_binding_, + if (update_ == 0) + update_.reset ( + new (details::shared) update_statement_type ( + this->conn_, + update_name_, + update_text_, + update_types_, + update_count_, + update_image_binding_, + update_image_native_binding_, false)); - } - return *delete_all_; + return *update_; } - private: - container_statements (const container_statements&); - container_statements& operator= (const container_statements&); - protected: - connection_type& conn_; - functions_type functions_; - - const binding* id_binding_; - cond_image_type cond_image_; std::size_t cond_image_version_; std::size_t cond_id_binding_version_; binding cond_image_binding_; native_binding cond_image_native_binding_; - data_image_type data_image_; - std::size_t data_image_version_; - std::size_t data_id_binding_version_; - - binding data_image_binding_; - native_binding data_image_native_binding_; + std::size_t update_id_binding_version_; + std::size_t update_cond_image_version_; + std::size_t update_data_image_version_; + binding update_image_binding_; + native_binding update_image_native_binding_; - // Skips the id from data_image_binding. - // - binding select_image_binding_; - bool* select_image_truncated_; + const char* update_name_; + const char* update_text_; + const Oid* update_types_; + std::size_t update_count_; - const char* insert_one_name_; - const char* insert_one_text_; - const Oid* insert_one_types_; - std::size_t insert_one_count_; + const Oid* delete_types_; + std::size_t delete_count_; - const char* select_all_name_; - const char* select_all_text_; - const Oid* select_all_types_; - std::size_t select_all_count_; - - const char* delete_all_name_; - const char* delete_all_text_; - const Oid* delete_all_types_; - std::size_t delete_all_count_; - - details::shared_ptr<insert_statement_type> insert_one_; - details::shared_ptr<select_statement_type> select_all_; - details::shared_ptr<delete_statement_type> delete_all_; + details::shared_ptr<update_statement_type> update_; }; // Template argument is the generated concrete container traits type. @@ -299,18 +356,15 @@ namespace odb typedef typename T::statements_type base; typedef pgsql::connection connection_type; - container_statements_impl (connection_type&); - + container_statements_impl (connection_type&, + binding&, + native_binding&, + const Oid*); private: container_statements_impl (const container_statements_impl&); container_statements_impl& operator= (const container_statements_impl&); private: - bind cond_image_bind_[traits::cond_column_count]; - char* cond_image_values_[traits::cond_column_count]; - int cond_image_lengths_[traits::cond_column_count]; - int cond_image_formats_[traits::cond_column_count]; - bind data_image_bind_[traits::data_column_count]; char* data_image_values_[traits::data_column_count]; int data_image_lengths_[traits::data_column_count]; @@ -319,6 +373,33 @@ namespace odb bool select_image_truncated_array_[traits::data_column_count - traits::id_column_count]; }; + + template <typename T> + class smart_container_statements_impl: public container_statements_impl<T> + { + public: + typedef T traits; + typedef pgsql::connection connection_type; + + smart_container_statements_impl (connection_type&, + binding&, + native_binding&, + const Oid*); + private: + bind cond_image_bind_[traits::cond_column_count]; + char* cond_image_values_[traits::cond_column_count]; + int cond_image_lengths_[traits::cond_column_count]; + int cond_image_formats_[traits::cond_column_count]; + + bind update_image_bind_[traits::value_column_count + + traits::cond_column_count]; + char* update_image_values_[traits::value_column_count + + traits::cond_column_count]; + int update_image_lengths_[traits::value_column_count + + traits::cond_column_count]; + int update_image_formats_[traits::value_column_count + + traits::cond_column_count]; + }; } } diff --git a/odb/pgsql/container-statements.txx b/odb/pgsql/container-statements.txx index 7008cbb..2349b92 100644 --- a/odb/pgsql/container-statements.txx +++ b/odb/pgsql/container-statements.txx @@ -11,60 +11,80 @@ namespace odb { // container_statements // - template <typename T> container_statements<T>:: - container_statements (connection_type& conn) + container_statements (connection_type& conn, + binding& id, + native_binding& idn, + const Oid* idt) : conn_ (conn), - functions_ (this, - &traits::insert_one, - &traits::load_all, - &traits::delete_all), - id_binding_ (0), - cond_image_binding_ (0, 0), // Initialized by impl. - cond_image_native_binding_ (0, 0, 0, 0), // Initialized by impl. - data_image_binding_ (0, 0), // Initialized by impl. - data_image_native_binding_ (0, 0, 0, 0), // Initialized by impl. - select_image_binding_ (0, 0) // Initialized by impl. + id_binding_ (id), + id_native_binding_ (idn), + id_types_ (idt), + functions_ (this), + insert_image_binding_ (0, 0), // Initialized by impl. + insert_image_native_binding_ (0, 0, 0, 0), // Initialized by impl. + select_image_binding_ (0, 0) // Initialized by impl. { - cond_image_.version = 0; - cond_image_version_ = 0; - cond_id_binding_version_ = 0; + functions_.insert_ = &traits::insert; + functions_.select_ = &traits::select; + functions_.delete__ = &traits::delete_; data_image_.version = 0; data_image_version_ = 0; data_id_binding_version_ = 0; } + // smart_container_statements + // + template <typename T> + smart_container_statements<T>:: + smart_container_statements (connection_type& conn, + binding& id, + native_binding& idn, + const Oid* idt) + : container_statements<T> (conn, id, idn, idt), + cond_image_binding_ (0, 0), // Initialized by impl. + cond_image_native_binding_ (0, 0, 0, 0), // Initialized by impl. + update_image_binding_ (0, 0), // Initialized by impl. + update_image_native_binding_ (0, 0, 0, 0) // Initialized by impl. + { + this->functions_.update_ = &traits::update; + + cond_image_.version = 0; + cond_image_version_ = 0; + cond_id_binding_version_ = 0; + + update_id_binding_version_ = 0; + update_cond_image_version_ = 0; + update_data_image_version_ = 0; + } + + // container_statements_impl + // template <typename T> container_statements_impl<T>:: - container_statements_impl (connection_type& conn) - : base (conn) + container_statements_impl (connection_type& conn, + binding& id, + native_binding& idn, + const Oid* idt) + : base (conn, id, idn, idt) { this->select_image_truncated_ = select_image_truncated_array_; - this->cond_image_binding_.bind = cond_image_bind_; - this->cond_image_binding_.count = traits::cond_column_count; - - this->data_image_binding_.bind = data_image_bind_; - this->data_image_binding_.count = traits::data_column_count; + this->insert_image_binding_.bind = data_image_bind_; + this->insert_image_binding_.count = traits::data_column_count; this->select_image_binding_.bind = data_image_bind_ + traits::id_column_count; this->select_image_binding_.count = traits::data_column_count - traits::id_column_count; - this->cond_image_native_binding_.values = cond_image_values_; - this->cond_image_native_binding_.lengths = cond_image_lengths_; - this->cond_image_native_binding_.formats = cond_image_formats_; - this->cond_image_native_binding_.count = traits::cond_column_count; - - this->data_image_native_binding_.values = data_image_values_; - this->data_image_native_binding_.lengths = data_image_lengths_; - this->data_image_native_binding_.formats = data_image_formats_; - this->data_image_native_binding_.count = traits::data_column_count; + this->insert_image_native_binding_.values = data_image_values_; + this->insert_image_native_binding_.lengths = data_image_lengths_; + this->insert_image_native_binding_.formats = data_image_formats_; + this->insert_image_native_binding_.count = traits::data_column_count; - std::memset (cond_image_bind_, 0, sizeof (cond_image_bind_)); std::memset (data_image_bind_, 0, sizeof (data_image_bind_)); std::memset (select_image_truncated_array_, 0, @@ -76,20 +96,57 @@ namespace odb data_image_bind_[i + traits::id_column_count].truncated = select_image_truncated_array_ + i; - this->insert_one_name_ = traits::insert_one_name; - this->insert_one_text_ = traits::insert_one_statement; - this->insert_one_types_ = traits::insert_one_types; - this->insert_one_count_ = traits::data_column_count; + this->insert_name_ = traits::insert_name; + this->insert_text_ = traits::insert_statement; + this->insert_types_ = traits::insert_types; + this->insert_count_ = traits::data_column_count; + + this->select_name_ = traits::select_name; + this->select_text_ = traits::select_statement; + + this->delete_name_ = traits::delete_name; + this->delete_text_ = traits::delete_statement; + } + + // smart_container_statements_impl + // + template <typename T> + smart_container_statements_impl<T>:: + smart_container_statements_impl (connection_type& conn, + binding& id, + native_binding& idn, + const Oid* idt) + : container_statements_impl<T> (conn, id, idn, idt) + { + this->cond_image_binding_.bind = cond_image_bind_; + this->cond_image_binding_.count = traits::cond_column_count; + + this->update_image_binding_.bind = update_image_bind_; + this->update_image_binding_.count = traits::value_column_count + + traits::cond_column_count; + + this->cond_image_native_binding_.values = cond_image_values_; + this->cond_image_native_binding_.lengths = cond_image_lengths_; + this->cond_image_native_binding_.formats = cond_image_formats_; + this->cond_image_native_binding_.count = traits::cond_column_count; + + this->update_image_native_binding_.values = update_image_values_; + this->update_image_native_binding_.lengths = update_image_lengths_; + this->update_image_native_binding_.formats = update_image_formats_; + this->update_image_native_binding_.count = traits::value_column_count + + traits::cond_column_count; + + std::memset (cond_image_bind_, 0, sizeof (cond_image_bind_)); + std::memset (update_image_bind_, 0, sizeof (update_image_bind_)); - this->select_all_name_ = traits::select_all_name; - this->select_all_text_ = traits::select_all_statement; - this->select_all_types_ = traits::select_all_types; - this->select_all_count_ = traits::cond_column_count; + this->update_name_ = traits::update_name; + this->update_text_ = traits::update_statement; + this->update_types_ = traits::update_types; + this->update_count_ = traits::value_column_count + + traits::cond_column_count; - this->delete_all_name_ = traits::delete_all_name; - this->delete_all_text_ = traits::delete_all_statement; - this->delete_all_types_ = traits::delete_all_types; - this->delete_all_count_ = traits::cond_column_count; + this->delete_types_ = traits::delete_types; + this->delete_count_ = traits::cond_column_count; } } } diff --git a/odb/pgsql/forward.hxx b/odb/pgsql/forward.hxx index d028f4d..7799d1d 100644 --- a/odb/pgsql/forward.hxx +++ b/odb/pgsql/forward.hxx @@ -67,6 +67,9 @@ namespace odb template <typename T> class container_statements; + template <typename T> + class smart_container_statements; + class query_base; } diff --git a/odb/pgsql/polymorphic-object-statements.hxx b/odb/pgsql/polymorphic-object-statements.hxx index 2f1a03a..6109597 100644 --- a/odb/pgsql/polymorphic-object-statements.hxx +++ b/odb/pgsql/polymorphic-object-statements.hxx @@ -378,7 +378,11 @@ namespace odb container_statement_cache_type& container_statment_cache () { - return container_statement_cache_.get (conn_); + return container_statement_cache_.get ( + conn_, + root_statements_.id_image_binding (), + root_statements_.id_image_native_binding (), + object_traits::find_statement_types); } public: diff --git a/odb/pgsql/simple-object-statements.hxx b/odb/pgsql/simple-object-statements.hxx index 772ff24..3dbdff3 100644 --- a/odb/pgsql/simple-object-statements.hxx +++ b/odb/pgsql/simple-object-statements.hxx @@ -45,36 +45,43 @@ namespace odb typedef pgsql::connection connection_type; container_statement_cache_ptr (): p_ (0) {} - ~container_statement_cache_ptr () {if (p_ != 0) (this->*deleter_) (0);} + ~container_statement_cache_ptr () + { + if (p_ != 0) + (this->*deleter_) (0, 0, 0, 0); + } T& - get (connection_type& c) + get (connection_type& c, + binding& id, native_binding& idn, const Oid* idt) { if (p_ == 0) - allocate (&c); + allocate (&c, &id, &idn, idt); return *p_; } private: void - allocate (connection_type*); + allocate (connection_type*, binding*, native_binding*, const Oid*); private: T* p_; - void (container_statement_cache_ptr::*deleter_) (connection_type*); + void (container_statement_cache_ptr::*deleter_) ( + connection_type*, binding*, native_binding*, const Oid*); }; template <typename T> void container_statement_cache_ptr<T>:: - allocate (connection_type* c) + allocate (connection_type* c, + binding* id, native_binding* idn, const Oid* idt) { // To reduce object code size, this function acts as both allocator // and deleter. // if (p_ == 0) { - p_ = new T (*c); + p_ = new T (*c, *id, *idn, idt); deleter_ = &container_statement_cache_ptr<T>::allocate; } else @@ -432,7 +439,11 @@ namespace odb container_statement_cache_type& container_statment_cache () { - return container_statement_cache_.get (conn_); + return container_statement_cache_.get ( + conn_, + id_image_binding_, + id_image_native_binding_, + object_traits::find_statement_types); } public: |