| connection-factory.hxx | | connection-factory.hxx | |
|---|
| | | | |
| skipping to change at line 30 | | skipping to change at line 30 | |
|---|
| #include <odb/sqlite/connection.hxx> | | #include <odb/sqlite/connection.hxx> | |
| #include <odb/sqlite/details/export.hxx> | | #include <odb/sqlite/details/export.hxx> | |
| | | | |
| namespace odb | | namespace odb | |
| { | | { | |
| namespace sqlite | | namespace sqlite | |
| { | | { | |
| class LIBODB_SQLITE_EXPORT connection_factory | | class LIBODB_SQLITE_EXPORT connection_factory | |
| { | | { | |
| public: | | public: | |
|
| virtual details::shared_ptr<connection> | | virtual connection_ptr | |
| connect () = 0; | | connect () = 0; | |
| | | | |
| public: | | public: | |
| typedef sqlite::database database_type; | | typedef sqlite::database database_type; | |
| | | | |
| virtual void | | virtual void | |
| database (database_type&) = 0; | | database (database_type&) = 0; | |
| | | | |
| virtual | | virtual | |
| ~connection_factory (); | | ~connection_factory (); | |
| }; | | }; | |
| | | | |
| // Share a single connection. | | // Share a single connection. | |
| // | | // | |
| class LIBODB_SQLITE_EXPORT single_connection_factory: | | class LIBODB_SQLITE_EXPORT single_connection_factory: | |
| public connection_factory | | public connection_factory | |
| { | | { | |
| public: | | public: | |
| single_connection_factory (): db_ (0) {} | | single_connection_factory (): db_ (0) {} | |
| | | | |
|
| virtual details::shared_ptr<connection> | | virtual connection_ptr | |
| connect (); | | connect (); | |
| | | | |
| virtual void | | virtual void | |
| database (database_type&); | | database (database_type&); | |
| | | | |
| virtual | | virtual | |
| ~single_connection_factory (); | | ~single_connection_factory (); | |
| | | | |
| private: | | private: | |
| single_connection_factory (const single_connection_factory&); | | single_connection_factory (const single_connection_factory&); | |
| single_connection_factory& operator= (const single_connection_factory
&); | | single_connection_factory& operator= (const single_connection_factory
&); | |
| | | | |
|
| private: | | protected: | |
| class single_connection: public connection | | class single_connection: public connection | |
| { | | { | |
| public: | | public: | |
|
| // NULL factory value indicates that the connection is not in use. | | single_connection (database_type&, int extra_flags = 0); | |
| // | | single_connection (database_type&, sqlite3*); | |
| single_connection (database_type&, | | | |
| int extra_flags, | | | |
| single_connection_factory*); | | | |
| | | | |
| private: | | private: | |
| static bool | | static bool | |
| zero_counter (void*); | | zero_counter (void*); | |
| | | | |
| private: | | private: | |
| friend class single_connection_factory; | | friend class single_connection_factory; | |
| | | | |
| shared_base::refcount_callback callback_; | | shared_base::refcount_callback callback_; | |
|
| | | | |
| | | // NULL factory value indicates that the connection is not in use. | |
| | | // | |
| single_connection_factory* factory_; | | single_connection_factory* factory_; | |
| }; | | }; | |
| | | | |
| friend class single_connection; | | friend class single_connection; | |
| | | | |
|
| private: | | typedef details::shared_ptr<single_connection> single_connection_ptr; | |
| | | | |
| | | // This function is called when the factory needs to create the | |
| | | // connection. | |
| | | // | |
| | | virtual single_connection_ptr | |
| | | create (); | |
| | | | |
| | | protected: | |
| // Return true if the connection should be deleted, false otherwise. | | // Return true if the connection should be deleted, false otherwise. | |
| // | | // | |
| bool | | bool | |
| release (single_connection*); | | release (single_connection*); | |
| | | | |
|
| private: | | protected: | |
| database_type* db_; | | database_type* db_; | |
| details::mutex mutex_; | | details::mutex mutex_; | |
|
| details::shared_ptr<single_connection> connection_; | | single_connection_ptr connection_; | |
| }; | | }; | |
| | | | |
| // Create a new connection every time one is requested. | | // Create a new connection every time one is requested. | |
| // | | // | |
| class LIBODB_SQLITE_EXPORT new_connection_factory: | | class LIBODB_SQLITE_EXPORT new_connection_factory: | |
| public connection_factory | | public connection_factory | |
| { | | { | |
| public: | | public: | |
| new_connection_factory (): db_ (0), extra_flags_ (0) {} | | new_connection_factory (): db_ (0), extra_flags_ (0) {} | |
| | | | |
|
| virtual details::shared_ptr<connection> | | virtual connection_ptr | |
| connect (); | | connect (); | |
| | | | |
| virtual void | | virtual void | |
| database (database_type&); | | database (database_type&); | |
| | | | |
| private: | | private: | |
| new_connection_factory (const new_connection_factory&); | | new_connection_factory (const new_connection_factory&); | |
| new_connection_factory& operator= (const new_connection_factory&); | | new_connection_factory& operator= (const new_connection_factory&); | |
| | | | |
| private: | | private: | |
| | | | |
| skipping to change at line 157 | | skipping to change at line 165 | |
|---|
| min_ (min_connections), | | min_ (min_connections), | |
| extra_flags_ (0), | | extra_flags_ (0), | |
| in_use_ (0), | | in_use_ (0), | |
| waiters_ (0), | | waiters_ (0), | |
| db_ (0), | | db_ (0), | |
| cond_ (mutex_) | | cond_ (mutex_) | |
| { | | { | |
| // @@ check min_ <= max_ | | // @@ check min_ <= max_ | |
| } | | } | |
| | | | |
|
| virtual details::shared_ptr<connection> | | virtual connection_ptr | |
| connect (); | | connect (); | |
| | | | |
| virtual void | | virtual void | |
| database (database_type&); | | database (database_type&); | |
| | | | |
| virtual | | virtual | |
| ~connection_pool_factory (); | | ~connection_pool_factory (); | |
| | | | |
| private: | | private: | |
| connection_pool_factory (const connection_pool_factory&); | | connection_pool_factory (const connection_pool_factory&); | |
| connection_pool_factory& operator= (const connection_pool_factory&); | | connection_pool_factory& operator= (const connection_pool_factory&); | |
| | | | |
|
| private: | | protected: | |
| class pooled_connection: public connection | | class pooled_connection: public connection | |
| { | | { | |
| public: | | public: | |
|
| // NULL pool value indicates that the connection is not in use. | | pooled_connection (database_type&, int extra_flags = 0); | |
| // | | pooled_connection (database_type&, sqlite3*); | |
| pooled_connection (database_type&, | | | |
| int extra_flags, | | | |
| connection_pool_factory*); | | | |
| | | | |
| private: | | private: | |
| static bool | | static bool | |
| zero_counter (void*); | | zero_counter (void*); | |
| | | | |
| private: | | private: | |
| friend class connection_pool_factory; | | friend class connection_pool_factory; | |
| | | | |
| shared_base::refcount_callback callback_; | | shared_base::refcount_callback callback_; | |
|
| | | | |
| | | // NULL pool value indicates that the connection is not in use. | |
| | | // | |
| connection_pool_factory* pool_; | | connection_pool_factory* pool_; | |
| }; | | }; | |
| | | | |
| friend class pooled_connection; | | friend class pooled_connection; | |
|
| typedef std::vector<details::shared_ptr<pooled_connection> > connecti
ons; | | | |
| | | | |
|
| private: | | typedef details::shared_ptr<pooled_connection> pooled_connection_ptr; | |
| | | typedef std::vector<pooled_connection_ptr> connections; | |
| | | | |
| | | // This function is called whenever the pool needs to create a new | |
| | | // connection. | |
| | | // | |
| | | virtual pooled_connection_ptr | |
| | | create (); | |
| | | | |
| | | protected: | |
| // Return true if the connection should be deleted, false otherwise. | | // Return true if the connection should be deleted, false otherwise. | |
| // | | // | |
| bool | | bool | |
| release (pooled_connection*); | | release (pooled_connection*); | |
| | | | |
|
| private: | | protected: | |
| const std::size_t max_; | | const std::size_t max_; | |
| const std::size_t min_; | | const std::size_t min_; | |
| int extra_flags_; | | int extra_flags_; | |
| | | | |
| std::size_t in_use_; // Number of connections currently in use. | | std::size_t in_use_; // Number of connections currently in use. | |
| std::size_t waiters_; // Number of threads waiting for a connection. | | std::size_t waiters_; // Number of threads waiting for a connection. | |
| | | | |
| database_type* db_; | | database_type* db_; | |
| connections connections_; | | connections connections_; | |
| | | | |
| | | | |
| End of changes. 16 change blocks. |
|---|
| 22 lines changed or deleted | | 38 lines changed or added | |
|---|
|
| query.hxx | | query.hxx | |
|---|
| | | | |
| skipping to change at line 118 | | skipping to change at line 118 | |
|---|
| }; | | }; | |
| | | | |
| // | | // | |
| // | | // | |
| template <typename T, database_type_id ID> | | template <typename T, database_type_id ID> | |
| struct query_column; | | struct query_column; | |
| | | | |
| class LIBODB_SQLITE_EXPORT query | | class LIBODB_SQLITE_EXPORT query | |
| { | | { | |
| public: | | public: | |
|
| | | struct clause_part | |
| | | { | |
| | | enum kind_type | |
| | | { | |
| | | column, | |
| | | param, | |
| | | native, | |
| | | boolean | |
| | | }; | |
| | | | |
| | | clause_part (kind_type k): kind (k) {} | |
| | | clause_part (kind_type k, const std::string& p): kind (k), part (p) | |
| | | {} | |
| | | clause_part (bool p): kind (boolean), bool_part (p) {} | |
| | | | |
| | | kind_type kind; | |
| | | std::string part; | |
| | | bool bool_part; | |
| | | }; | |
| | | | |
| query () | | query () | |
| : parameters_ (new (details::shared) query_params) | | : parameters_ (new (details::shared) query_params) | |
| { | | { | |
| } | | } | |
| | | | |
|
| | | // True or false literal. | |
| | | // | |
| | | explicit | |
| | | query (bool v) | |
| | | : parameters_ (new (details::shared) query_params) | |
| | | { | |
| | | clause_.push_back (clause_part (v)); | |
| | | } | |
| | | | |
| explicit | | explicit | |
|
| query (const std::string& q) | | query (const char* native) | |
| : clause_ (q), parameters_ (new (details::shared) query_params) | | : parameters_ (new (details::shared) query_params) | |
| { | | { | |
|
| | | clause_.push_back (clause_part (clause_part::native, native)); | |
| | | } | |
| | | | |
| | | explicit | |
| | | query (const std::string& native) | |
| | | : parameters_ (new (details::shared) query_params) | |
| | | { | |
| | | clause_.push_back (clause_part (clause_part::native, native)); | |
| | | } | |
| | | | |
| | | query (const char* table, const char* column) | |
| | | : parameters_ (new (details::shared) query_params) | |
| | | { | |
| | | append (table, column); | |
| } | | } | |
| | | | |
| template <typename T> | | template <typename T> | |
| explicit | | explicit | |
| query (val_bind<T> v) | | query (val_bind<T> v) | |
| : parameters_ (new (details::shared) query_params) | | : parameters_ (new (details::shared) query_params) | |
| { | | { | |
| append<T, type_traits<T>::db_type_id> (v); | | append<T, type_traits<T>::db_type_id> (v); | |
| } | | } | |
| | | | |
| | | | |
| skipping to change at line 157 | | skipping to change at line 199 | |
|---|
| | | | |
| query (const query&); | | query (const query&); | |
| | | | |
| query& | | query& | |
| operator= (const query&); | | operator= (const query&); | |
| | | | |
| public: | | public: | |
| std::string | | std::string | |
| clause () const; | | clause () const; | |
| | | | |
|
| | | const char* | |
| | | clause_prefix () const; | |
| | | | |
| binding& | | binding& | |
| parameters_binding () const; | | parameters_binding () const; | |
| | | | |
| details::shared_ptr<query_params> | | details::shared_ptr<query_params> | |
| parameters () const; | | parameters () const; | |
| | | | |
| public: | | public: | |
|
| | | bool | |
| | | empty () const | |
| | | { | |
| | | return clause_.empty (); | |
| | | } | |
| | | | |
| | | static const query true_expr; | |
| | | | |
| | | bool | |
| | | const_true () const | |
| | | { | |
| | | return clause_.size () == 1 && | |
| | | clause_.front ().kind == clause_part::boolean && | |
| | | clause_.front ().bool_part; | |
| | | } | |
| | | | |
| | | void | |
| | | optimize (); | |
| | | | |
| | | public: | |
| template <typename T> | | template <typename T> | |
| static val_bind<T> | | static val_bind<T> | |
| _val (const T& x) | | _val (const T& x) | |
| { | | { | |
| return val_bind<T> (x); | | return val_bind<T> (x); | |
| } | | } | |
| | | | |
| template <typename T> | | template <typename T> | |
| static ref_bind<T> | | static ref_bind<T> | |
| _ref (const T& x) | | _ref (const T& x) | |
| | | | |
| skipping to change at line 185 | | skipping to change at line 250 | |
|---|
| return ref_bind<T> (x); | | return ref_bind<T> (x); | |
| } | | } | |
| | | | |
| public: | | public: | |
| query& | | query& | |
| operator+= (const query&); | | operator+= (const query&); | |
| | | | |
| query& | | query& | |
| operator+= (const std::string& q) | | operator+= (const std::string& q) | |
| { | | { | |
|
| size_t n (clause_.size ()); | | append (q); | |
| | | | |
| if (n != 0 && clause_[n - 1] != ' ' && !q.empty () && q[0] != ' ') | | | |
| clause_ += ' '; | | | |
| | | | |
| clause_ += q; | | | |
| return *this; | | return *this; | |
| } | | } | |
| | | | |
| template <typename T> | | template <typename T> | |
| query& | | query& | |
| operator+= (val_bind<T> v) | | operator+= (val_bind<T> v) | |
| { | | { | |
| append<T, type_traits<T>::db_type_id> (v); | | append<T, type_traits<T>::db_type_id> (v); | |
| return *this; | | return *this; | |
| } | | } | |
| | | | |
| skipping to change at line 219 | | skipping to change at line 279 | |
|---|
| | | | |
| public: | | public: | |
| template <typename T, database_type_id ID> | | template <typename T, database_type_id ID> | |
| void | | void | |
| append (val_bind<T>); | | append (val_bind<T>); | |
| | | | |
| template <typename T, database_type_id ID> | | template <typename T, database_type_id ID> | |
| void | | void | |
| append (ref_bind<T>); | | append (ref_bind<T>); | |
| | | | |
|
| | | void | |
| | | append (const std::string& native); | |
| | | | |
| | | void | |
| | | append (const char* table, const char* column); | |
| | | | |
| private: | | private: | |
| void | | void | |
| add (details::shared_ptr<query_param>); | | add (details::shared_ptr<query_param>); | |
| | | | |
| private: | | private: | |
|
| std::string clause_; | | typedef std::vector<clause_part> clause_type; | |
| | | | |
| | | clause_type clause_; | |
| details::shared_ptr<query_params> parameters_; | | details::shared_ptr<query_params> parameters_; | |
| }; | | }; | |
| | | | |
| inline query | | inline query | |
| operator+ (const query& x, const query& y) | | operator+ (const query& x, const query& y) | |
| { | | { | |
| query r (x); | | query r (x); | |
| r += y; | | r += y; | |
| return r; | | return r; | |
| } | | } | |
| | | | |
| skipping to change at line 328 | | skipping to change at line 396 | |
|---|
| template <typename T> | | template <typename T> | |
| inline query | | inline query | |
| operator+ (ref_bind<T> b, const std::string& s) | | operator+ (ref_bind<T> b, const std::string& s) | |
| { | | { | |
| query r; | | query r; | |
| r += b; | | r += b; | |
| r += s; | | r += s; | |
| return r; | | return r; | |
| } | | } | |
| | | | |
|
| inline query | | LIBODB_SQLITE_EXPORT query | |
| operator&& (const query& x, const query& y) | | operator&& (const query&, const query&); | |
| { | | | |
| query r ("("); | | | |
| r += x; | | | |
| r += ") AND ("; | | | |
| r += y; | | | |
| r += ")"; | | | |
| return r; | | | |
| } | | | |
| | | | |
|
| inline query | | LIBODB_SQLITE_EXPORT query | |
| operator|| (const query& x, const query& y) | | operator|| (const query&, const query&); | |
| { | | | |
| query r ("("); | | | |
| r += x; | | | |
| r += ") OR ("; | | | |
| r += y; | | | |
| r += ")"; | | | |
| return r; | | | |
| } | | | |
| | | | |
|
| inline query | | LIBODB_SQLITE_EXPORT query | |
| operator! (const query& x) | | operator! (const query&); | |
| { | | | |
| query r ("NOT ("); | | | |
| r += x; | | | |
| r += ")"; | | | |
| return r; | | | |
| } | | | |
| | | | |
| // query_column | | // query_column | |
| // | | // | |
| | | | |
| template <typename T, typename T2> | | template <typename T, typename T2> | |
| class copy_bind: public val_bind<T> | | class copy_bind: public val_bind<T> | |
| { | | { | |
| public: | | public: | |
| explicit | | explicit | |
| copy_bind (const T2& v): val_bind<T> (val), val (v) {} | | copy_bind (const T2& v): val_bind<T> (val), val (v) {} | |
| | | | |
| skipping to change at line 379 | | skipping to change at line 425 | |
|---|
| const T val; | | const T val; | |
| }; | | }; | |
| | | | |
| template <typename T> | | template <typename T> | |
| const T& | | const T& | |
| type_instance (); | | type_instance (); | |
| | | | |
| template <typename T, database_type_id ID> | | template <typename T, database_type_id ID> | |
| struct query_column | | struct query_column | |
| { | | { | |
|
| explicit | | // Note that we keep shalow copies of the table and column names. | |
| query_column (const char* name) | | // | |
| : name_ (name) | | query_column (const char* table, const char* column) | |
| | | : table_ (table), column_ (column) | |
| { | | { | |
| } | | } | |
| | | | |
| const char* | | const char* | |
|
| name () const | | table () const | |
| { | | { | |
|
| return name_; | | return table_; | |
| | | } | |
| | | | |
| | | const char* | |
| | | column () const | |
| | | { | |
| | | return column_; | |
| } | | } | |
| | | | |
| // is_null, is_not_null | | // is_null, is_not_null | |
| // | | // | |
| public: | | public: | |
| query | | query | |
| is_null () const | | is_null () const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "IS NULL"; | | q += "IS NULL"; | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| query | | query | |
| is_not_null () const | | is_not_null () const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "IS NOT NULL"; | | q += "IS NOT NULL"; | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| // in | | // in | |
| // | | // | |
| public: | | public: | |
| query | | query | |
| in (const T&, const T&) const; | | in (const T&, const T&) const; | |
| | | | |
| | | | |
| skipping to change at line 441 | | skipping to change at line 494 | |
|---|
| public: | | public: | |
| query | | query | |
| equal (const T& v) const | | equal (const T& v) const | |
| { | | { | |
| return equal (val_bind<T> (v)); | | return equal (val_bind<T> (v)); | |
| } | | } | |
| | | | |
| query | | query | |
| equal (val_bind<T> v) const | | equal (val_bind<T> v) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "="; | | q += "="; | |
| q.append<T, ID> (v); | | q.append<T, ID> (v); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T2> | | template <typename T2> | |
| query | | query | |
| equal (val_bind<T2> v) const | | equal (val_bind<T2> v) const | |
| { | | { | |
| copy_bind<T, T2> c (v.val); | | copy_bind<T, T2> c (v.val); | |
| return equal (c); | | return equal (c); | |
| } | | } | |
| | | | |
| query | | query | |
| equal (ref_bind<T> r) const | | equal (ref_bind<T> r) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "="; | | q += "="; | |
| q.append<T, ID> (r); | | q.append<T, ID> (r); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| friend query | | friend query | |
| operator== (const query_column& c, const T& v) | | operator== (const query_column& c, const T& v) | |
| { | | { | |
| return c.equal (v); | | return c.equal (v); | |
| } | | } | |
| | | | |
| skipping to change at line 526 | | skipping to change at line 579 | |
|---|
| public: | | public: | |
| query | | query | |
| unequal (const T& v) const | | unequal (const T& v) const | |
| { | | { | |
| return unequal (val_bind<T> (v)); | | return unequal (val_bind<T> (v)); | |
| } | | } | |
| | | | |
| query | | query | |
| unequal (val_bind<T> v) const | | unequal (val_bind<T> v) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "!="; | | q += "!="; | |
| q.append<T, ID> (v); | | q.append<T, ID> (v); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T2> | | template <typename T2> | |
| query | | query | |
| unequal (val_bind<T2> v) const | | unequal (val_bind<T2> v) const | |
| { | | { | |
| copy_bind<T, T2> c (v.val); | | copy_bind<T, T2> c (v.val); | |
| return unequal (c); | | return unequal (c); | |
| } | | } | |
| | | | |
| query | | query | |
| unequal (ref_bind<T> r) const | | unequal (ref_bind<T> r) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "!="; | | q += "!="; | |
| q.append<T, ID> (r); | | q.append<T, ID> (r); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| friend query | | friend query | |
| operator!= (const query_column& c, const T& v) | | operator!= (const query_column& c, const T& v) | |
| { | | { | |
| return c.unequal (v); | | return c.unequal (v); | |
| } | | } | |
| | | | |
| skipping to change at line 611 | | skipping to change at line 664 | |
|---|
| public: | | public: | |
| query | | query | |
| less (const T& v) const | | less (const T& v) const | |
| { | | { | |
| return less (val_bind<T> (v)); | | return less (val_bind<T> (v)); | |
| } | | } | |
| | | | |
| query | | query | |
| less (val_bind<T> v) const | | less (val_bind<T> v) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "<"; | | q += "<"; | |
| q.append<T, ID> (v); | | q.append<T, ID> (v); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T2> | | template <typename T2> | |
| query | | query | |
| less (val_bind<T2> v) const | | less (val_bind<T2> v) const | |
| { | | { | |
| copy_bind<T, T2> c (v.val); | | copy_bind<T, T2> c (v.val); | |
| return less (c); | | return less (c); | |
| } | | } | |
| | | | |
| query | | query | |
| less (ref_bind<T> r) const | | less (ref_bind<T> r) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "<"; | | q += "<"; | |
| q.append<T, ID> (r); | | q.append<T, ID> (r); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| friend query | | friend query | |
| operator< (const query_column& c, const T& v) | | operator< (const query_column& c, const T& v) | |
| { | | { | |
| return c.less (v); | | return c.less (v); | |
| } | | } | |
| | | | |
| skipping to change at line 696 | | skipping to change at line 749 | |
|---|
| public: | | public: | |
| query | | query | |
| greater (const T& v) const | | greater (const T& v) const | |
| { | | { | |
| return greater (val_bind<T> (v)); | | return greater (val_bind<T> (v)); | |
| } | | } | |
| | | | |
| query | | query | |
| greater (val_bind<T> v) const | | greater (val_bind<T> v) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += ">"; | | q += ">"; | |
| q.append<T, ID> (v); | | q.append<T, ID> (v); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T2> | | template <typename T2> | |
| query | | query | |
| greater (val_bind<T2> v) const | | greater (val_bind<T2> v) const | |
| { | | { | |
| copy_bind<T, T2> c (v.val); | | copy_bind<T, T2> c (v.val); | |
| return greater (c); | | return greater (c); | |
| } | | } | |
| | | | |
| query | | query | |
| greater (ref_bind<T> r) const | | greater (ref_bind<T> r) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += ">"; | | q += ">"; | |
| q.append<T, ID> (r); | | q.append<T, ID> (r); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| friend query | | friend query | |
| operator> (const query_column& c, const T& v) | | operator> (const query_column& c, const T& v) | |
| { | | { | |
| return c.greater (v); | | return c.greater (v); | |
| } | | } | |
| | | | |
| skipping to change at line 781 | | skipping to change at line 834 | |
|---|
| public: | | public: | |
| query | | query | |
| less_equal (const T& v) const | | less_equal (const T& v) const | |
| { | | { | |
| return less_equal (val_bind<T> (v)); | | return less_equal (val_bind<T> (v)); | |
| } | | } | |
| | | | |
| query | | query | |
| less_equal (val_bind<T> v) const | | less_equal (val_bind<T> v) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "<="; | | q += "<="; | |
| q.append<T, ID> (v); | | q.append<T, ID> (v); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T2> | | template <typename T2> | |
| query | | query | |
| less_equal (val_bind<T2> v) const | | less_equal (val_bind<T2> v) const | |
| { | | { | |
| copy_bind<T, T2> c (v.val); | | copy_bind<T, T2> c (v.val); | |
| return less_equal (c); | | return less_equal (c); | |
| } | | } | |
| | | | |
| query | | query | |
| less_equal (ref_bind<T> r) const | | less_equal (ref_bind<T> r) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "<="; | | q += "<="; | |
| q.append<T, ID> (r); | | q.append<T, ID> (r); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| friend query | | friend query | |
| operator<= (const query_column& c, const T& v) | | operator<= (const query_column& c, const T& v) | |
| { | | { | |
| return c.less_equal (v); | | return c.less_equal (v); | |
| } | | } | |
| | | | |
| skipping to change at line 866 | | skipping to change at line 919 | |
|---|
| public: | | public: | |
| query | | query | |
| greater_equal (const T& v) const | | greater_equal (const T& v) const | |
| { | | { | |
| return greater_equal (val_bind<T> (v)); | | return greater_equal (val_bind<T> (v)); | |
| } | | } | |
| | | | |
| query | | query | |
| greater_equal (val_bind<T> v) const | | greater_equal (val_bind<T> v) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += ">="; | | q += ">="; | |
| q.append<T, ID> (v); | | q.append<T, ID> (v); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T2> | | template <typename T2> | |
| query | | query | |
| greater_equal (val_bind<T2> v) const | | greater_equal (val_bind<T2> v) const | |
| { | | { | |
| copy_bind<T, T2> c (v.val); | | copy_bind<T, T2> c (v.val); | |
| return greater_equal (c); | | return greater_equal (c); | |
| } | | } | |
| | | | |
| query | | query | |
| greater_equal (ref_bind<T> r) const | | greater_equal (ref_bind<T> r) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += ">="; | | q += ">="; | |
| q.append<T, ID> (r); | | q.append<T, ID> (r); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| friend query | | friend query | |
| operator>= (const query_column& c, const T& v) | | operator>= (const query_column& c, const T& v) | |
| { | | { | |
| return c.greater_equal (v); | | return c.greater_equal (v); | |
| } | | } | |
| | | | |
| skipping to change at line 950 | | skipping to change at line 1003 | |
|---|
| // | | // | |
| public: | | public: | |
| template <typename T2, database_type_id ID2> | | template <typename T2, database_type_id ID2> | |
| query | | query | |
| operator== (const query_column<T2, ID2>& c) const | | operator== (const query_column<T2, ID2>& c) const | |
| { | | { | |
| // We can compare columns only if we can compare their C++ types. | | // We can compare columns only if we can compare their C++ types. | |
| // | | // | |
| (void) (sizeof (type_instance<T> () == type_instance<T2> ())); | | (void) (sizeof (type_instance<T> () == type_instance<T2> ())); | |
| | | | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "="; | | q += "="; | |
|
| q += c.name (); | | q.append (c.table (), c.column ()); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T2, database_type_id ID2> | | template <typename T2, database_type_id ID2> | |
| query | | query | |
| operator!= (const query_column<T2, ID2>& c) const | | operator!= (const query_column<T2, ID2>& c) const | |
| { | | { | |
| // We can compare columns only if we can compare their C++ types. | | // We can compare columns only if we can compare their C++ types. | |
| // | | // | |
| (void) (sizeof (type_instance<T> () != type_instance<T2> ())); | | (void) (sizeof (type_instance<T> () != type_instance<T2> ())); | |
| | | | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "!="; | | q += "!="; | |
|
| q += c.name (); | | q.append (c.table (), c.column ()); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T2, database_type_id ID2> | | template <typename T2, database_type_id ID2> | |
| query | | query | |
| operator< (const query_column<T2, ID2>& c) const | | operator< (const query_column<T2, ID2>& c) const | |
| { | | { | |
| // We can compare columns only if we can compare their C++ types. | | // We can compare columns only if we can compare their C++ types. | |
| // | | // | |
| (void) (sizeof (type_instance<T> () < type_instance<T2> ())); | | (void) (sizeof (type_instance<T> () < type_instance<T2> ())); | |
| | | | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "<"; | | q += "<"; | |
|
| q += c.name (); | | q.append (c.table (), c.column ()); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T2, database_type_id ID2> | | template <typename T2, database_type_id ID2> | |
| query | | query | |
| operator> (const query_column<T2, ID2>& c) const | | operator> (const query_column<T2, ID2>& c) const | |
| { | | { | |
| // We can compare columns only if we can compare their C++ types. | | // We can compare columns only if we can compare their C++ types. | |
| // | | // | |
| (void) (sizeof (type_instance<T> () > type_instance<T2> ())); | | (void) (sizeof (type_instance<T> () > type_instance<T2> ())); | |
| | | | |
|
| query q (name_); | | query q (table_, column_); | |
| q += ">"; | | q += ">"; | |
|
| q += c.name (); | | q.append (c.table (), c.column ()); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T2, database_type_id ID2> | | template <typename T2, database_type_id ID2> | |
| query | | query | |
| operator<= (const query_column<T2, ID2>& c) const | | operator<= (const query_column<T2, ID2>& c) const | |
| { | | { | |
| // We can compare columns only if we can compare their C++ types. | | // We can compare columns only if we can compare their C++ types. | |
| // | | // | |
| (void) (sizeof (type_instance<T> () <= type_instance<T2> ())); | | (void) (sizeof (type_instance<T> () <= type_instance<T2> ())); | |
| | | | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "<="; | | q += "<="; | |
|
| q += c.name (); | | q.append (c.table (), c.column ()); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T2, database_type_id ID2> | | template <typename T2, database_type_id ID2> | |
| query | | query | |
| operator>= (const query_column<T2, ID2>& c) const | | operator>= (const query_column<T2, ID2>& c) const | |
| { | | { | |
| // We can compare columns only if we can compare their C++ types. | | // We can compare columns only if we can compare their C++ types. | |
| // | | // | |
| (void) (sizeof (type_instance<T> () >= type_instance<T2> ())); | | (void) (sizeof (type_instance<T> () >= type_instance<T2> ())); | |
| | | | |
|
| query q (name_); | | query q (table_, column_); | |
| q += ">="; | | q += ">="; | |
|
| q += c.name (); | | q.append (c.table (), c.column ()); | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| private: | | private: | |
|
| const char* name_; | | const char* table_; | |
| | | const char* column_; | |
| }; | | }; | |
| | | | |
|
| | | // Provide operator+() for using columns to construct native | |
| | | // query fragments (e.g., ORDER BY). | |
| | | // | |
| | | template <typename T, database_type_id ID> | |
| | | inline query | |
| | | operator+ (const query_column<T, ID>& c, const std::string& s) | |
| | | { | |
| | | query q (c.table (), c.column ()); | |
| | | q += s; | |
| | | return q; | |
| | | } | |
| | | | |
| | | template <typename T, database_type_id ID> | |
| | | inline query | |
| | | operator+ (const std::string& s, const query_column<T, ID>& c) | |
| | | { | |
| | | query q (s); | |
| | | q.append (c.table (), c.column ()); | |
| | | return q; | |
| | | } | |
| | | | |
| | | template <typename T, database_type_id ID> | |
| | | inline query | |
| | | operator+ (const query_column<T, ID>& c, const query& q) | |
| | | { | |
| | | query r (c.table (), c.column ()); | |
| | | r += q; | |
| | | return r; | |
| | | } | |
| | | | |
| | | template <typename T, database_type_id ID> | |
| | | inline query | |
| | | operator+ (const query& q, const query_column<T, ID>& c) | |
| | | { | |
| | | query r (q); | |
| | | r.append (c.table (), c.column ()); | |
| | | return r; | |
| | | } | |
| | | | |
| // | | // | |
| // | | // | |
| template <typename T, database_type_id> | | template <typename T, database_type_id> | |
| struct query_param_impl; | | struct query_param_impl; | |
| | | | |
| // INTEGER | | // INTEGER | |
| // | | // | |
| template <typename T> | | template <typename T> | |
| struct query_param_impl<T, id_integer>: query_param | | struct query_param_impl<T, id_integer>: query_param | |
| { | | { | |
| | | | |
| skipping to change at line 1184 | | skipping to change at line 1277 | |
|---|
| std::size_t size_; | | std::size_t size_; | |
| }; | | }; | |
| } | | } | |
| } | | } | |
| | | | |
| // odb::query specialization for SQLite. | | // odb::query specialization for SQLite. | |
| // | | // | |
| namespace odb | | namespace odb | |
| { | | { | |
| template <typename T> | | template <typename T> | |
|
| class query<T, sqlite::query>: public object_traits<T>::query_type | | class query<T, sqlite::query>: public query_selector<T>::type | |
| { | | { | |
| public: | | public: | |
| // We don't define any typedefs here since they may clash with | | // We don't define any typedefs here since they may clash with | |
| // column names defined by our base type. | | // column names defined by our base type. | |
| // | | // | |
| | | | |
| query () | | query () | |
| { | | { | |
| } | | } | |
| | | | |
| explicit | | explicit | |
|
| | | query (bool v) | |
| | | : query_selector<T>::type (v) | |
| | | { | |
| | | } | |
| | | | |
| | | explicit | |
| | | query (const char* q) | |
| | | : query_selector<T>::type (q) | |
| | | { | |
| | | } | |
| | | | |
| | | explicit | |
| query (const std::string& q) | | query (const std::string& q) | |
|
| : object_traits<T>::query_type (q) | | : query_selector<T>::type (q) | |
| { | | { | |
| } | | } | |
| | | | |
| template <typename T2> | | template <typename T2> | |
| explicit | | explicit | |
| query (sqlite::val_bind<T2> v) | | query (sqlite::val_bind<T2> v) | |
|
| : object_traits<T>::query_type (sqlite::query (v)) | | : query_selector<T>::type (sqlite::query (v)) | |
| { | | { | |
| } | | } | |
| | | | |
| template <typename T2> | | template <typename T2> | |
| explicit | | explicit | |
| query (sqlite::ref_bind<T2> r) | | query (sqlite::ref_bind<T2> r) | |
|
| : object_traits<T>::query_type (sqlite::query (r)) | | : query_selector<T>::type (sqlite::query (r)) | |
| { | | { | |
| } | | } | |
| | | | |
| query (const sqlite::query& q) | | query (const sqlite::query& q) | |
|
| : object_traits<T>::query_type (q) | | : query_selector<T>::type (q) | |
| { | | { | |
| } | | } | |
| | | | |
| template <sqlite::database_type_id ID> | | template <sqlite::database_type_id ID> | |
| query (const sqlite::query_column<bool, ID>& qc) | | query (const sqlite::query_column<bool, ID>& qc) | |
|
| : object_traits<T>::query_type (qc) | | : query_selector<T>::type (qc) | |
| { | | { | |
| } | | } | |
| }; | | }; | |
| } | | } | |
| | | | |
| #include <odb/sqlite/query.ixx> | | #include <odb/sqlite/query.ixx> | |
| #include <odb/sqlite/query.txx> | | #include <odb/sqlite/query.txx> | |
| | | | |
| #include <odb/post.hxx> | | #include <odb/post.hxx> | |
| | | | |
| | | | |
| End of changes. 50 change blocks. |
|---|
| 75 lines changed or deleted | | 181 lines changed or added | |
|---|
|
| query.txx | | query.txx | |
|---|
| | | | |
| skipping to change at line 16 | | skipping to change at line 16 | |
|---|
| namespace odb | | namespace odb | |
| { | | { | |
| namespace sqlite | | namespace sqlite | |
| { | | { | |
| // query | | // query | |
| // | | // | |
| | | | |
| template <database_type_id ID> | | template <database_type_id ID> | |
| query:: | | query:: | |
| query (const query_column<bool, ID>& c) | | query (const query_column<bool, ID>& c) | |
|
| : clause_ (c.name ()), | | : parameters_ (new (details::shared) query_params) | |
| parameters_ (new (details::shared) query_params) | | | |
| { | | { | |
| // Cannot use IS TRUE here since database type can be a non- | | // Cannot use IS TRUE here since database type can be a non- | |
| // integral type. | | // integral type. | |
| // | | // | |
|
| clause_ += " = "; | | append (c.table (), c.column ()); | |
| | | append ("="); | |
| append<bool, ID> (val_bind<bool> (true)); | | append<bool, ID> (val_bind<bool> (true)); | |
| } | | } | |
| | | | |
| // query_column | | // query_column | |
| // | | // | |
| template <typename T, database_type_id ID> | | template <typename T, database_type_id ID> | |
| query query_column<T, ID>:: | | query query_column<T, ID>:: | |
| in (const T& v1, const T& v2) const | | in (const T& v1, const T& v2) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "IN ("; | | q += "IN ("; | |
| q.append<T, ID> (val_bind<T> (v1)); | | q.append<T, ID> (val_bind<T> (v1)); | |
| q += ","; | | q += ","; | |
| q.append<T, ID> (val_bind<T> (v2)); | | q.append<T, ID> (val_bind<T> (v2)); | |
| q += ")"; | | q += ")"; | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T, database_type_id ID> | | template <typename T, database_type_id ID> | |
| query query_column<T, ID>:: | | query query_column<T, ID>:: | |
| in (const T& v1, const T& v2, const T& v3) const | | in (const T& v1, const T& v2, const T& v3) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "IN ("; | | q += "IN ("; | |
| q.append<T, ID> (val_bind<T> (v1)); | | q.append<T, ID> (val_bind<T> (v1)); | |
| q += ","; | | q += ","; | |
| q.append<T, ID> (val_bind<T> (v2)); | | q.append<T, ID> (val_bind<T> (v2)); | |
| q += ","; | | q += ","; | |
| q.append<T, ID> (val_bind<T> (v3)); | | q.append<T, ID> (val_bind<T> (v3)); | |
| q += ")"; | | q += ")"; | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T, database_type_id ID> | | template <typename T, database_type_id ID> | |
| query query_column<T, ID>:: | | query query_column<T, ID>:: | |
| in (const T& v1, const T& v2, const T& v3, const T& v4) const | | in (const T& v1, const T& v2, const T& v3, const T& v4) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "IN ("; | | q += "IN ("; | |
| q.append<T, ID> (val_bind<T> (v1)); | | q.append<T, ID> (val_bind<T> (v1)); | |
| q += ","; | | q += ","; | |
| q.append<T, ID> (val_bind<T> (v2)); | | q.append<T, ID> (val_bind<T> (v2)); | |
| q += ","; | | q += ","; | |
| q.append<T, ID> (val_bind<T> (v3)); | | q.append<T, ID> (val_bind<T> (v3)); | |
| q += ","; | | q += ","; | |
| q.append<T, ID> (val_bind<T> (v4)); | | q.append<T, ID> (val_bind<T> (v4)); | |
| q += ")"; | | q += ")"; | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T, database_type_id ID> | | template <typename T, database_type_id ID> | |
| query query_column<T, ID>:: | | query query_column<T, ID>:: | |
| in (const T& v1, const T& v2, const T& v3, const T& v4, const T& v5) co
nst | | in (const T& v1, const T& v2, const T& v3, const T& v4, const T& v5) co
nst | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "IN ("; | | q += "IN ("; | |
| q.append<T, ID> (val_bind<T> (v1)); | | q.append<T, ID> (val_bind<T> (v1)); | |
| q += ","; | | q += ","; | |
| q.append<T, ID> (val_bind<T> (v2)); | | q.append<T, ID> (val_bind<T> (v2)); | |
| q += ","; | | q += ","; | |
| q.append<T, ID> (val_bind<T> (v3)); | | q.append<T, ID> (val_bind<T> (v3)); | |
| q += ","; | | q += ","; | |
| q.append<T, ID> (val_bind<T> (v4)); | | q.append<T, ID> (val_bind<T> (v4)); | |
| q += ","; | | q += ","; | |
| q.append<T, ID> (val_bind<T> (v5)); | | q.append<T, ID> (val_bind<T> (v5)); | |
| q += ")"; | | q += ")"; | |
| return q; | | return q; | |
| } | | } | |
| | | | |
| template <typename T, database_type_id ID> | | template <typename T, database_type_id ID> | |
| template <typename I> | | template <typename I> | |
| query query_column<T, ID>:: | | query query_column<T, ID>:: | |
| in_range (I begin, I end) const | | in_range (I begin, I end) const | |
| { | | { | |
|
| query q (name_); | | query q (table_, column_); | |
| q += "IN ("; | | q += "IN ("; | |
| | | | |
| for (I i (begin); i != end; ++i) | | for (I i (begin); i != end; ++i) | |
| { | | { | |
| if (i != begin) | | if (i != begin) | |
| q += ","; | | q += ","; | |
| | | | |
| q.append<T, ID> (val_bind<T> (*i)); | | q.append<T, ID> (val_bind<T> (*i)); | |
| } | | } | |
| q += ")"; | | q += ")"; | |
| | | | |
| End of changes. 7 change blocks. |
|---|
| 8 lines changed or deleted | | 8 lines changed or added | |
|---|
|
| traits.hxx | | traits.hxx | |
|---|
| | | | |
| skipping to change at line 12 | | skipping to change at line 12 | |
|---|
| // author : Boris Kolpackov <boris@codesynthesis.com> | | // author : Boris Kolpackov <boris@codesynthesis.com> | |
| // copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC | | // copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC | |
| // license : GNU GPL v2; see accompanying LICENSE file | | // license : GNU GPL v2; see accompanying LICENSE file | |
| | | | |
| #ifndef ODB_SQLITE_TRAITS_HXX | | #ifndef ODB_SQLITE_TRAITS_HXX | |
| #define ODB_SQLITE_TRAITS_HXX | | #define ODB_SQLITE_TRAITS_HXX | |
| | | | |
| #include <odb/pre.hxx> | | #include <odb/pre.hxx> | |
| | | | |
| #include <string> | | #include <string> | |
|
| | | #include <vector> | |
| #include <cstddef> // std::size_t | | #include <cstddef> // std::size_t | |
| | | | |
| #include <odb/traits.hxx> | | #include <odb/traits.hxx> | |
|
| | | #include <odb/wrapper-traits.hxx> | |
| | | | |
| #include <odb/details/buffer.hxx> | | #include <odb/details/buffer.hxx> | |
|
| | | #include <odb/details/wrapper-p.hxx> | |
| | | | |
| #include <odb/sqlite/version.hxx> | | #include <odb/sqlite/version.hxx> | |
| #include <odb/sqlite/details/export.hxx> | | #include <odb/sqlite/details/export.hxx> | |
| | | | |
| namespace odb | | namespace odb | |
| { | | { | |
| namespace sqlite | | namespace sqlite | |
| { | | { | |
| enum database_type_id | | enum database_type_id | |
| { | | { | |
| | | | |
| skipping to change at line 55 | | skipping to change at line 59 | |
|---|
| template <> | | template <> | |
| struct image_traits<id_text> {typedef details::buffer image_type;}; | | struct image_traits<id_text> {typedef details::buffer image_type;}; | |
| | | | |
| template <> | | template <> | |
| struct image_traits<id_blob> {typedef details::buffer image_type;}; | | struct image_traits<id_blob> {typedef details::buffer image_type;}; | |
| | | | |
| // | | // | |
| // value_traits | | // value_traits | |
| // | | // | |
| | | | |
|
| | | template <typename W, database_type_id, bool null_handler> | |
| | | struct wrapped_value_traits; | |
| | | | |
| template <typename T, database_type_id> | | template <typename T, database_type_id> | |
| struct default_value_traits; | | struct default_value_traits; | |
| | | | |
|
| | | template <typename T, database_type_id, bool w = details::wrapper_p<T>: | |
| | | :r> | |
| | | struct select_traits; | |
| | | | |
| template <typename T, database_type_id ID> | | template <typename T, database_type_id ID> | |
|
| class value_traits: public default_value_traits<T, ID> | | struct select_traits<T, ID, false> | |
| | | { | |
| | | typedef default_value_traits<T, ID> type; | |
| | | }; | |
| | | | |
| | | template <typename W, database_type_id ID> | |
| | | struct select_traits<W, ID, true> | |
| | | { | |
| | | typedef | |
| | | wrapped_value_traits<W, ID, wrapper_traits<W>::null_handler> | |
| | | type; | |
| | | }; | |
| | | | |
| | | template <typename T, database_type_id ID> | |
| | | class value_traits: public select_traits<T, ID>::type | |
| | | { | |
| | | }; | |
| | | | |
| | | // The wrapped_value_traits specializations should be able to handle | |
| | | // any value type which means we have to have every possible signature | |
| | | // of the set_value() and set_image() functions. | |
| | | // | |
| | | template <typename W, database_type_id ID> | |
| | | struct wrapped_value_traits<W, ID, false> | |
| | | { | |
| | | typedef wrapper_traits<W> wtraits; | |
| | | typedef typename wtraits::wrapped_type wrapped_type; | |
| | | | |
| | | typedef W value_type; | |
| | | typedef wrapped_type query_type; | |
| | | typedef typename image_traits<ID>::image_type image_type; | |
| | | | |
| | | typedef value_traits<wrapped_type, ID> vtraits; | |
| | | | |
| | | static void | |
| | | set_value (W& v, const image_type& i, bool is_null) | |
| | | { | |
| | | vtraits::set_value (wtraits::set_ref (v), i, is_null); | |
| | | } | |
| | | | |
| | | static void | |
| | | set_image (image_type& i, bool& is_null, const W& v) | |
| | | { | |
| | | vtraits::set_image (i, is_null, wtraits::get_ref (v)); | |
| | | } | |
| | | | |
| | | // TEXT and BLOB. | |
| | | // | |
| | | static void | |
| | | set_value (W& v, const details::buffer& b, std::size_t n, bool is_nul | |
| | | l) | |
| | | { | |
| | | vtraits::set_value (wtraits::set_ref (v), b, n, is_null); | |
| | | } | |
| | | | |
| | | static void | |
| | | set_image (details::buffer& b, std::size_t& n, bool& is_null, const W | |
| | | & v) | |
| | | { | |
| | | vtraits::set_image (b, n, is_null, wtraits::get_ref (v)); | |
| | | } | |
| | | }; | |
| | | | |
| | | template <typename W, database_type_id ID> | |
| | | struct wrapped_value_traits<W, ID, true> | |
| { | | { | |
|
| | | typedef wrapper_traits<W> wtraits; | |
| | | typedef typename wtraits::wrapped_type wrapped_type; | |
| | | | |
| | | typedef W value_type; | |
| | | typedef wrapped_type query_type; | |
| | | typedef typename image_traits<ID>::image_type image_type; | |
| | | | |
| | | typedef value_traits<wrapped_type, ID> vtraits; | |
| | | | |
| | | static void | |
| | | set_value (W& v, const image_type& i, bool is_null) | |
| | | { | |
| | | if (is_null) | |
| | | wtraits::set_null (v); | |
| | | else | |
| | | vtraits::set_value (wtraits::set_ref (v), i, is_null); | |
| | | } | |
| | | | |
| | | static void | |
| | | set_image (image_type& i, bool& is_null, const W& v) | |
| | | { | |
| | | is_null = wtraits::get_null (v); | |
| | | | |
| | | if (!is_null) | |
| | | vtraits::set_image (i, is_null, wtraits::get_ref (v)); | |
| | | } | |
| | | | |
| | | // TEXT and BLOB. | |
| | | // | |
| | | static void | |
| | | set_value (W& v, const details::buffer& b, std::size_t n, bool is_nul | |
| | | l) | |
| | | { | |
| | | if (is_null) | |
| | | wtraits::set_null (v); | |
| | | else | |
| | | vtraits::set_value (wtraits::set_ref (v), b, n, is_null); | |
| | | } | |
| | | | |
| | | static void | |
| | | set_image (details::buffer& b, std::size_t& n, bool& is_null, const W | |
| | | & v) | |
| | | { | |
| | | is_null = wtraits::get_null (v); | |
| | | | |
| | | if (!is_null) | |
| | | vtraits::set_image (b, n, is_null, wtraits::get_ref (v)); | |
| | | } | |
| }; | | }; | |
| | | | |
| template <typename T, database_type_id ID> | | template <typename T, database_type_id ID> | |
| struct default_value_traits | | struct default_value_traits | |
| { | | { | |
| typedef T value_type; | | typedef T value_type; | |
| typedef T query_type; | | typedef T query_type; | |
| typedef typename image_traits<ID>::image_type image_type; | | typedef typename image_traits<ID>::image_type image_type; | |
| | | | |
| static void | | static void | |
| | | | |
| skipping to change at line 121 | | skipping to change at line 239 | |
|---|
| bool& is_null, | | bool& is_null, | |
| const std::string&); | | const std::string&); | |
| }; | | }; | |
| | | | |
| // const char* specialization | | // const char* specialization | |
| // | | // | |
| // Specialization for const char* which only supports initialization | | // Specialization for const char* which only supports initialization | |
| // of an image from the value but not the other way around. This way | | // of an image from the value but not the other way around. This way | |
| // we can pass such values to the queries. | | // we can pass such values to the queries. | |
| // | | // | |
|
| template <> | | struct LIBODB_SQLITE_EXPORT c_string_value_traits | |
| struct LIBODB_SQLITE_EXPORT default_value_traits<const char*, id_text> | | | |
| { | | { | |
| typedef const char* value_type; | | typedef const char* value_type; | |
| typedef const char* query_type; | | typedef const char* query_type; | |
| typedef details::buffer image_type; | | typedef details::buffer image_type; | |
| | | | |
| static void | | static void | |
| set_image (details::buffer&, | | set_image (details::buffer&, | |
| std::size_t& n, | | std::size_t& n, | |
| bool& is_null, | | bool& is_null, | |
| const char*); | | const char*); | |
| }; | | }; | |
| | | | |
|
| | | template <> | |
| | | struct LIBODB_SQLITE_EXPORT default_value_traits<const char*, id_text>: | |
| | | c_string_value_traits | |
| | | { | |
| | | }; | |
| | | | |
| | | template <std::size_t n> | |
| | | struct default_value_traits<char[n], id_text>: c_string_value_traits | |
| | | { | |
| | | }; | |
| | | | |
| | | template <std::size_t n> | |
| | | struct default_value_traits<const char[n], id_text>: c_string_value_tra | |
| | | its | |
| | | { | |
| | | }; | |
| | | | |
| | | // std::vector<char> (buffer) specialization. | |
| | | // | |
| | | template <> | |
| | | struct LIBODB_SQLITE_EXPORT default_value_traits<std::vector<char>, id_ | |
| | | blob> | |
| | | { | |
| | | public: | |
| | | typedef std::vector<char> value_type; | |
| | | typedef std::vector<char> query_type; | |
| | | typedef details::buffer image_type; | |
| | | | |
| | | static void | |
| | | set_value (value_type& v, | |
| | | const details::buffer& b, | |
| | | std::size_t n, | |
| | | bool is_null) | |
| | | { | |
| | | if (!is_null) | |
| | | v.assign (b.data (), b.data () + n); | |
| | | else | |
| | | v.clear (); | |
| | | } | |
| | | | |
| | | static void | |
| | | set_image (details::buffer&, | |
| | | std::size_t& n, | |
| | | bool& is_null, | |
| | | const value_type&); | |
| | | }; | |
| | | | |
| // | | // | |
| // type_traits | | // type_traits | |
| // | | // | |
| | | | |
| template <typename T> | | template <typename T> | |
| struct default_type_traits; | | struct default_type_traits; | |
| | | | |
| template <typename T> | | template <typename T> | |
| class type_traits: public default_type_traits<T> | | class type_traits: public default_type_traits<T> | |
| { | | { | |
| | | | |
| skipping to change at line 242 | | skipping to change at line 404 | |
|---|
| struct default_type_traits<std::string> | | struct default_type_traits<std::string> | |
| { | | { | |
| static const database_type_id db_type_id = id_text; | | static const database_type_id db_type_id = id_text; | |
| }; | | }; | |
| | | | |
| template <> | | template <> | |
| struct default_type_traits<const char*> | | struct default_type_traits<const char*> | |
| { | | { | |
| static const database_type_id db_type_id = id_text; | | static const database_type_id db_type_id = id_text; | |
| }; | | }; | |
|
| | | | |
| | | template <std::size_t n> | |
| | | struct default_type_traits<char[n]> | |
| | | { | |
| | | static const database_type_id db_type_id = id_text; | |
| | | }; | |
| | | | |
| | | template <std::size_t n> | |
| | | struct default_type_traits<const char[n]> | |
| | | { | |
| | | static const database_type_id db_type_id = id_text; | |
| | | }; | |
| } | | } | |
| } | | } | |
| | | | |
| #include <odb/post.hxx> | | #include <odb/post.hxx> | |
| | | | |
| #endif // ODB_SQLITE_TRAITS_HXX | | #endif // ODB_SQLITE_TRAITS_HXX | |
| | | | |
| End of changes. 10 change blocks. |
|---|
| 3 lines changed or deleted | | 184 lines changed or added | |
|---|
|