diff options
Diffstat (limited to 'odb/sqlite')
| -rw-r--r-- | odb/sqlite/database.hxx | 14 | ||||
| -rw-r--r-- | odb/sqlite/database.ixx | 14 | ||||
| -rw-r--r-- | odb/sqlite/forward.hxx | 3 | ||||
| -rw-r--r-- | odb/sqlite/polymorphic-object-statements.hxx | 39 | ||||
| -rw-r--r-- | odb/sqlite/section-statements.hxx | 182 | ||||
| -rw-r--r-- | odb/sqlite/section-statements.txx | 42 | ||||
| -rw-r--r-- | odb/sqlite/simple-object-statements.hxx | 100 | ||||
| -rw-r--r-- | odb/sqlite/simple-object-statements.txx | 1 |
8 files changed, 337 insertions, 58 deletions
diff --git a/odb/sqlite/database.hxx b/odb/sqlite/database.hxx index 0471b64..6039f23 100644 --- a/odb/sqlite/database.hxx +++ b/odb/sqlite/database.hxx @@ -147,6 +147,12 @@ namespace odb void load (const typename object_traits<T>::id_type& id, T& object); + // Load (or reload, if it is already loaded) a section of an object. + // + template <typename T> + void + load (T& object, section&); + // Reload an object. // template <typename T> @@ -217,6 +223,14 @@ namespace odb void update (const typename object_traits<T>::pointer_type& obj_ptr); + // Update a section of an object. Throws the section_not_loaded + // exception if the section is not loaded. Note also that this + // function does not clear the changed flag if it is set. + // + template <typename T> + void + update (const T& object, const section&); + // Make the object transient. Throw object_not_persistent if not // found. // diff --git a/odb/sqlite/database.ixx b/odb/sqlite/database.ixx index fd2063e..c2fd1a5 100644 --- a/odb/sqlite/database.ixx +++ b/odb/sqlite/database.ixx @@ -108,6 +108,13 @@ namespace odb } template <typename T> + inline void database:: + load (T& obj, section& s) + { + return load_<T, id_sqlite> (obj, s); + } + + template <typename T> inline typename object_traits<T>::pointer_type database:: find (const typename object_traits<T>::id_type& id) { @@ -249,6 +256,13 @@ namespace odb template <typename T> inline void database:: + update (const T& obj, const section& s) + { + update_<T, id_sqlite> (obj, s); + } + + template <typename T> + inline void database:: erase (const typename object_traits<T>::id_type& id) { return erase_<T, id_sqlite> (id); diff --git a/odb/sqlite/forward.hxx b/odb/sqlite/forward.hxx index 316fbbc..456ff43 100644 --- a/odb/sqlite/forward.hxx +++ b/odb/sqlite/forward.hxx @@ -70,6 +70,9 @@ namespace odb template <typename T> class smart_container_statements; + template <typename T, typename ST> + class section_statements; + class query_base; class query_params; } diff --git a/odb/sqlite/polymorphic-object-statements.hxx b/odb/sqlite/polymorphic-object-statements.hxx index f932234..fa5f6af 100644 --- a/odb/sqlite/polymorphic-object-statements.hxx +++ b/odb/sqlite/polymorphic-object-statements.hxx @@ -171,8 +171,8 @@ namespace odb base_statements_type; typedef - typename object_traits::container_statement_cache_type - container_statement_cache_type; + typename object_traits::extra_statement_cache_type + extra_statement_cache_type; typedef sqlite::insert_statement insert_statement_type; typedef sqlite::select_statement select_statement_type; @@ -282,6 +282,10 @@ namespace odb binding& id_image_binding () {return root_statements_.id_image_binding ();} + binding& + optimistic_id_image_binding () { + return root_statements_.optimistic_id_image_binding ();} + // Statements. // insert_statement_type& @@ -348,31 +352,40 @@ namespace odb return *erase_; } - // Container statement cache. + // Extra (container, section) statement cache. // - container_statement_cache_type& - container_statment_cache () + extra_statement_cache_type& + extra_statement_cache () { - return container_statement_cache_.get (conn_, id_image_binding ()); + return extra_statement_cache_.get ( + conn_, + image_, + id_image_binding (), + &id_image_binding ()); // Note, not id+version. } public: - // select = total - id + base::select + // select = total - id - separate_load + base::select // insert = total - inverse - // update = total - inverse - id - readonly + // update = total - inverse - id - readonly - separate_update // 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 + + object_traits::column_count - + id_column_count - + object_traits::separate_load_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; + 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; + object_traits::id_column_count - + object_traits::readonly_column_count - + object_traits::separate_update_column_count; private: polymorphic_derived_object_statements ( @@ -385,8 +398,8 @@ namespace odb root_statements_type& root_statements_; base_statements_type& base_statements_; - container_statement_cache_ptr<container_statement_cache_type> - container_statement_cache_; + extra_statement_cache_ptr<extra_statement_cache_type, image_type> + extra_statement_cache_; image_type image_; diff --git a/odb/sqlite/section-statements.hxx b/odb/sqlite/section-statements.hxx new file mode 100644 index 0000000..3f0d9c4 --- /dev/null +++ b/odb/sqlite/section-statements.hxx @@ -0,0 +1,182 @@ +// file : odb/sqlite/section-statements.hxx +// copyright : Copyright (c) 2005-2013 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_SECTION_STATEMENTS_HXX +#define ODB_SQLITE_SECTION_STATEMENTS_HXX + +#include <odb/pre.hxx> + +#include <cstddef> // std::size_t + +#include <odb/forward.hxx> +#include <odb/traits.hxx> + +#include <odb/sqlite/version.hxx> +#include <odb/sqlite/sqlite-types.hxx> +#include <odb/sqlite/binding.hxx> +#include <odb/sqlite/statement.hxx> +#include <odb/sqlite/details/export.hxx> + +namespace odb +{ + namespace sqlite + { + class connection; + + // Template argument is the section traits type. + // + template <typename T, typename ST> + class section_statements + { + public: + typedef ST traits; + + typedef typename traits::image_type image_type; + + typedef sqlite::select_statement select_statement_type; + typedef sqlite::update_statement update_statement_type; + + typedef sqlite::connection connection_type; + + section_statements (connection_type&, + image_type&, + binding& id, binding& idv); + + connection_type& + connection () {return conn_;} + + image_type& + image () {return image_;} + + const binding& + id_binding () {return id_binding_;} + + // Id and optimistic concurrency version (if any). + // + const binding& + idv_binding () {return idv_binding_;} + + // Select binding. + // + 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_;} + + // 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_;} + + // + // Statements. + // + + select_statement_type& + select_statement () + { + if (select_ == 0) + select_.reset ( + new (details::shared) select_statement_type ( + conn_, + traits::select_statement, + id_binding_, + select_image_binding_)); + + return *select_; + } + + update_statement_type& + update_statement () + { + if (update_ == 0) + update_.reset ( + new (details::shared) update_statement_type ( + conn_, + traits::update_statement, + update_image_binding_)); + + return *update_; + } + + public: + static const std::size_t id_column_count = traits::id_column_count; + static const std::size_t managed_optimistic_load_column_count = + traits::managed_optimistic_load_column_count; + static const std::size_t managed_optimistic_update_column_count = + traits::managed_optimistic_update_column_count; + static const std::size_t select_column_count = traits::load_column_count; + static const std::size_t update_column_count = + traits::update_column_count; + + private: + section_statements (const section_statements&); + section_statements& operator= (const section_statements&); + + protected: + connection_type& conn_; + + // These come from object_statements. + // + image_type& image_; + binding& id_binding_; + binding& idv_binding_; + + // Select binding. + // + std::size_t select_image_version_; + + static const std::size_t select_bind_count = + select_column_count != 0 || managed_optimistic_load_column_count != 0 + ? select_column_count + managed_optimistic_load_column_count + : 1; + + binding select_image_binding_; + bind select_image_bind_[select_bind_count]; + bool select_image_truncated_[select_bind_count]; + + // Update binding. + // + std::size_t update_image_version_; + std::size_t update_id_binding_version_; + + static const std::size_t update_bind_count = + update_column_count != 0 || managed_optimistic_update_column_count != 0 + ? update_column_count + id_column_count + + managed_optimistic_update_column_count + : 1; + + binding update_image_binding_; + bind update_image_bind_[update_bind_count]; + + details::shared_ptr<select_statement_type> select_; + details::shared_ptr<update_statement_type> update_; + }; + } +} + +#include <odb/sqlite/section-statements.txx> + +#include <odb/post.hxx> + +#endif // ODB_SQLITE_SECTION_STATEMENTS_HXX diff --git a/odb/sqlite/section-statements.txx b/odb/sqlite/section-statements.txx new file mode 100644 index 0000000..b6945d9 --- /dev/null +++ b/odb/sqlite/section-statements.txx @@ -0,0 +1,42 @@ +// file : odb/sqlite/section-statements.txx +// copyright : Copyright (c) 2005-2013 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include <cstring> // std::memset + +namespace odb +{ + namespace sqlite + { + template <typename T, typename ST> + section_statements<T, ST>:: + section_statements (connection_type& conn, + image_type& im, + binding& id, binding& idv) + : conn_ (conn), + image_ (im), + id_binding_ (id), + idv_binding_ (idv), + select_image_binding_ (select_image_bind_, + select_column_count + + managed_optimistic_load_column_count), + update_image_binding_ (update_image_bind_, + update_column_count + id_column_count + + managed_optimistic_update_column_count) + { + select_image_version_ = 0; + update_image_version_ = 0; + update_id_binding_version_ = 0; + + std::memset (select_image_bind_, 0, sizeof (select_image_bind_)); + std::memset ( + select_image_truncated_, 0, sizeof (select_image_truncated_)); + std::memset (update_image_bind_, 0, sizeof (update_image_bind_)); + + for (std::size_t i (0); + i < select_column_count + managed_optimistic_load_column_count; + ++i) + select_image_bind_[i].truncated = select_image_truncated_ + i; + } + } +} diff --git a/odb/sqlite/simple-object-statements.hxx b/odb/sqlite/simple-object-statements.hxx index 2c5b321..a1e7678 100644 --- a/odb/sqlite/simple-object-statements.hxx +++ b/odb/sqlite/simple-object-statements.hxx @@ -29,58 +29,59 @@ namespace odb { namespace sqlite { - // The container_statement_cache class is only defined (and used) in + // The extra_statement_cache class is only defined (and used) in // the generated source file. However, object_statements may be // referenced from another source file in the case of a polymorphic - // hierarchy (though in this case the container statement cache is + // hierarchy (though in this case the extra statement cache is // not used). As a result, we cannot have a by-value member and // instead will store a pointer and lazily allocate the cache if // and when needed. We will also need to store a pointer to the // deleter function which will be initialized during allocation // (at that point we know that the cache class is defined). // - template <typename T> - struct container_statement_cache_ptr + template <typename T, typename I> + struct extra_statement_cache_ptr { + typedef I image_type; typedef sqlite::connection connection_type; - container_statement_cache_ptr (): p_ (0) {} - ~container_statement_cache_ptr () + extra_statement_cache_ptr (): p_ (0) {} + ~extra_statement_cache_ptr () { if (p_ != 0) - (this->*deleter_) (0, 0); + (this->*deleter_) (0, 0, 0, 0); } T& - get (connection_type& c, binding& id) + get (connection_type& c, image_type& im, binding& id, binding* idv) { if (p_ == 0) - allocate (&c, &id); + allocate (&c, &im, &id, (idv != 0 ? idv : &id)); return *p_; } private: void - allocate (connection_type*, binding*); + allocate (connection_type*, image_type*, binding*, binding*); private: T* p_; - void (container_statement_cache_ptr::*deleter_) ( - connection_type*, binding*); + void (extra_statement_cache_ptr::*deleter_) ( + connection_type*, image_type*, binding*, binding*); }; - template <typename T> - void container_statement_cache_ptr<T>:: - allocate (connection_type* c, binding* id) + template <typename T, typename I> + void extra_statement_cache_ptr<T, I>:: + allocate (connection_type* c, image_type* im, binding* id, binding* idv) { // To reduce object code size, this function acts as both allocator // and deleter. // if (p_ == 0) { - p_ = new T (*c, *id); - deleter_ = &container_statement_cache_ptr<T>::allocate; + p_ = new T (*c, *im, *id, *idv); + deleter_ = &extra_statement_cache_ptr<T, I>::allocate; } else delete p_; @@ -156,9 +157,11 @@ namespace odb optimistic_data (bind*); + binding* + id_image_binding () {return &id_image_binding_;} + // The id + optimistic column binding. // - std::size_t id_image_version_; binding id_image_binding_; details::shared_ptr<delete_statement> erase_; @@ -168,6 +171,9 @@ namespace odb struct optimistic_data<T, false> { optimistic_data (bind*) {} + + binding* + id_image_binding () {return 0;} }; template <typename T> @@ -186,8 +192,8 @@ namespace odb pointer_cache_traits; typedef - typename object_traits::container_statement_cache_type - container_statement_cache_type; + typename object_traits::extra_statement_cache_type + extra_statement_cache_type; typedef sqlite::insert_statement insert_statement_type; typedef sqlite::select_statement select_statement_type; @@ -327,14 +333,10 @@ namespace odb binding& id_image_binding () {return id_image_binding_;} - // Optimistic id + managed column image binding. + // Optimistic id + managed column image binding. It points to + // the same suffix as id binding and they are always updated + // at the same time. // - std::size_t - optimistic_id_image_version () const {return od_.id_image_version_;} - - void - optimistic_id_image_version (std::size_t v) {od_.id_image_version_ = v;} - binding& optimistic_id_image_binding () {return od_.id_image_binding_;} @@ -416,35 +418,42 @@ namespace odb return *od_.erase_; } - // Container statement cache. + // Extra (container, section) statement cache. // - container_statement_cache_type& - container_statment_cache () + extra_statement_cache_type& + extra_statement_cache () { - return container_statement_cache_.get (conn_, id_image_binding_); + return extra_statement_cache_.get ( + conn_, image_, id_image_binding_, od_.id_image_binding ()); } public: - // select = total + // select = total - separate_load // insert = total - inverse - managed_optimistic // update = total - inverse - managed_optimistic - id - readonly + // - separate_update // - static const std::size_t select_column_count = - object_traits::column_count; - - static const std::size_t insert_column_count = - object_traits::column_count - object_traits::inverse_column_count - - object_traits::managed_optimistic_column_count; - - static const std::size_t update_column_count = insert_column_count - - object_traits::id_column_count - object_traits::readonly_column_count; - static const std::size_t id_column_count = object_traits::id_column_count; static const std::size_t managed_optimistic_column_count = object_traits::managed_optimistic_column_count; + static const std::size_t select_column_count = + object_traits::column_count - + object_traits::separate_load_column_count; + + static const std::size_t insert_column_count = + object_traits::column_count - + object_traits::inverse_column_count - + object_traits::managed_optimistic_column_count; + + static const std::size_t update_column_count = + insert_column_count - + id_column_count - + object_traits::readonly_column_count - + object_traits::separate_update_column_count; + private: object_statements (const object_statements&); object_statements& operator= (const object_statements&); @@ -457,8 +466,11 @@ namespace odb clear_delayed_ (); private: - container_statement_cache_ptr<container_statement_cache_type> - container_statement_cache_; + template <typename T1> + friend class polymorphic_derived_object_statements; + + extra_statement_cache_ptr<extra_statement_cache_type, image_type> + extra_statement_cache_; image_type image_; diff --git a/odb/sqlite/simple-object-statements.txx b/odb/sqlite/simple-object-statements.txx index f0e6138..15689c6 100644 --- a/odb/sqlite/simple-object-statements.txx +++ b/odb/sqlite/simple-object-statements.txx @@ -25,7 +25,6 @@ namespace odb object_traits::id_column_count + object_traits::managed_optimistic_column_count) { - id_image_version_ = 0; } // |