container-statements.hxx   container-statements.hxx 
// file : odb/mysql/container-statements.hxx // file : odb/mysql/container-statements.hxx
// author : Boris Kolpackov <boris@codesynthesis.com> // author : Boris Kolpackov <boris@codesynthesis.com>
// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC // copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC
// license : GNU GPL v2; see accompanying LICENSE file // license : GNU GPL v2; see accompanying LICENSE file
#ifndef ODB_MYSQL_CONTAINER_STATEMENTS_HXX #ifndef ODB_MYSQL_CONTAINER_STATEMENTS_HXX
#define ODB_MYSQL_CONTAINER_STATEMENTS_HXX #define ODB_MYSQL_CONTAINER_STATEMENTS_HXX
#include <odb/pre.hxx> #include <odb/pre.hxx>
#include <cstddef> // std::size_t
#include <odb/forward.hxx> #include <odb/forward.hxx>
#include <odb/traits.hxx> #include <odb/traits.hxx>
#include <odb/mysql/mysql.hxx> #include <odb/mysql/mysql.hxx>
#include <odb/mysql/version.hxx> #include <odb/mysql/version.hxx>
#include <odb/mysql/statement.hxx> #include <odb/mysql/statement.hxx>
#include <odb/mysql/details/export.hxx> #include <odb/mysql/details/export.hxx>
namespace odb namespace odb
skipping to change at line 153 skipping to change at line 155
data_id_image_version_ = v; data_id_image_version_ = v;
} }
binding& binding&
data_image_binding () data_image_binding ()
{ {
return data_image_binding_; return data_image_binding_;
} }
my_bool* my_bool*
data_image_error () data_image_truncated ()
{ {
return data_image_error_; return data_image_truncated_;
} }
// //
// Statements. // Statements.
// //
insert_statement_type& insert_statement_type&
insert_one_statement () insert_one_statement ()
{ {
if (insert_one_ == 0) if (insert_one_ == 0)
skipping to change at line 219 skipping to change at line 221
std::size_t cond_image_version_; std::size_t cond_image_version_;
std::size_t cond_id_image_version_; std::size_t cond_id_image_version_;
binding cond_image_binding_; binding cond_image_binding_;
MYSQL_BIND cond_image_bind_[traits::cond_column_count]; MYSQL_BIND cond_image_bind_[traits::cond_column_count];
data_image_type data_image_; data_image_type data_image_;
std::size_t data_image_version_; std::size_t data_image_version_;
std::size_t data_id_image_version_; std::size_t data_id_image_version_;
binding data_image_binding_; binding data_image_binding_;
MYSQL_BIND data_image_bind_[traits::data_column_count]; MYSQL_BIND data_image_bind_[traits::data_column_count];
my_bool data_image_error_[traits::data_column_count]; my_bool data_image_truncated_[traits::data_column_count];
details::shared_ptr<insert_statement_type> insert_one_; details::shared_ptr<insert_statement_type> insert_one_;
details::shared_ptr<select_statement_type> select_all_; details::shared_ptr<select_statement_type> select_all_;
details::shared_ptr<delete_statement_type> delete_all_; details::shared_ptr<delete_statement_type> delete_all_;
}; };
} }
} }
#include <odb/mysql/container-statements.txx> #include <odb/mysql/container-statements.txx>
 End of changes. 4 change blocks. 
3 lines changed or deleted 5 lines changed or added


 container-statements.txx   container-statements.txx 
skipping to change at line 38 skipping to change at line 38
cond_image_.version = 0; cond_image_.version = 0;
cond_image_version_ = 0; cond_image_version_ = 0;
cond_id_image_version_ = 0; cond_id_image_version_ = 0;
data_image_.version = 0; data_image_.version = 0;
data_image_version_ = 0; data_image_version_ = 0;
data_id_image_version_ = 0; data_id_image_version_ = 0;
std::memset (cond_image_bind_, 0, sizeof (cond_image_bind_)); std::memset (cond_image_bind_, 0, sizeof (cond_image_bind_));
std::memset (data_image_bind_, 0, sizeof (data_image_bind_)); std::memset (data_image_bind_, 0, sizeof (data_image_bind_));
std::memset (data_image_error_, 0, sizeof (data_image_error_)); std::memset (data_image_truncated_, 0, sizeof (data_image_truncated_) );
for (std::size_t i (0); i < traits::data_column_count; ++i) for (std::size_t i (0); i < traits::data_column_count; ++i)
data_image_bind_[i].error = data_image_error_ + i; data_image_bind_[i].error = data_image_truncated_ + i;
} }
} }
} }
 End of changes. 2 change blocks. 
