aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--odb/mysql/binding.hxx45
-rw-r--r--odb/mysql/connection.cxx7
-rw-r--r--odb/mysql/connection.hxx9
-rw-r--r--odb/mysql/container-statements.hxx155
-rw-r--r--odb/mysql/container-statements.txx35
-rw-r--r--odb/mysql/forward.hxx6
-rw-r--r--odb/mysql/makefile19
-rw-r--r--odb/mysql/object-statements.cxx17
-rw-r--r--odb/mysql/object-statements.hxx185
-rw-r--r--odb/mysql/object-statements.txx (renamed from odb/mysql/statement.txx)3
-rw-r--r--odb/mysql/query.cxx44
-rw-r--r--odb/mysql/query.hxx106
-rw-r--r--odb/mysql/query.txx2
-rw-r--r--odb/mysql/result.hxx4
-rw-r--r--odb/mysql/result.txx10
-rw-r--r--odb/mysql/statement-cache.hxx83
-rw-r--r--odb/mysql/statement.cxx269
-rw-r--r--odb/mysql/statement.hxx328
-rw-r--r--odb/mysql/transaction-impl.cxx1
19 files changed, 756 insertions, 572 deletions
diff --git a/odb/mysql/binding.hxx b/odb/mysql/binding.hxx
new file mode 100644
index 0000000..1aa7c6e
--- /dev/null
+++ b/odb/mysql/binding.hxx
@@ -0,0 +1,45 @@
+// file : odb/mysql/binding.hxx
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// license : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_MYSQL_BINDING_HXX
+#define ODB_MYSQL_BINDING_HXX
+
+#include <odb/pre.hxx>
+
+#include <cstddef> // std::size_t
+
+#include <odb/forward.hxx>
+
+#include <odb/mysql/mysql.hxx>
+#include <odb/mysql/version.hxx>
+
+#include <odb/mysql/details/export.hxx>
+
+namespace odb
+{
+ namespace mysql
+ {
+ class LIBODB_MYSQL_EXPORT binding
+ {
+ public:
+ binding (MYSQL_BIND* b, std::size_t n)
+ : bind (b), count (n), version (0)
+ {
+ }
+
+ MYSQL_BIND* bind;
+ std::size_t count;
+ std::size_t version;
+
+ private:
+ binding (const binding&);
+ binding& operator= (const binding&);
+ };
+ }
+}
+
+#include <odb/post.hxx>
+
+#endif // ODB_MYSQL_BINDING_HXX
diff --git a/odb/mysql/connection.cxx b/odb/mysql/connection.cxx
index 3c17869..0b38d35 100644
--- a/odb/mysql/connection.cxx
+++ b/odb/mysql/connection.cxx
@@ -3,11 +3,12 @@
// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
// license : GNU GPL v2; see accompanying LICENSE file
-#include <new> // std::bad_alloc
+#include <new> // std::bad_alloc
#include <odb/mysql/database.hxx>
#include <odb/mysql/connection.hxx>
#include <odb/mysql/exceptions.hxx>
+#include <odb/mysql/statement-cache.hxx>
using namespace std;
@@ -17,7 +18,9 @@ namespace odb
{
connection::
connection (database& db)
- : handle_ (&mysql_), active_ (0), statement_cache_ (*this)
+ : handle_ (&mysql_),
+ active_ (0),
+ statement_cache_ (new statement_cache_type (*this))
{
if (mysql_init (handle_) == 0)
throw bad_alloc ();
diff --git a/odb/mysql/connection.hxx b/odb/mysql/connection.hxx
index 7bbc335..7696909 100644
--- a/odb/mysql/connection.hxx
+++ b/odb/mysql/connection.hxx
@@ -9,12 +9,12 @@
#include <odb/pre.hxx>
#include <vector>
+#include <memory> // std::auto_ptr
#include <odb/forward.hxx>
#include <odb/mysql/mysql.hxx>
#include <odb/mysql/version.hxx>
-#include <odb/mysql/statement.hxx>
#include <odb/details/shared-ptr.hxx>
@@ -24,6 +24,9 @@ namespace odb
{
namespace mysql
{
+ class statement;
+ class statement_cache;
+
class LIBODB_MYSQL_EXPORT connection: public details::shared_base
{
public:
@@ -44,7 +47,7 @@ namespace odb
statement_cache_type&
statement_cache ()
{
- return statement_cache_;
+ return *statement_cache_;
}
public:
@@ -82,7 +85,7 @@ namespace odb
MYSQL mysql_;
MYSQL* handle_;
statement* active_;
- statement_cache_type statement_cache_;
+ std::auto_ptr<statement_cache_type> statement_cache_;
typedef std::vector<MYSQL_STMT*> stmt_handles;
stmt_handles stmt_handles_;
diff --git a/odb/mysql/container-statements.hxx b/odb/mysql/container-statements.hxx
new file mode 100644
index 0000000..322129f
--- /dev/null
+++ b/odb/mysql/container-statements.hxx
@@ -0,0 +1,155 @@
+// file : odb/mysql/container-statements.hxx
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// license : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_MYSQL_CONTAINER_STATEMENTS_HXX
+#define ODB_MYSQL_CONTAINER_STATEMENTS_HXX
+
+#include <odb/pre.hxx>
+
+#include <odb/forward.hxx>
+#include <odb/traits.hxx>
+
+#include <odb/mysql/mysql.hxx>
+#include <odb/mysql/version.hxx>
+#include <odb/mysql/statement.hxx>
+
+#include <odb/mysql/details/export.hxx>
+
+namespace odb
+{
+ namespace mysql
+ {
+ class connection;
+
+ // Template argument is the generated container traits type.
+ //
+ template <typename T>
+ class container_statements
+ {
+ public:
+ 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 mysql::insert_statement insert_statement_type;
+ typedef mysql::select_statement select_statement_type;
+ typedef mysql::delete_statement delete_statement_type;
+
+ container_statements (connection&);
+
+ // Functions.
+ //
+ const functions_type&
+ functions () const
+ {
+ return functions_;
+ }
+
+ // Condition image.
+ //
+ cond_image_type&
+ cond_image ()
+ {
+ return cond_image_;
+ }
+
+ binding&
+ cond_image_binding ()
+ {
+ return cond_image_binding_;
+ }
+
+ // Data image.
+ //
+ data_image_type&
+ data_image ()
+ {
+ return data_image_;
+ }
+
+ binding&
+ data_image_binding ()
+ {
+ return data_image_binding_;
+ }
+
+ my_bool*
+ data_image_error ()
+ {
+ return data_image_error_;
+ }
+
+ //
+ // Statements.
+ //
+
+ insert_statement_type&
+ insert_one_statement ()
+ {
+ if (insert_one_ == 0)
+ insert_one_.reset (
+ new (details::shared) insert_statement_type (
+ conn_, traits::insert_one_statement, data_image_binding_));
+
+ return *insert_one_;
+ }
+
+ select_statement_type&
+ select_all_statement ()
+ {
+ if (select_all_ == 0)
+ select_all_.reset (
+ new (details::shared) select_statement_type (
+ conn_,
+ traits::select_all_statement,
+ cond_image_binding_,
+ data_image_binding_));
+
+ return *select_all_;
+ }
+
+ delete_statement_type&
+ delete_all_statement ()
+ {
+ if (delete_all_ == 0)
+ delete_all_.reset (
+ new (details::shared) delete_statement_type (
+ conn_, traits::delete_all_statement, cond_image_binding_));
+
+ return *delete_all_;
+ }
+
+ private:
+ container_statements (const container_statements&);
+ container_statements& operator= (const container_statements&);
+
+ private:
+ connection& conn_;
+ functions_type functions_;
+
+ cond_image_type cond_image_;
+ binding cond_image_binding_;
+ MYSQL_BIND cond_image_bind_[traits::cond_column_count];
+
+ data_image_type data_image_;
+ binding data_image_binding_;
+ MYSQL_BIND data_image_bind_[traits::data_column_count];
+ my_bool data_image_error_[traits::data_column_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_;
+ };
+ }
+}
+
+#include <odb/mysql/container-statements.txx>
+
+#include <odb/post.hxx>
+
+#endif // ODB_MYSQL_CONTAINER_STATEMENTS_HXX
diff --git a/odb/mysql/container-statements.txx b/odb/mysql/container-statements.txx
new file mode 100644
index 0000000..a4bb7e5
--- /dev/null
+++ b/odb/mysql/container-statements.txx
@@ -0,0 +1,35 @@
+// file : odb/mysql/container-statements.txx
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// license : GNU GPL v2; see accompanying LICENSE file
+
+#include <cstddef> // std::size_t
+#include <cstring> // std::memset
+
+namespace odb
+{
+ namespace mysql
+ {
+ // container_statements
+ //
+
+ template <typename T>
+ container_statements<T>::
+ container_statements (connection& conn)
+ : conn_ (conn),
+ functions_ (this,
+ &traits::insert_one,
+ &traits::load_all,
+ &traits::delete_all),
+ cond_image_binding_ (cond_image_bind_, traits::cond_column_count),
+ data_image_binding_ (data_image_bind_, 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 (data_image_error_, 0, sizeof (data_image_error_));
+
+ for (std::size_t i (0); i < traits::data_column_count; ++i)
+ data_image_bind_[i].error = data_image_error_ + i;
+ }
+ }
+}
diff --git a/odb/mysql/forward.hxx b/odb/mysql/forward.hxx
index 095b857..3b36780 100644
--- a/odb/mysql/forward.hxx
+++ b/odb/mysql/forward.hxx
@@ -16,11 +16,15 @@ namespace odb
class connection;
class connection_factory;
class transaction;
- class binding;
class query;
+ // Implementation details.
+ //
template <typename T>
class object_statements;
+
+ template <typename T>
+ class container_statements;
}
}
diff --git a/odb/mysql/makefile b/odb/mysql/makefile
index 8bec46b..53d2302 100644
--- a/odb/mysql/makefile
+++ b/odb/mysql/makefile
@@ -5,15 +5,16 @@
include $(dir $(lastword $(MAKEFILE_LIST)))../../build/bootstrap.make
-cxx := \
-connection.cxx \
-connection-factory.cxx \
-database.cxx \
-exceptions.cxx \
-transaction.cxx \
-transaction-impl.cxx \
-statement.cxx \
-query.cxx \
+cxx := \
+connection.cxx \
+connection-factory.cxx \
+database.cxx \
+exceptions.cxx \
+object-statements.cxx \
+transaction.cxx \
+transaction-impl.cxx \
+statement.cxx \
+query.cxx \
traits.cxx
cli_tun := details/options.cli
diff --git a/odb/mysql/object-statements.cxx b/odb/mysql/object-statements.cxx
new file mode 100644
index 0000000..f732fb8
--- /dev/null
+++ b/odb/mysql/object-statements.cxx
@@ -0,0 +1,17 @@
+// file : odb/mysql/object-statements.cxx
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// license : GNU GPL v2; see accompanying LICENSE file
+
+#include <odb/mysql/object-statements.hxx>
+
+namespace odb
+{
+ namespace mysql
+ {
+ object_statements_base::
+ ~object_statements_base ()
+ {
+ }
+ }
+}
diff --git a/odb/mysql/object-statements.hxx b/odb/mysql/object-statements.hxx
new file mode 100644
index 0000000..a16af88
--- /dev/null
+++ b/odb/mysql/object-statements.hxx
@@ -0,0 +1,185 @@
+// file : odb/mysql/object-statements.hxx
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// license : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_MYSQL_OBJECT_STATEMENTS_HXX
+#define ODB_MYSQL_OBJECT_STATEMENTS_HXX
+
+#include <odb/pre.hxx>
+
+#include <odb/forward.hxx>
+#include <odb/traits.hxx>
+
+#include <odb/mysql/mysql.hxx>
+#include <odb/mysql/version.hxx>
+#include <odb/mysql/statement.hxx>
+
+#include <odb/details/shared-ptr.hxx>
+
+#include <odb/mysql/details/export.hxx>
+
+namespace odb
+{
+ namespace mysql
+ {
+ class connection;
+
+ class LIBODB_MYSQL_EXPORT object_statements_base:
+ public details::shared_base
+ {
+ public:
+ virtual
+ ~object_statements_base ();
+
+ protected:
+ object_statements_base (connection& conn)
+ : conn_ (conn)
+ {
+ }
+
+ protected:
+ connection& conn_;
+ };
+
+ template <typename T>
+ class object_statements: public object_statements_base
+ {
+ public:
+ typedef odb::object_traits<T> object_traits;
+ typedef typename object_traits::image_type image_type;
+ typedef typename object_traits::id_image_type id_image_type;
+
+ typedef
+ typename object_traits::container_statement_cache_type
+ container_statement_cache_type;
+
+ typedef mysql::insert_statement persist_statement_type;
+ typedef mysql::select_statement find_statement_type;
+ typedef mysql::update_statement update_statement_type;
+ typedef mysql::delete_statement erase_statement_type;
+
+ object_statements (connection&);
+
+ image_type&
+ image ()
+ {
+ return image_;
+ }
+
+ binding&
+ image_binding ()
+ {
+ return image_binding_;
+ }
+
+ my_bool*
+ image_error ()
+ {
+ return image_error_;
+ }
+
+ id_image_type&
+ id_image ()
+ {
+ return id_image_;
+ }
+
+ binding&
+ id_image_binding ()
+ {
+ return id_image_binding_;
+ }
+
+ persist_statement_type&
+ persist_statement ()
+ {
+ if (persist_ == 0)
+ persist_.reset (
+ new (details::shared) persist_statement_type (
+ conn_, object_traits::persist_statement, image_binding_));
+
+ return *persist_;
+ }
+
+ find_statement_type&
+ find_statement ()
+ {
+ if (find_ == 0)
+ find_.reset (
+ new (details::shared) find_statement_type (
+ conn_,
+ object_traits::find_statement,
+ id_image_binding_,
+ image_binding_));
+
+ return *find_;
+ }
+
+ update_statement_type&
+ update_statement ()
+ {
+ if (update_ == 0)
+ update_.reset (
+ new (details::shared) update_statement_type (
+ conn_,
+ object_traits::update_statement,
+ id_image_binding_,
+ image_binding_));
+
+ return *update_;
+ }
+
+ erase_statement_type&
+ erase_statement ()
+ {
+ if (erase_ == 0)
+ erase_.reset (
+ new (details::shared) erase_statement_type (
+ conn_,
+ object_traits::erase_statement,
+ id_image_binding_));
+
+ return *erase_;
+ }
+
+ // Container statement cache.
+ //
+ container_statement_cache_type&
+ container_statment_cache ()
+ {
+ return container_statement_cache_;
+ }
+
+ private:
+ object_statements (const object_statements&);
+ object_statements& operator= (const object_statements&);
+
+ private:
+ container_statement_cache_type container_statement_cache_;
+
+ // The last element is the id parameter. The update statement
+ // depends on this being one contiguous arrays.
+ //
+ MYSQL_BIND image_bind_[object_traits::column_count + 1];
+
+ image_type image_;
+ my_bool image_error_[object_traits::column_count];
+ binding image_binding_;
+
+ id_image_type id_image_;
+ binding id_image_binding_;
+
+ details::shared_ptr<persist_statement_type> persist_;
+ details::shared_ptr<find_statement_type> find_;
+ details::shared_ptr<update_statement_type> update_;
+ details::shared_ptr<erase_statement_type> erase_;
+ };
+ }
+}
+
+#include <odb/mysql/object-statements.txx>
+
+#include <odb/post.hxx>
+
+#endif // ODB_MYSQL_OBJECT_STATEMENTS_HXX
diff --git a/odb/mysql/statement.txx b/odb/mysql/object-statements.txx
index 95579b4..8b2dad1 100644
--- a/odb/mysql/statement.txx
+++ b/odb/mysql/object-statements.txx
@@ -1,4 +1,4 @@
-// file : odb/mysql/statement.txx
+// file : odb/mysql/object-statements.txx
// author : Boris Kolpackov <boris@codesynthesis.com>
// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
// license : GNU GPL v2; see accompanying LICENSE file
@@ -17,6 +17,7 @@ namespace odb
object_statements<T>::
object_statements (connection& conn)
: object_statements_base (conn),
+ container_statement_cache_ (conn),
image_binding_ (image_bind_, object_traits::column_count),
id_image_binding_ (image_bind_ + object_traits::column_count, 1)
{
diff --git a/odb/mysql/query.cxx b/odb/mysql/query.cxx
index b159c2a..2aefeea 100644
--- a/odb/mysql/query.cxx
+++ b/odb/mysql/query.cxx
@@ -25,7 +25,8 @@ namespace odb
query (const query& q)
: clause_ (q.clause_),
parameters_ (q.parameters_),
- binding_ (q.binding_)
+ bind_ (q.bind_),
+ binding_ (0, 0)
{
}
@@ -36,7 +37,7 @@ namespace odb
{
clause_ = q.clause_;
parameters_ = q.parameters_;
- binding_ = q.binding_;
+ bind_ = q.bind_;
}
return *this;
@@ -56,8 +57,8 @@ namespace odb
parameters_.insert (
parameters_.end (), q.parameters_.begin (), q.parameters_.end ());
- binding_.insert (
- binding_.end (), q.binding_.begin (), q.binding_.end ());
+ bind_.insert (
+ bind_.end (), q.bind_.begin (), q.bind_.end ());
return *this;
}
@@ -73,23 +74,32 @@ namespace odb
clause_ += '?';
parameters_.push_back (p);
- binding_.push_back (MYSQL_BIND ());
- MYSQL_BIND* b (&binding_.back ());
+ bind_.push_back (MYSQL_BIND ());
+ MYSQL_BIND* b (&bind_.back ());
memset (b, 0, sizeof (MYSQL_BIND));
- if (!p->reference ())
- p->bind (b);
+ p->bind (b);
}
- MYSQL_BIND* query::
+ binding& query::
parameters () const
{
size_t n (parameters_.size ());
+ binding& r (const_cast<binding&> (binding_));
if (n == 0)
- return 0;
+ return r; // r.bind and r.count should be 0.
- MYSQL_BIND* b (const_cast<MYSQL_BIND*> (&binding_[0]));
+ MYSQL_BIND* b (const_cast<MYSQL_BIND*> (&bind_[0]));
+
+ bool inc_ver (false);
+
+ if (r.bind != b || r.count != bind_.size ())
+ {
+ r.bind = b;
+ r.count = bind_.size ();
+ inc_ver = true;
+ }
for (size_t i (0); i < n; ++i)
{
@@ -97,12 +107,18 @@ namespace odb
if (p.reference ())
{
- p.init ();
- p.bind (b + i);
+ if (p.init ())
+ {
+ p.bind (b + i);
+ inc_ver = true;
+ }
}
}
- return b;
+ if (inc_ver)
+ r.version++;
+
+ return r;
}
std::string query::
diff --git a/odb/mysql/query.hxx b/odb/mysql/query.hxx
index e0a6884..9deb6a7 100644
--- a/odb/mysql/query.hxx
+++ b/odb/mysql/query.hxx
@@ -18,6 +18,7 @@
#include <odb/mysql/version.hxx>
#include <odb/mysql/forward.hxx>
#include <odb/mysql/traits.hxx>
+#include <odb/mysql/binding.hxx>
#include <odb/details/buffer.hxx>
#include <odb/details/shared-ptr.hxx>
@@ -59,7 +60,7 @@ namespace odb
return value_ != 0;
}
- virtual void
+ virtual bool
init () = 0;
virtual void
@@ -84,18 +85,20 @@ namespace odb
{
public:
query ()
+ : binding_ (0, 0)
{
}
explicit
query (const std::string& q)
- : clause_ (q)
+ : clause_ (q), binding_ (0, 0)
{
}
template <typename T>
explicit
query (val_bind<T> v)
+ : binding_ (0, 0)
{
append<T, type_traits<T>::db_type_id> (v);
}
@@ -103,6 +106,7 @@ namespace odb
template <typename T>
explicit
query (ref_bind<T> r)
+ : binding_ (0, 0)
{
append<T, type_traits<T>::db_type_id> (r);
}
@@ -116,7 +120,7 @@ namespace odb
operator= (const query&);
public:
- MYSQL_BIND*
+ binding&
parameters () const;
std::string
@@ -187,7 +191,8 @@ namespace odb
std::string clause_;
parameters_type parameters_;
- std::vector<MYSQL_BIND> binding_;
+ std::vector<MYSQL_BIND> bind_;
+ binding binding_;
};
inline query
@@ -1005,10 +1010,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1037,10 +1043,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1071,10 +1078,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1103,10 +1111,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1138,10 +1147,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1170,10 +1180,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1204,10 +1215,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1236,10 +1248,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1271,10 +1284,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1305,10 +1319,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1339,10 +1354,10 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
- init (*static_cast<const T*> (value_));
+ return init (*static_cast<const T*> (value_));
}
virtual void
@@ -1355,14 +1370,15 @@ namespace odb
}
private:
- void
+ bool
init (const T& v)
{
bool dummy;
- std::size_t size;
+ std::size_t size, cap (buffer_.capacity ());
value_traits<T, details::buffer, id_decimal>::set_image (
buffer_, size, dummy, v);
size_ = static_cast<unsigned long> (size);
+ return cap != buffer_.capacity ();
}
private:
@@ -1378,10 +1394,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1411,10 +1428,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1444,10 +1462,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1477,10 +1496,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1511,10 +1531,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1545,10 +1566,10 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
- init (*static_cast<const T*> (value_));
+ return init (*static_cast<const T*> (value_));
}
virtual void
@@ -1561,14 +1582,15 @@ namespace odb
}
private:
- void
+ bool
init (const T& v)
{
bool dummy;
- std::size_t size;
+ std::size_t size, cap (buffer_.capacity ());
value_traits<T, details::buffer, id_string>::set_image (
buffer_, size, dummy, v);
size_ = static_cast<unsigned long> (size);
+ return cap != buffer_.capacity ();
}
private:
@@ -1584,10 +1606,10 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
- init (*static_cast<const T*> (value_));
+ return init (*static_cast<const T*> (value_));
}
virtual void
@@ -1600,14 +1622,15 @@ namespace odb
}
private:
- void
+ bool
init (const T& v)
{
bool dummy;
- std::size_t size;
+ std::size_t size, cap (buffer_.capacity ());
value_traits<T, details::buffer, id_blob>::set_image (
buffer_, size, dummy, v);
size_ = static_cast<unsigned long> (size);
+ return cap != buffer_.capacity ();
}
private:
@@ -1623,10 +1646,11 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
init (*static_cast<const T*> (value_));
+ return false;
}
virtual void
@@ -1664,10 +1688,10 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
- init (*static_cast<const T*> (value_));
+ return init (*static_cast<const T*> (value_));
}
virtual void
@@ -1680,14 +1704,15 @@ namespace odb
}
private:
- void
+ bool
init (const T& v)
{
bool dummy;
- std::size_t size;
+ std::size_t size, cap (buffer_.capacity ());
value_traits<T, details::buffer, id_enum>::set_image (
buffer_, size, dummy, v);
size_ = static_cast<unsigned long> (size);
+ return cap != buffer_.capacity ();
}
private:
@@ -1703,10 +1728,10 @@ namespace odb
query_param_impl (ref_bind<T> r) : query_param (&r.ref) {}
query_param_impl (val_bind<T> v) : query_param (0) {init (v.val);}
- virtual void
+ virtual bool
init ()
{
- init (*static_cast<const T*> (value_));
+ return init (*static_cast<const T*> (value_));
}
virtual void
@@ -1719,14 +1744,15 @@ namespace odb
}
private:
- void
+ bool
init (const T& v)
{
bool dummy;
- std::size_t size;
+ std::size_t size, cap (buffer_.capacity ());
value_traits<T, details::buffer, id_set>::set_image (
buffer_, size, dummy, v);
size_ = static_cast<unsigned long> (size);
+ return cap != buffer_.capacity ();
}
private:
diff --git a/odb/mysql/query.txx b/odb/mysql/query.txx
index deafad0..5cc1fc1 100644
--- a/odb/mysql/query.txx
+++ b/odb/mysql/query.txx
@@ -13,7 +13,7 @@ namespace odb
template <database_type_id ID>
query::
query (const query_column<bool, ID>& c)
- : clause_ (c.name ())
+ : clause_ (c.name ()), binding_ (0, 0)
{
// Cannot use IS TRUE here since database type can be a non-
// integral type.
diff --git a/odb/mysql/result.hxx b/odb/mysql/result.hxx
index 8c2469f..fe4fcfb 100644
--- a/odb/mysql/result.hxx
+++ b/odb/mysql/result.hxx
@@ -31,7 +31,7 @@ namespace odb
virtual
~result_impl ();
- result_impl (details::shared_ptr<query_statement> statement,
+ result_impl (details::shared_ptr<select_statement> statement,
object_statements<T>& statements);
virtual void
@@ -49,7 +49,7 @@ namespace odb
using odb::result_impl<T>::current;
private:
- details::shared_ptr<query_statement> statement_;
+ details::shared_ptr<select_statement> statement_;
object_statements<T>& statements_;
};
}
diff --git a/odb/mysql/result.txx b/odb/mysql/result.txx
index ca27dd1..f06ee46 100644
--- a/odb/mysql/result.txx
+++ b/odb/mysql/result.txx
@@ -15,7 +15,7 @@ namespace odb
template <typename T>
result_impl<T>::
- result_impl (details::shared_ptr<query_statement> statement,
+ result_impl (details::shared_ptr<select_statement> statement,
object_statements<T>& statements)
: statement_ (statement), statements_ (statements)
{
@@ -35,11 +35,11 @@ namespace odb
next ()
{
this->current (pointer_type ());
- query_statement::result r (statement_->fetch ());
+ select_statement::result r (statement_->fetch ());
switch (r)
{
- case query_statement::truncated:
+ case select_statement::truncated:
{
typename traits::image_type& i (statements_.image ());
@@ -52,11 +52,11 @@ namespace odb
}
// Fall throught.
}
- case query_statement::success:
+ case select_statement::success:
{
break;
}
- case query_statement::no_data:
+ case select_statement::no_data:
{
this->end_ = true;
break;
diff --git a/odb/mysql/statement-cache.hxx b/odb/mysql/statement-cache.hxx
new file mode 100644
index 0000000..480f30d
--- /dev/null
+++ b/odb/mysql/statement-cache.hxx
@@ -0,0 +1,83 @@
+// file : odb/mysql/statement-cache.hxx
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// license : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_MYSQL_STATEMENT_CACHE_HXX
+#define ODB_MYSQL_STATEMENT_CACHE_HXX
+
+#include <odb/pre.hxx>
+
+#include <map>
+#include <typeinfo>
+
+#include <odb/forward.hxx>
+
+#include <odb/mysql/version.hxx>
+#include <odb/mysql/object-statements.hxx>
+
+#include <odb/details/shared-ptr.hxx>
+
+#include <odb/mysql/details/export.hxx>
+
+namespace odb
+{
+ namespace mysql
+ {
+ class connection;
+
+ struct LIBODB_MYSQL_EXPORT type_info_comparator
+ {
+ bool
+ operator() (const std::type_info* x, const std::type_info* y) const
+ {
+ // XL C++ on AIX has buggy type_info::before() in that
+ // it returns true for two different type_info objects
+ // that happened to be for the same type.
+ //
+#if defined(__xlC__) && defined(_AIX)
+ return *x != *y && x->before (*y);
+#else
+ return x->before (*y);
+#endif
+ }
+ };
+
+ class LIBODB_MYSQL_EXPORT statement_cache
+ {
+ public:
+ statement_cache (connection& conn)
+ : conn_ (conn)
+ {
+ }
+
+ template <typename T>
+ object_statements<T>&
+ find ()
+ {
+ map::iterator i (map_.find (&typeid (T)));
+
+ if (i != map_.end ())
+ return static_cast<object_statements<T>&> (*i->second);
+
+ details::shared_ptr<object_statements<T> > p (
+ new (details::shared) object_statements<T> (conn_));
+
+ map_.insert (map::value_type (&typeid (T), p));
+ return *p;
+ }
+
+ private:
+ typedef std::map<const std::type_info*,
+ details::shared_ptr<object_statements_base>,
+ type_info_comparator> map;
+
+ connection& conn_;
+ map map_;
+ };
+ }
+}
+
+#include <odb/post.hxx>
+
+#endif // ODB_MYSQL_STATEMENT_CACHE_HXX
diff --git a/odb/mysql/statement.cxx b/odb/mysql/statement.cxx
index 6193f39..0f21917 100644
--- a/odb/mysql/statement.cxx
+++ b/odb/mysql/statement.cxx
@@ -35,15 +35,13 @@ namespace odb
{
}
- // query_statement
+ // select_statement
//
- query_statement::
- ~query_statement ()
+ select_statement::
+ ~select_statement ()
{
- statement* as (conn_.active ());
-
- if (cached_ || as == this)
+ if (cached_ || conn_.active () == this)
{
try
{
@@ -53,23 +51,21 @@ namespace odb
{
}
}
-
- if (as == this)
- conn_.active (0);
}
- query_statement::
- query_statement (connection& conn,
- const string& s,
- binding& image,
- MYSQL_BIND* parameters)
+ select_statement::
+ select_statement (connection& conn,
+ const string& s,
+ binding& cond,
+ binding& data)
: statement (conn),
end_ (false),
cached_ (false),
rows_ (0),
- image_ (image),
- image_version_ (0),
- parameters_ (parameters)
+ cond_ (cond),
+ cond_version_ (0),
+ data_ (data),
+ data_version_ (0)
{
if (statement* a = conn_.active ())
a->cancel ();
@@ -78,7 +74,7 @@ namespace odb
throw database_exception (stmt_);
}
- void query_statement::
+ void select_statement::
execute ()
{
if (statement* a = conn_.active ())
@@ -93,20 +89,20 @@ namespace odb
if (mysql_stmt_reset (stmt_))
throw database_exception (stmt_);
- if (image_version_ != image_.version)
+ if (cond_version_ != cond_.version)
{
- if (mysql_stmt_bind_result (stmt_, image_.bind))
+ if (mysql_stmt_bind_param (stmt_, cond_.bind))
throw database_exception (stmt_);
- image_version_ = image_.version;
+ cond_version_ = cond_.version;
}
- if (parameters_ != 0)
+ if (data_version_ != data_.version)
{
- // @@ versioning
- //
- if (mysql_stmt_bind_param (stmt_, parameters_))
+ if (mysql_stmt_bind_result (stmt_, data_.bind))
throw database_exception (stmt_);
+
+ data_version_ = data_.version;
}
if (mysql_stmt_execute (stmt_))
@@ -122,7 +118,7 @@ namespace odb
conn_.active (this);
}
- void query_statement::
+ void select_statement::
cache ()
{
if (!cached_)
@@ -139,7 +135,7 @@ namespace odb
}
}
- std::size_t query_statement::
+ std::size_t select_statement::
result_size ()
{
if (!cached_)
@@ -151,18 +147,18 @@ namespace odb
return rows_ + static_cast<std::size_t> (mysql_stmt_num_rows (stmt_));
}
- query_statement::result query_statement::
+ select_statement::result select_statement::
fetch ()
{
- // If the result was cached the image can grow between calls
+ // If the result was cached the data image can grow between calls
// to fetch() as a result of other statements execution.
//
- if (cached_ && image_version_ != image_.version)
+ if (cached_ && data_version_ != data_.version)
{
- if (mysql_stmt_bind_result (stmt_, image_.bind))
+ if (mysql_stmt_bind_result (stmt_, data_.bind))
throw database_exception (stmt_);
- image_version_ = image_.version;
+ data_version_ = data_.version;
}
int r (mysql_stmt_fetch (stmt_));
@@ -195,25 +191,25 @@ namespace odb
}
}
- void query_statement::
+ void select_statement::
refetch ()
{
// Re-fetch columns that were truncated.
//
- for (size_t i (0); i < image_.count; ++i)
+ for (size_t i (0); i < data_.count; ++i)
{
- if (*image_.bind[i].error)
+ if (*data_.bind[i].error)
{
- *image_.bind[i].error = 0;
+ *data_.bind[i].error = 0;
if (mysql_stmt_fetch_column (
- stmt_, image_.bind + i, static_cast<unsigned int> (i), 0))
+ stmt_, data_.bind + i, static_cast<unsigned int> (i), 0))
throw database_exception (stmt_);
}
}
}
- void query_statement::
+ void select_statement::
free_result ()
{
end_ = true;
@@ -222,30 +218,33 @@ namespace odb
if (mysql_stmt_free_result (stmt_))
throw database_exception (stmt_);
+
+ if (conn_.active () == this)
+ conn_.active (0);
}
- void query_statement::
+ void select_statement::
cancel ()
{
// If we cached the result, don't free it just yet.
//
if (!cached_)
free_result ();
-
- conn_.active (0);
+ else
+ conn_.active (0);
}
- // persist_statement
+ // insert_statement
//
- persist_statement::
- ~persist_statement ()
+ insert_statement::
+ ~insert_statement ()
{
}
- persist_statement::
- persist_statement (connection& conn, const string& s, binding& image)
- : statement (conn), image_ (image), version_ (0)
+ insert_statement::
+ insert_statement (connection& conn, const string& s, binding& data)
+ : statement (conn), data_ (data), data_version_ (0)
{
if (statement* a = conn_.active ())
a->cancel ();
@@ -254,7 +253,7 @@ namespace odb
throw database_exception (stmt_);
}
- void persist_statement::
+ bool insert_statement::
execute ()
{
if (statement* a = conn_.active ())
@@ -263,12 +262,12 @@ namespace odb
if (mysql_stmt_reset (stmt_))
throw database_exception (stmt_);
- if (version_ != image_.version)
+ if (data_version_ != data_.version)
{
- if (mysql_stmt_bind_param (stmt_, image_.bind))
+ if (mysql_stmt_bind_param (stmt_, data_.bind))
throw database_exception (stmt_);
- version_ = image_.version;
+ data_version_ = data_.version;
}
if (mysql_stmt_execute (stmt_))
@@ -277,7 +276,7 @@ namespace odb
{
case ER_DUP_ENTRY:
{
- throw object_already_persistent ();
+ return false;
}
case ER_LOCK_DEADLOCK:
{
@@ -289,139 +288,10 @@ namespace odb
}
}
}
- }
-
- // find_statement
- //
-
- find_statement::
- ~find_statement ()
- {
- if (conn_.active () == this)
- {
- try
- {
- free_result ();
- }
- catch (...)
- {
- }
- }
- }
-
- find_statement::
- find_statement (connection& conn,
- const string& s,
- binding& id,
- binding& image)
- : statement (conn),
- id_ (id),
- id_version_ (0),
- image_ (image),
- image_version_ (0)
- {
- if (statement* a = conn_.active ())
- a->cancel ();
-
- if (mysql_stmt_prepare (stmt_, s.c_str (), s.size ()) != 0)
- throw database_exception (stmt_);
- }
-
- find_statement::result find_statement::
- execute ()
- {
- if (statement* a = conn_.active ())
- a->cancel ();
-
- if (mysql_stmt_reset (stmt_))
- throw database_exception (stmt_);
-
- if (id_version_ != id_.version)
- {
- if (mysql_stmt_bind_param (stmt_, id_.bind))
- throw database_exception (stmt_);
-
- id_version_ = id_.version;
- }
-
- if (image_version_ != image_.version)
- {
- if (mysql_stmt_bind_result (stmt_, image_.bind))
- throw database_exception (stmt_);
-
- image_version_ = image_.version;
- }
-
- if (mysql_stmt_execute (stmt_))
- {
- unsigned int e (mysql_stmt_errno (stmt_));
-
- if (e == ER_LOCK_DEADLOCK)
- throw deadlock ();
- else
- throw database_exception (stmt_);
- }
-
- conn_.active (this);
-
- int r (mysql_stmt_fetch (stmt_));
-
- switch (r)
- {
- case 0:
- {
- return success;
- }
- case MYSQL_NO_DATA:
- {
- free_result ();
- return no_data;
- }
- case MYSQL_DATA_TRUNCATED:
- {
- return truncated;
- }
- default:
- {
- throw database_exception (stmt_);
- }
- }
- }
- void find_statement::
- refetch ()
- {
- // Re-fetch columns that were truncated.
- //
- for (size_t i (0); i < image_.count; ++i)
- {
- if (*image_.bind[i].error)
- {
- *image_.bind[i].error = 0;
-
- if (mysql_stmt_fetch_column (
- stmt_, image_.bind + i, static_cast<unsigned int> (i), 0))
- throw database_exception (stmt_);
- }
- }
+ return true;
}
- void find_statement::
- free_result ()
- {
- if (mysql_stmt_free_result (stmt_))
- throw database_exception (stmt_);
-
- conn_.active (0);
- }
-
- void find_statement::
- cancel ()
- {
- free_result ();
- }
-
-
// update_statement
//
@@ -490,17 +360,17 @@ namespace odb
throw database_exception (stmt_);
}
- // erase_statement
+ // delete_statement
//
- erase_statement::
- ~erase_statement ()
+ delete_statement::
+ ~delete_statement ()
{
}
- erase_statement::
- erase_statement (connection& conn, const string& s, binding& id)
- : statement (conn), id_ (id), version_ (0)
+ delete_statement::
+ delete_statement (connection& conn, const string& s, binding& cond)
+ : statement (conn), cond_ (cond), cond_version_ (0)
{
if (statement* a = conn_.active ())
a->cancel ();
@@ -509,7 +379,7 @@ namespace odb
throw database_exception (stmt_);
}
- void erase_statement::
+ unsigned long long delete_statement::
execute ()
{
if (statement* a = conn_.active ())
@@ -518,12 +388,12 @@ namespace odb
if (mysql_stmt_reset (stmt_))
throw database_exception (stmt_);
- if (version_ != id_.version)
+ if (cond_version_ != cond_.version)
{
- if (mysql_stmt_bind_param (stmt_, id_.bind))
+ if (mysql_stmt_bind_param (stmt_, cond_.bind))
throw database_exception (stmt_);
- version_ = id_.version;
+ cond_version_ = cond_.version;
}
if (mysql_stmt_execute (stmt_))
@@ -538,21 +408,10 @@ namespace odb
my_ulonglong r (mysql_stmt_affected_rows (stmt_));
- if (r > 0)
- return;
-
- if (r == 0)
- throw object_not_persistent ();
- else
+ if (r == static_cast<my_ulonglong> (-1))
throw database_exception (stmt_);
- }
-
- // object_statements_base
- //
- object_statements_base::
- ~object_statements_base ()
- {
+ return static_cast<unsigned long long> (r);
}
}
}
diff --git a/odb/mysql/statement.hxx b/odb/mysql/statement.hxx
index bdeee7a..3df86c0 100644
--- a/odb/mysql/statement.hxx
+++ b/odb/mysql/statement.hxx
@@ -8,16 +8,14 @@
#include <odb/pre.hxx>
-#include <map>
#include <string>
#include <cstddef> // std::size_t
-#include <typeinfo>
#include <odb/forward.hxx>
-#include <odb/traits.hxx>
#include <odb/mysql/mysql.hxx>
#include <odb/mysql/version.hxx>
+#include <odb/mysql/binding.hxx>
#include <odb/details/shared-ptr.hxx>
@@ -29,23 +27,6 @@ namespace odb
{
class connection;
- class LIBODB_MYSQL_EXPORT binding
- {
- public:
- binding (MYSQL_BIND* b, std::size_t n)
- : bind (b), count (n), version (0)
- {
- }
-
- MYSQL_BIND* bind;
- std::size_t count;
- std::size_t version;
-
- private:
- binding (const binding&);
- binding& operator= (const binding&);
- };
-
class LIBODB_MYSQL_EXPORT statement: public details::shared_base
{
public:
@@ -66,16 +47,16 @@ namespace odb
MYSQL_STMT* stmt_;
};
- class LIBODB_MYSQL_EXPORT query_statement: public statement
+ class LIBODB_MYSQL_EXPORT select_statement: public statement
{
public:
virtual
- ~query_statement ();
+ ~select_statement ();
- query_statement (connection& conn,
- const std::string& statement,
- binding& image,
- MYSQL_BIND* parameters);
+ select_statement (connection& conn,
+ const std::string& statement,
+ binding& cond,
+ binding& data);
enum result
{
success,
@@ -105,90 +86,51 @@ namespace odb
cancel ();
private:
- query_statement (const query_statement&);
- query_statement& operator= (const query_statement&);
+ select_statement (const select_statement&);
+ select_statement& operator= (const select_statement&);
private:
bool end_;
bool cached_;
std::size_t rows_;
- binding& image_;
- std::size_t image_version_;
+ binding& cond_;
+ std::size_t cond_version_;
- MYSQL_BIND* parameters_;
+ binding& data_;
+ std::size_t data_version_;
};
- class LIBODB_MYSQL_EXPORT persist_statement: public statement
+ class LIBODB_MYSQL_EXPORT insert_statement: public statement
{
public:
virtual
- ~persist_statement ();
+ ~insert_statement ();
- persist_statement (connection& conn,
- const std::string& statement,
- binding& image);
+ insert_statement (connection& conn,
+ const std::string& statement,
+ binding& data);
- void
- execute ();
+ // Return true if successful and false if the row is a duplicate.
+ // All other errors are reported by throwing exceptions.
+ //
+ bool
+ execute ();
unsigned long long
id ()
{
- return mysql_stmt_insert_id (stmt_);
+ return static_cast<unsigned long long> (
+ mysql_stmt_insert_id (stmt_));
}
private:
- persist_statement (const persist_statement&);
- persist_statement& operator= (const persist_statement&);
+ insert_statement (const insert_statement&);
+ insert_statement& operator= (const insert_statement&);
private:
- binding& image_;
- std::size_t version_;
- };
-
- class LIBODB_MYSQL_EXPORT find_statement: public statement
- {
- public:
- virtual
- ~find_statement ();
-
- find_statement (connection& conn,
- const std::string& statement,
- binding& id,
- binding& image);
- enum result
- {
- success,
- no_data,
- truncated
- };
-
- // You are expected to call free_result() if this function
- // returns success or truncated.
- //
- result
- execute ();
-
- void
- refetch ();
-
- void
- free_result ();
-
- void
- cancel ();
-
- private:
- find_statement (const find_statement&);
- find_statement& operator= (const find_statement&);
-
- private:
- binding& id_;
- std::size_t id_version_;
-
- binding& image_;
- std::size_t image_version_;
+ binding& data_;
+ std::size_t data_version_;
};
class LIBODB_MYSQL_EXPORT update_statement: public statement
@@ -216,222 +158,30 @@ namespace odb
std::size_t image_version_;
};
- class LIBODB_MYSQL_EXPORT erase_statement: public statement
+ class LIBODB_MYSQL_EXPORT delete_statement: public statement
{
public:
virtual
- ~erase_statement ();
+ ~delete_statement ();
- erase_statement (connection& conn,
- const std::string& statement,
- binding& id);
+ delete_statement (connection& conn,
+ const std::string& statement,
+ binding& cond);
- void
+ unsigned long long
execute ();
private:
- erase_statement (const erase_statement&);
- erase_statement& operator= (const erase_statement&);
-
- private:
- binding& id_;
- std::size_t version_;
- };
-
- // Statement cache.
- //
-
- class LIBODB_MYSQL_EXPORT object_statements_base:
- public details::shared_base
- {
- public:
- virtual
- ~object_statements_base ();
-
- protected:
- object_statements_base (connection& conn)
- : conn_ (conn)
- {
- }
-
- protected:
- connection& conn_;
- };
-
- template <typename T>
- class object_statements: public object_statements_base
- {
- public:
- typedef odb::object_traits<T> object_traits;
- typedef typename object_traits::image_type image_type;
- typedef typename object_traits::id_image_type id_image_type;
-
- typedef mysql::persist_statement persist_statement_type;
- typedef mysql::find_statement find_statement_type;
- typedef mysql::update_statement update_statement_type;
- typedef mysql::erase_statement erase_statement_type;
-
- object_statements (connection&);
-
- image_type&
- image ()
- {
- return image_;
- }
-
- binding&
- image_binding ()
- {
- return image_binding_;
- }
-
- my_bool*
- image_error ()
- {
- return image_error_;
- }
-
- id_image_type&
- id_image ()
- {
- return id_image_;
- }
-
- binding&
- id_image_binding ()
- {
- return id_image_binding_;
- }
-
- persist_statement_type&
- persist_statement ()
- {
- if (persist_ == 0)
- persist_.reset (
- new (details::shared) persist_statement_type (
- conn_, object_traits::persist_statement, image_binding_));
-
- return *persist_;
- }
-
- find_statement_type&
- find_statement ()
- {
- if (find_ == 0)
- find_.reset (
- new (details::shared) find_statement_type (
- conn_,
- object_traits::find_statement,
- id_image_binding_,
- image_binding_));
-
- return *find_;
- }
-
- update_statement_type&
- update_statement ()
- {
- if (update_ == 0)
- update_.reset (
- new (details::shared) update_statement_type (
- conn_,
- object_traits::update_statement,
- id_image_binding_,
- image_binding_));
-
- return *update_;
- }
-
- erase_statement_type&
- erase_statement ()
- {
- if (erase_ == 0)
- erase_.reset (
- new (details::shared) erase_statement_type (
- conn_,
- object_traits::erase_statement,
- id_image_binding_));
-
- return *erase_;
- }
-
- private:
- object_statements (const object_statements&);
- object_statements& operator= (const object_statements&);
+ delete_statement (const delete_statement&);
+ delete_statement& operator= (const delete_statement&);
private:
- // The last element is the id parameter. The update statement
- // depends on this being one contiguous arrays.
- //
- MYSQL_BIND image_bind_[object_traits::column_count + 1];
-
- image_type image_;
- my_bool image_error_[object_traits::column_count];
- binding image_binding_;
-
- id_image_type id_image_;
- binding id_image_binding_;
-
- details::shared_ptr<persist_statement_type> persist_;
- details::shared_ptr<find_statement_type> find_;
- details::shared_ptr<update_statement_type> update_;
- details::shared_ptr<erase_statement_type> erase_;
- };
-
- struct LIBODB_MYSQL_EXPORT type_info_comparator
- {
- bool
- operator() (const std::type_info* x, const std::type_info* y) const
- {
- // XL C++ on AIX has buggy type_info::before() in that
- // it returns true for two different type_info objects
- // that happened to be for the same type.
- //
-#if defined(__xlC__) && defined(_AIX)
- return *x != *y && x->before (*y);
-#else
- return x->before (*y);
-#endif
- }
- };
-
- class LIBODB_MYSQL_EXPORT statement_cache
- {
- public:
- statement_cache (connection& conn)
- : conn_ (conn)
- {
- }
-
- template <typename T>
- object_statements<T>&
- find ()
- {
- map::iterator i (map_.find (&typeid (T)));
-
- if (i != map_.end ())
- return static_cast<object_statements<T>&> (*i->second);
-
- details::shared_ptr<object_statements<T> > p (
- new (details::shared) object_statements<T> (conn_));
-
- map_.insert (map::value_type (&typeid (T), p));
- return *p;
- }
-
- private:
- typedef std::map<const std::type_info*,
- details::shared_ptr<object_statements_base>,
- type_info_comparator> map;
-
- connection& conn_;
- map map_;
+ binding& cond_;
+ std::size_t cond_version_;
};
}
}
-#include <odb/mysql/statement.txx>
-
#include <odb/post.hxx>
#endif // ODB_MYSQL_STATEMENT_HXX
diff --git a/odb/mysql/transaction-impl.cxx b/odb/mysql/transaction-impl.cxx
index df41015..6348001 100644
--- a/odb/mysql/transaction-impl.cxx
+++ b/odb/mysql/transaction-impl.cxx
@@ -6,6 +6,7 @@
#include <odb/mysql/mysql.hxx>
#include <odb/mysql/database.hxx>
#include <odb/mysql/connection.hxx>
+#include <odb/mysql/statement.hxx>
#include <odb/mysql/exceptions.hxx>
#include <odb/mysql/transaction-impl.hxx>