Add support for container persistence

Generalize statements that were used for persisting objects to work for
both objects and containers. Implement a cache for container statements.

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>