2 lines changed or deleted 2 lines changed or added


 database.hxx   database.hxx 
skipping to change at line 161 skipping to change at line 161
return socket_; return socket_;
} }
unsigned long unsigned long
client_flags () const client_flags () const
{ {
return client_flags_; return client_flags_;
} }
public: public:
using odb::database::execute;
virtual unsigned long long virtual unsigned long long
execute (const char* statement, std::size_t length); execute (const char* statement, std::size_t length);
public: public:
virtual transaction_impl* virtual transaction_impl*
begin (); begin ();
public: public:
details::shared_ptr<connection_type> details::shared_ptr<connection_type>
connection (); connection ();
 End of changes. 1 change blocks. 
0 lines changed or deleted 2 lines changed or added


 object-statements.hxx   object-statements.hxx 
skipping to change at line 13 skipping to change at line 13
// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC // copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC
// license : GNU GPL v2; see accompanying LICENSE file // license : GNU GPL v2; see accompanying LICENSE file
#ifndef ODB_MYSQL_OBJECT_STATEMENTS_HXX #ifndef ODB_MYSQL_OBJECT_STATEMENTS_HXX
#define ODB_MYSQL_OBJECT_STATEMENTS_HXX #define ODB_MYSQL_OBJECT_STATEMENTS_HXX
#include <odb/pre.hxx> #include <odb/pre.hxx>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <cstddef> // std::size_t
#include <odb/forward.hxx> #include <odb/forward.hxx>
#include <odb/traits.hxx> #include <odb/traits.hxx>
#include <odb/cache-traits.hxx> #include <odb/cache-traits.hxx>
#include <odb/mysql/mysql.hxx> #include <odb/mysql/mysql.hxx>
#include <odb/mysql/version.hxx> #include <odb/mysql/version.hxx>
#include <odb/mysql/statement.hxx> #include <odb/mysql/statement.hxx>
#include <odb/details/shared-ptr.hxx> #include <odb/details/shared-ptr.hxx>
skipping to change at line 213 skipping to change at line 214
return in_image_binding_; return in_image_binding_;
} }
binding& binding&
out_image_binding () out_image_binding ()
{ {
return out_image_binding_; return out_image_binding_;
} }
my_bool* my_bool*
out_image_error () out_image_truncated ()
{ {
return out_image_error_; return out_image_truncated_;
} }
// Object id image. // Object id image.
// //
id_image_type& id_image_type&
id_image () id_image ()
{ {
return id_image_; return id_image_;
} }
skipping to change at line 332 skipping to change at line 333
// //
std::size_t in_image_version_; std::size_t in_image_version_;
binding in_image_binding_; binding in_image_binding_;
MYSQL_BIND in_image_bind_[object_traits::in_column_count + 1]; MYSQL_BIND in_image_bind_[object_traits::in_column_count + 1];
// Out (receive) binding. // Out (receive) binding.
// //
std::size_t out_image_version_; std::size_t out_image_version_;
binding out_image_binding_; binding out_image_binding_;
MYSQL_BIND out_image_bind_[object_traits::out_column_count]; MYSQL_BIND out_image_bind_[object_traits::out_column_count];
my_bool out_image_error_[object_traits::out_column_count]; my_bool out_image_truncated_[object_traits::out_column_count];
// Id image binding (only in). // Id image binding (only in).
// //
id_image_type id_image_; id_image_type id_image_;
std::size_t id_image_version_; std::size_t id_image_version_;
binding id_image_binding_; binding id_image_binding_;
details::shared_ptr<persist_statement_type> persist_; details::shared_ptr<persist_statement_type> persist_;
details::shared_ptr<find_statement_type> find_; details::shared_ptr<find_statement_type> find_;
details::shared_ptr<update_statement_type> update_; details::shared_ptr<update_statement_type> update_;
 End of changes. 4 change blocks. 
3 lines changed or deleted 4 lines changed or added


 object-statements.txx   object-statements.txx 
