diff options
| -rw-r--r-- | odb/mysql/forward.hxx | 3 | ||||
| -rw-r--r-- | odb/mysql/object-result.hxx | 56 | ||||
| -rw-r--r-- | odb/mysql/object-result.txx | 170 | ||||
| -rw-r--r-- | odb/mysql/object-statements.hxx | 122 | ||||
| -rw-r--r-- | odb/mysql/object-statements.txx | 34 | ||||
| -rw-r--r-- | odb/mysql/result.hxx | 9 | ||||
| -rw-r--r-- | odb/mysql/statement-cache.hxx | 10 | ||||
| -rw-r--r-- | odb/mysql/view-result.hxx | 12 | ||||
| -rw-r--r-- | odb/mysql/view-result.txx | 22 |
9 files changed, 388 insertions, 50 deletions
diff --git a/odb/mysql/forward.hxx b/odb/mysql/forward.hxx index 5d665dc..8ed934c 100644 --- a/odb/mysql/forward.hxx +++ b/odb/mysql/forward.hxx @@ -37,6 +37,9 @@ namespace odb class object_statements; template <typename T> + class object_statements_no_id; + + template <typename T> class view_statements; template <typename T> diff --git a/odb/mysql/object-result.hxx b/odb/mysql/object-result.hxx index ff99111..d2c6ab0 100644 --- a/odb/mysql/object-result.hxx +++ b/odb/mysql/object-result.hxx @@ -22,11 +22,10 @@ namespace odb namespace mysql { template <typename T> - class result_impl<T, class_object>: - public odb::result_impl<T, class_object> + class object_result_impl: public odb::object_result_impl<T> { public: - typedef odb::result_impl<T, class_object> base_type; + typedef odb::object_result_impl<T> base_type; typedef typename base_type::object_type object_type; typedef typename base_type::object_traits object_traits; @@ -36,11 +35,11 @@ namespace odb typedef typename base_type::pointer_traits pointer_traits; virtual - ~result_impl (); + ~object_result_impl (); - result_impl (const query&, - details::shared_ptr<select_statement>, - object_statements<object_type>&); + object_result_impl (const query&, + details::shared_ptr<select_statement>, + object_statements<object_type>&); virtual void load (object_type&); @@ -68,6 +67,49 @@ namespace odb object_statements<object_type>& statements_; std::size_t count_; }; + + 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: + void + fetch (); + + private: + details::shared_ptr<select_statement> statement_; + object_statements_no_id<object_type>& statements_; + std::size_t count_; + }; } } diff --git a/odb/mysql/object-result.txx b/odb/mysql/object-result.txx index d745537..e8b3560 100644 --- a/odb/mysql/object-result.txx +++ b/odb/mysql/object-result.txx @@ -12,17 +12,21 @@ namespace odb { namespace mysql { + // + // object_result_impl + // + template <typename T> - result_impl<T, class_object>:: - ~result_impl () + object_result_impl<T>:: + ~object_result_impl () { } template <typename T> - result_impl<T, class_object>:: - result_impl (const query&, - details::shared_ptr<select_statement> statement, - object_statements<object_type>& statements) + object_result_impl<T>:: + object_result_impl (const query&, + details::shared_ptr<select_statement> statement, + object_statements<object_type>& statements) : base_type (statements.connection ().database ()), statement_ (statement), statements_ (statements), @@ -31,7 +35,7 @@ namespace odb } template <typename T> - void result_impl<T, class_object>:: + void object_result_impl<T>:: load (object_type& obj) { if (count_ > statement_->fetched ()) @@ -69,8 +73,8 @@ namespace odb } template <typename T> - typename result_impl<T, class_object>::id_type - result_impl<T, class_object>:: + typename object_result_impl<T>::id_type + object_result_impl<T>:: load_id () { if (count_ > statement_->fetched ()) @@ -80,7 +84,147 @@ namespace odb } template <typename T> - void result_impl<T, class_object>:: + void object_result_impl<T>:: + next () + { + this->current (pointer_type ()); + + // If we are cached, simply increment the position and + // postpone the actual row fetching until later. This way + // if the same object is loaded in between iteration, the + // image won't be messed up. + // + count_++; + + if (statement_->cached ()) + this->end_ = count_ > statement_->result_size (); + else + fetch (); + } + + template <typename T> + void object_result_impl<T>:: + fetch () + { + // If the result is cached, the image can grow between calls + // to fetch() as a result of other statements execution. + // + if (statement_->cached ()) + { + 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++; + } + } + + while (!this->end_ && count_ > statement_->fetched ()) + { + select_statement::result r (statement_->fetch ()); + + switch (r) + { + case select_statement::truncated: + { + // Don't re-fetch data we are skipping. + // + if (count_ != statement_->fetched ()) + continue; + + typename object_traits::image_type& im (statements_.image ()); + + 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_->refetch (); + } + // Fall throught. + } + case select_statement::success: + { + break; + } + case select_statement::no_data: + { + this->end_ = true; + break; + } + } + } + } + + template <typename T> + void object_result_impl<T>:: + cache () + { + if (!statement_->cached ()) + { + statement_->cache (); + + if (count_ >= statement_->result_size ()) + this->end_ = true; + } + } + + template <typename T> + std::size_t object_result_impl<T>:: + size () + { + if (!statement_->cached ()) + throw result_not_cached (); + + return statement_->result_size (); + } + + // + // object_result_impl_no_id + // + + template <typename T> + object_result_impl_no_id<T>:: + ~object_result_impl_no_id () + { + } + + 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), + count_ (0) + { + } + + template <typename T> + void object_result_impl_no_id<T>:: + load (object_type& obj) + { + if (count_ > statement_->fetched ()) + fetch (); + + odb::database& db (this->database ()); + + object_traits::callback (db, obj, callback_event::pre_load); + object_traits::init (obj, statements_.image (), 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 ()); @@ -99,7 +243,7 @@ namespace odb } template <typename T> - void result_impl<T, class_object>:: + void object_result_impl_no_id<T>:: fetch () { // If the result is cached, the image can grow between calls @@ -161,7 +305,7 @@ namespace odb } template <typename T> - void result_impl<T, class_object>:: + void object_result_impl_no_id<T>:: cache () { if (!statement_->cached ()) @@ -174,7 +318,7 @@ namespace odb } template <typename T> - std::size_t result_impl<T, class_object>:: + std::size_t object_result_impl_no_id<T>:: size () { if (!statement_->cached ()) diff --git a/odb/mysql/object-statements.hxx b/odb/mysql/object-statements.hxx index f259feb..9ea9933 100644 --- a/odb/mysql/object-statements.hxx +++ b/odb/mysql/object-statements.hxx @@ -29,6 +29,28 @@ namespace odb { namespace mysql { + 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. + // + class LIBODB_MYSQL_EXPORT object_statements_base: public statements_base { // Locking. @@ -399,6 +421,106 @@ 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 mysql::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_;} + + my_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, + insert_image_binding_)); + + 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 select_column_count = + object_traits::column_count; + + static const std::size_t insert_column_count = + object_traits::column_count; + + private: + image_type image_; + + // Select binding. + // + std::size_t select_image_version_; + binding select_image_binding_; + MYSQL_BIND select_image_bind_[select_column_count]; + my_bool select_image_truncated_[select_column_count]; + + // Insert binding. + // + std::size_t insert_image_version_; + binding insert_image_binding_; + MYSQL_BIND insert_image_bind_[insert_column_count]; + + details::shared_ptr<insert_statement_type> persist_; + }; } } diff --git a/odb/mysql/object-statements.txx b/odb/mysql/object-statements.txx index 740a7d9..372118d 100644 --- a/odb/mysql/object-statements.txx +++ b/odb/mysql/object-statements.txx @@ -16,6 +16,10 @@ namespace odb { namespace mysql { + // + // object_statements + // + template <typename T> object_statements<T>:: ~object_statements () @@ -115,5 +119,35 @@ namespace odb delayed_.clear (); } + + // + // object_statements + // + + 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_image_binding_ (select_image_bind_, select_column_count), + insert_image_binding_ (insert_image_bind_, 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].error = select_image_truncated_ + i; + } } } diff --git a/odb/mysql/result.hxx b/odb/mysql/result.hxx index 33df541..cf6b15b 100644 --- a/odb/mysql/result.hxx +++ b/odb/mysql/result.hxx @@ -14,15 +14,6 @@ #include <odb/mysql/version.hxx> #include <odb/mysql/forward.hxx> -namespace odb -{ - namespace mysql - { - template <typename T, class_kind kind> - class result_impl; - } -} - #include <odb/post.hxx> #endif // ODB_MYSQL_RESULT_HXX diff --git a/odb/mysql/statement-cache.hxx b/odb/mysql/statement-cache.hxx index d5ede48..d1aad0a 100644 --- a/odb/mysql/statement-cache.hxx +++ b/odb/mysql/statement-cache.hxx @@ -38,16 +38,18 @@ namespace odb } template <typename T> - object_statements<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<T>&> (*i->second); + return static_cast<object_statements&> (*i->second); - details::shared_ptr<object_statements<T> > p ( - new (details::shared) object_statements<T> (conn_)); + details::shared_ptr<object_statements> p ( + new (details::shared) object_statements (conn_)); map_.insert (map::value_type (&typeid (T), p)); return *p; diff --git a/odb/mysql/view-result.hxx b/odb/mysql/view-result.hxx index 8acb97d..a2a9f3c 100644 --- a/odb/mysql/view-result.hxx +++ b/odb/mysql/view-result.hxx @@ -22,10 +22,10 @@ namespace odb namespace mysql { template <typename T> - class result_impl<T, class_view>: public odb::result_impl<T, class_view> + class view_result_impl: public odb::view_result_impl<T> { public: - typedef odb::result_impl<T, class_view> base_type; + typedef odb::view_result_impl<T> base_type; typedef typename base_type::view_type view_type; typedef typename base_type::view_traits view_traits; @@ -34,11 +34,11 @@ namespace odb typedef typename base_type::pointer_traits pointer_traits; virtual - ~result_impl (); + ~view_result_impl (); - result_impl (const query&, - details::shared_ptr<select_statement>, - view_statements<view_type>&); + view_result_impl (const query&, + details::shared_ptr<select_statement>, + view_statements<view_type>&); virtual void load (view_type&); diff --git a/odb/mysql/view-result.txx b/odb/mysql/view-result.txx index 94d9ae6..8b5b598 100644 --- a/odb/mysql/view-result.txx +++ b/odb/mysql/view-result.txx @@ -13,16 +13,16 @@ namespace odb namespace mysql { template <typename T> - result_impl<T, class_view>:: - ~result_impl () + view_result_impl<T>:: + ~view_result_impl () { } template <typename T> - result_impl<T, class_view>:: - result_impl (const query&, - details::shared_ptr<select_statement> statement, - view_statements<view_type>& statements) + view_result_impl<T>:: + view_result_impl (const query&, + details::shared_ptr<select_statement> statement, + view_statements<view_type>& statements) : base_type (statements.connection ().database ()), statement_ (statement), statements_ (statements), @@ -31,7 +31,7 @@ namespace odb } template <typename T> - void result_impl<T, class_view>:: + void view_result_impl<T>:: load (view_type& view) { if (count_ > statement_->fetched ()) @@ -45,7 +45,7 @@ namespace odb } template <typename T> - void result_impl<T, class_view>:: + void view_result_impl<T>:: next () { this->current (pointer_type ()); @@ -64,7 +64,7 @@ namespace odb } template <typename T> - void result_impl<T, class_view>:: + void view_result_impl<T>:: fetch () { // If the result is cached, the image can grow between calls @@ -125,7 +125,7 @@ namespace odb } template <typename T> - void result_impl<T, class_view>:: + void view_result_impl<T>:: cache () { if (!statement_->cached ()) @@ -138,7 +138,7 @@ namespace odb } template <typename T> - std::size_t result_impl<T, class_view>:: + std::size_t view_result_impl<T>:: size () { if (!statement_->cached ()) |