skipping to change at line 36 skipping to change at line 36
{ {
image_.version = 0; image_.version = 0;
in_image_version_ = 0; in_image_version_ = 0;
out_image_version_ = 0; out_image_version_ = 0;
id_image_.version = 0; id_image_.version = 0;
id_image_version_ = 0; id_image_version_ = 0;
std::memset (in_image_bind_, 0, sizeof (in_image_bind_)); std::memset (in_image_bind_, 0, sizeof (in_image_bind_));
std::memset (out_image_bind_, 0, sizeof (out_image_bind_)); std::memset (out_image_bind_, 0, sizeof (out_image_bind_));
std::memset (out_image_error_, 0, sizeof (out_image_error_)); std::memset (out_image_truncated_, 0, sizeof (out_image_truncated_));
for (std::size_t i (0); i < object_traits::out_column_count; ++i) for (std::size_t i (0); i < object_traits::out_column_count; ++i)
out_image_bind_[i].error = out_image_error_ + i; out_image_bind_[i].error = out_image_truncated_ + i;
} }
template <typename T> template <typename T>
void object_statements<T>:: void object_statements<T>::
load_delayed_ () load_delayed_ ()
{ {
// We should be careful here: the delayed vector can change // We should be careful here: the delayed vector can change
// from under us as a result of a recursive load. // from under us as a result of a recursive load.
// //
database& db (connection ().database ()); database& db (connection ().database ());
 End of changes. 2 change blocks. 
2 lines changed or deleted 2 lines changed or added


 query.hxx   query.hxx 
skipping to change at line 123 skipping to change at line 123
template <database_type_id ID> template <database_type_id ID>
query (const query_column<bool, ID>&); query (const query_column<bool, ID>&);
query (const query&); query (const query&);
query& query&
operator= (const query&); operator= (const query&);
public: public:
binding&
parameters () const;
std::string std::string
clause () const; clause () const;
binding&
parameters_binding () const;
public: public:
template <typename T> template <typename T>
static val_bind<T> static val_bind<T>
_val (const T& x) _val (const T& x)
{ {
return val_bind<T> (x); return val_bind<T> (x);
} }
template <typename T> template <typename T>
static ref_bind<T> static ref_bind<T>
 End of changes. 2 change blocks. 
3 lines changed or deleted 3 lines changed or added


 result.hxx   result.hxx 
skipping to change at line 25 skipping to change at line 25
#include <odb/mysql/version.hxx> #include <odb/mysql/version.hxx>
#include <odb/mysql/forward.hxx> #include <odb/mysql/forward.hxx>
#include <odb/mysql/statement.hxx> #include <odb/mysql/statement.hxx>
#include <odb/details/shared-ptr.hxx> #include <odb/details/shared-ptr.hxx>
namespace odb namespace odb
{ {
namespace mysql namespace mysql
{ {
class query;
template <typename T> template <typename T>
class result_impl: public odb::result_impl<T> class result_impl: public odb::result_impl<T>
{ {
public: public:
typedef typename odb::result_impl<T>::pointer_type pointer_type; typedef typename odb::result_impl<T>::pointer_type pointer_type;
typedef typename odb::result_impl<T>::pointer_traits pointer_traits; typedef typename odb::result_impl<T>::pointer_traits pointer_traits;
typedef typename odb::result_impl<T>::object_type object_type; typedef typename odb::result_impl<T>::object_type object_type;
typedef typename odb::result_impl<T>::id_type id_type; typedef typename odb::result_impl<T>::id_type id_type;
typedef typename odb::result_impl<T>::object_traits object_traits; typedef typename odb::result_impl<T>::object_traits object_traits;
virtual virtual
~result_impl (); ~result_impl ();
result_impl (details::shared_ptr<select_statement> statement, result_impl (const query&,
details::shared_ptr<select_statement> statement,
object_statements<object_type>& statements); object_statements<object_type>& statements);
virtual void virtual void
load (object_type&); load (object_type&);
virtual id_type virtual id_type
load_id (); load_id ();
virtual void virtual void
next (); next ();
 End of changes. 2 change blocks. 
1 lines changed or deleted 4 lines changed or added


 result.txx   result.txx 
skipping to change at line 20 skipping to change at line 20
namespace mysql namespace mysql
{ {
template <typename T> template <typename T>
result_impl<T>:: result_impl<T>::
~result_impl () ~result_impl ()
{ {
} }
template <typename T> template <typename T>
result_impl<T>:: result_impl<T>::
result_impl (details::shared_ptr<select_statement> statement, result_impl (const query&,
details::shared_ptr<select_statement> statement,
object_statements<object_type>& statements) object_statements<object_type>& statements)
: odb::result_impl<T> (statements.connection ().database ()), : odb::result_impl<T> (statements.connection ().database ()),
statement_ (statement), statement_ (statement),
statements_ (statements), statements_ (statements),
count_ (0) count_ (0)
{ {
} }
template <typename T> template <typename T>
void result_impl<T>:: void result_impl<T>::
skipping to change at line 117 skipping to change at line 118
switch (r) switch (r)
{ {
case select_statement::truncated: case select_statement::truncated:
{ {
// Don't re-fetch data we are skipping. // Don't re-fetch data we are skipping.
// //
if (count_ != statement_->fetched ()) if (count_ != statement_->fetched ())
continue; continue;
typename object_traits::image_type& im (statements_.image ()); typename object_traits::image_type& im (statements_.image ());
object_traits::grow (im, statements_.out_image_error ()); object_traits::grow (im, statements_.out_image_truncated ());
if (im.version != statements_.out_image_version ()) if (im.version != statements_.out_image_version ())
{ {
binding& b (statements_.out_image_binding ()); binding& b (statements_.out_image_binding ());
object_traits::bind (b.bind, im, true); object_traits::bind (b.bind, im, true);
statements_.out_image_version (im.version); statements_.out_image_version (im.version);
b.version++; b.version++;
statement_->refetch (); statement_->refetch ();
} }
// Fall throught. // Fall throught.
 End of changes. 2 change blocks. 
2 lines changed or deleted 3 lines changed or added


 statement.hxx   statement.hxx 
skipping to change at line 141 skipping to change at line 141
const std::string& statement, const std::string& statement,
binding& data); binding& data);
// Return true if successful and false if the row is a duplicate. // Return true if successful and false if the row is a duplicate.
// All other errors are reported by throwing exceptions. // All other errors are reported by throwing exceptions.
// //
bool bool
execute (); execute ();
unsigned long long unsigned long long
id () id ();
{
return static_cast<unsigned long long> (
mysql_stmt_insert_id (stmt_));
}
private: private:
insert_statement (const insert_statement&); insert_statement (const insert_statement&);
insert_statement& operator= (const insert_statement&); insert_statement& operator= (const insert_statement&);
private: private:
binding& data_; binding& data_;
std::size_t data_version_; std::size_t data_version_;
}; };
class LIBODB_MYSQL_EXPORT update_statement: public statement class LIBODB_MYSQL_EXPORT update_statement: public statement
{ {
public: public:
virtual virtual
~update_statement (); ~update_statement ();
// Asssumes that cond.bind is a suffix of data.bind.
//
update_statement (connection& conn, update_statement (connection& conn,
const std::string& statement, const std::string& statement,
binding& id, binding& cond,
binding& image); binding& data);
void void
execute (); execute ();
private: private:
update_statement (const update_statement&); update_statement (const update_statement&);
update_statement& operator= (const update_statement&); update_statement& operator= (const update_statement&);
private: private:
binding& id_; binding& cond_;
std::size_t id_version_; std::size_t cond_version_;
binding& image_; binding& data_;
std::size_t image_version_; std::size_t data_version_;
}; };
class LIBODB_MYSQL_EXPORT delete_statement: public statement class LIBODB_MYSQL_EXPORT delete_statement: public statement
{ {
public: public:
virtual virtual
~delete_statement (); ~delete_statement ();
delete_statement (connection& conn, delete_statement (connection& conn,
const std::string& statement, const std::string& statement,
 End of changes. 5 change blocks. 
11 lines changed or deleted 9 lines changed or added


 version.hxx   version.hxx 
skipping to change at line 40 skipping to change at line 40
// Version AABBCCDD // Version AABBCCDD
// 2.0.0 02000000 // 2.0.0 02000000
// 2.1.0 02010000 // 2.1.0 02010000
// 2.1.1 02010100 // 2.1.1 02010100
// 2.2.0.a1 02019901 // 2.2.0.a1 02019901
// 3.0.0.b2 02999952 // 3.0.0.b2 02999952
// //
// Check that we have compatible ODB version. // Check that we have compatible ODB version.
// //
#if ODB_VERSION != 10200 #if ODB_VERSION != 10300
# error incompatible odb interface version detected # error incompatible odb interface version detected
#endif #endif
// Check that we have a compatible MySQL version (5.0.3 or later). // Check that we have a compatible MySQL version (5.0.3 or later).
// //
#if !defined(MYSQL_VERSION_ID) || MYSQL_VERSION_ID < 50003 #if !defined(MYSQL_VERSION_ID) || MYSQL_VERSION_ID < 50003
# error incompatible MySQL version detected # error incompatible MySQL version detected
#endif #endif
// libodb-mysql version: odb interface version plus the bugfix // libodb-mysql version: odb interface version plus the bugfix
// version. // version.
// //
#define LIBODB_MYSQL_VERSION 1020000 #define LIBODB_MYSQL_VERSION 1030000
#define LIBODB_MYSQL_VERSION_STR "1.2.0" #define LIBODB_MYSQL_VERSION_STR "1.3.0"
#include <odb/post.hxx> #include <odb/post.hxx>
#endif // ODB_MYSQL_VERSION_HXX #endif // ODB_MYSQL_VERSION_HXX
 End of changes. 2 change blocks. 
3 lines changed or deleted 3 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/