once-temp-type.h   once-temp-type.h 
skipping to change at line 14 skipping to change at line 14
// (See accompanying file LICENSE_1_0.txt or copy at // (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt) // http://www.boost.org/LICENSE_1_0.txt)
// //
#ifndef SOCI_ONCE_TEMP_TYPE_H_INCLUDED #ifndef SOCI_ONCE_TEMP_TYPE_H_INCLUDED
#define SOCI_ONCE_TEMP_TYPE_H_INCLUDED #define SOCI_ONCE_TEMP_TYPE_H_INCLUDED
#include "ref-counted-statement.h" #include "ref-counted-statement.h"
#include "prepare-temp-type.h" #include "prepare-temp-type.h"
#if __cplusplus >= 201103L
#define SOCI_ONCE_TEMP_TYPE_NOEXCEPT noexcept(false)
#else
#define SOCI_ONCE_TEMP_TYPE_NOEXCEPT
#endif
namespace soci namespace soci
{ {
class session; class session;
namespace details namespace details
{ {
class ref_counted_statement; class ref_counted_statement;
// this needs to be lightweight and copyable // this needs to be lightweight and copyable
class SOCI_DECL once_temp_type class SOCI_DECL once_temp_type
{ {
public: public:
once_temp_type(session & s); once_temp_type(session & s);
once_temp_type(once_temp_type const & o); once_temp_type(once_temp_type const & o);
once_temp_type & operator=(once_temp_type const & o); once_temp_type & operator=(once_temp_type const & o);
~once_temp_type(); ~once_temp_type() SOCI_ONCE_TEMP_TYPE_NOEXCEPT;
template <typename T> template <typename T>
once_temp_type & operator<<(T const & t) once_temp_type & operator<<(T const & t)
{ {
rcst_->accumulate(t); rcst_->accumulate(t);
return *this; return *this;
} }
once_temp_type & operator,(into_type_ptr const &); once_temp_type & operator,(into_type_ptr const &);
once_temp_type & operator,(use_type_ptr const &); once_temp_type & operator,(use_type_ptr const &);
 End of changes. 2 change blocks. 
1 lines changed or deleted 7 lines changed or added


 soci-mysql.h   soci-mysql.h 
skipping to change at line 178 skipping to change at line 178
MYSQL_RES *result_; MYSQL_RES *result_;
// The query is split into chunks, separated by the named parameters; // The query is split into chunks, separated by the named parameters;
// e.g. for "SELECT id FROM ttt WHERE name = :foo AND gender = :bar" // e.g. for "SELECT id FROM ttt WHERE name = :foo AND gender = :bar"
// we will have query chunks "SELECT id FROM ttt WHERE name = ", // we will have query chunks "SELECT id FROM ttt WHERE name = ",
// "AND gender = " and names "foo", "bar". // "AND gender = " and names "foo", "bar".
std::vector<std::string> queryChunks_; std::vector<std::string> queryChunks_;
std::vector<std::string> names_; // list of names for named binds std::vector<std::string> names_; // list of names for named binds
long long rowsAffectedBulk_; // number of rows affected by the last bul
k operation
int numberOfRows_; // number of rows retrieved from the server int numberOfRows_; // number of rows retrieved from the server
int currentRow_; // "current" row number to consume in postFetch int currentRow_; // "current" row number to consume in postFetch
int rowsToConsume_; // number of rows to be consumed in postFetch int rowsToConsume_; // number of rows to be consumed in postFetch
bool justDescribed_; // to optimize row description with immediately bool justDescribed_; // to optimize row description with immediately
// following actual statement execution // following actual statement execution
// Prefetch the row offsets in order to use mysql_row_seek() for // Prefetch the row offsets in order to use mysql_row_seek() for
// random access to rows, since mysql_data_seek() is expensive. // random access to rows, since mysql_data_seek() is expensive.
std::vector<MYSQL_ROW_OFFSET> resultRowOffsets_; std::vector<MYSQL_ROW_OFFSET> resultRowOffsets_;
 End of changes. 1 change blocks. 
0 lines changed or deleted 3 lines changed or added


 soci-odbc.h   soci-odbc.h 
skipping to change at line 29 skipping to change at line 29
#endif // _WIN32 #endif // _WIN32
// //
// If SOCI_ODBC_DECL isn't defined yet define it now // If SOCI_ODBC_DECL isn't defined yet define it now
#ifndef SOCI_ODBC_DECL #ifndef SOCI_ODBC_DECL
# define SOCI_ODBC_DECL # define SOCI_ODBC_DECL
#endif #endif
#include <vector> #include <vector>
#include <soci-backend.h> #include <soci-backend.h>
#if defined(_MSC_VER) || defined(__MINGW32__) #if defined(_MSC_VER) || defined(__MINGW32__)
#include <soci-platform.h>
#include <windows.h> #include <windows.h>
#endif #endif
#include <sqlext.h> // ODBC #include <sqlext.h> // ODBC
#include <string.h> // strcpy() #include <string.h> // strcpy()
namespace soci namespace soci
{ {
// TODO: Do we want to make it a part of public interface? --mloskot // TODO: Do we want to make it a part of public interface? --mloskot
namespace details namespace details
skipping to change at line 229 skipping to change at line 230
// helper for defining into vector<string> // helper for defining into vector<string>
std::size_t column_size(int position); std::size_t column_size(int position);
virtual odbc_standard_into_type_backend * make_into_type_backend(); virtual odbc_standard_into_type_backend * make_into_type_backend();
virtual odbc_standard_use_type_backend * make_use_type_backend(); virtual odbc_standard_use_type_backend * make_use_type_backend();
virtual odbc_vector_into_type_backend * make_vector_into_type_backend() ; virtual odbc_vector_into_type_backend * make_vector_into_type_backend() ;
virtual odbc_vector_use_type_backend * make_vector_use_type_backend(); virtual odbc_vector_use_type_backend * make_vector_use_type_backend();
odbc_session_backend &session_; odbc_session_backend &session_;
SQLHSTMT hstmt_; SQLHSTMT hstmt_;
SQLUINTEGER numRowsFetched_; SQLULEN numRowsFetched_;
bool hasVectorUseElements_; bool hasVectorUseElements_;
bool boundByName_; bool boundByName_;
bool boundByPos_; bool boundByPos_;
bool lastNoData_; // true if last query returned SQL_NO_DATA
long long rowsAffected_; // number of rows affected by the last operati
on
std::string query_; std::string query_;
std::vector<std::string> names_; // list of names for named binds std::vector<std::string> names_; // list of names for named binds
}; };
struct odbc_rowid_backend : details::rowid_backend struct odbc_rowid_backend : details::rowid_backend
{ {
odbc_rowid_backend(odbc_session_backend &session); odbc_rowid_backend(odbc_session_backend &session);
skipping to change at line 329 skipping to change at line 331
public: public:
odbc_soci_error(SQLSMALLINT htype, odbc_soci_error(SQLSMALLINT htype,
SQLHANDLE hndl, SQLHANDLE hndl,
std::string const & msg) std::string const & msg)
: soci_error(msg) : soci_error(msg)
{ {
const char* socierror = NULL; const char* socierror = NULL;
SQLSMALLINT length, i = 1; SQLSMALLINT length, i = 1;
switch ( SQLGetDiagRec(htype, hndl, i, sqlstate_, &sqlcode_, switch ( SQLGetDiagRecA(htype, hndl, i, sqlstate_, &sqlcode_,
message_, SQL_MAX_MESSAGE_LENGTH + 1, message_, SQL_MAX_MESSAGE_LENGTH + 1,
&length) ) &length) )
{ {
case SQL_SUCCESS: case SQL_SUCCESS:
// The error message was successfully retrieved. // The error message was successfully retrieved.
break; break;
case SQL_INVALID_HANDLE: case SQL_INVALID_HANDLE:
socierror = "[SOCI]: Invalid handle."; socierror = "[SOCI]: Invalid handle.";
break; break;
 End of changes. 4 change blocks. 
3 lines changed or deleted 6 lines changed or added


 soci-platform.h   soci-platform.h 
// //
// Copyright (C) 2006-2008 Mateusz Loskot // Copyright (C) 2006-2008 Mateusz Loskot
// Distributed under the Boost Software License, Version 1.0. // Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at // (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt) // http://www.boost.org/LICENSE_1_0.txt)
// //
#ifndef SOCI_PLATFORM_H_INCLUDED #ifndef SOCI_PLATFORM_H_INCLUDED
#define SOCI_PLATFORM_H_INCLUDED #define SOCI_PLATFORM_H_INCLUDED
#if defined(_MSC_VER) || defined(__MINGW32__)
#define LL_FMT_FLAGS "I64"
#else
#define LL_FMT_FLAGS "ll"
#endif
// Portability hacks for Microsoft Visual C++ compiler // Portability hacks for Microsoft Visual C++ compiler
#ifdef _MSC_VER #ifdef _MSC_VER
#include <stdlib.h> #include <stdlib.h>
// Define if you have the vsnprintf variants. // Define if you have the vsnprintf variants.
#if _MSC_VER < 1500 #if _MSC_VER < 1500
# define HAVE_VSNPRINTF 1 # define HAVE_VSNPRINTF 1
# define vsnprintf _vsnprintf # define vsnprintf _vsnprintf
#endif #endif
 End of changes. 1 change blocks. 
0 lines changed or deleted 6 lines changed or added


 soci-postgresql.h   soci-postgresql.h 
skipping to change at line 49 skipping to change at line 49
{ {
public: public:
postgresql_soci_error(std::string const & msg, char const * sqlst); postgresql_soci_error(std::string const & msg, char const * sqlst);
std::string sqlstate() const; std::string sqlstate() const;
private: private:
char sqlstate_[ 5 ]; // not std::string to keep copy-constructor no-t hrow char sqlstate_[ 5 ]; // not std::string to keep copy-constructor no-t hrow
}; };
namespace details
{
// A class thinly encapsulating PGresult. Its main purpose is to ensure tha
t
// PQclear() is always called, avoiding result memory leaks.
class postgresql_result
{
public:
// Creates a wrapper for the given, possibly NULL, result. The wrapper
// object takes ownership of the object and will call PQclear() on it.
explicit postgresql_result(PGresult* result = NULL)
{
init(result);
}
// Frees any currently stored result pointer and takes ownership of the
// given one.
void reset(PGresult* result = NULL)
{
free();
init(result);
}
// Check whether the status is PGRES_COMMAND_OK and throw an exception
if
// it is different. Notice that if the query can return any results,
// check_for_data() below should be used instead to verify whether anyt
hing
// was returned or not.
//
// The provided error message is used only for the exception being thro
wn
// and should describe the operation which yielded this result.
void check_for_errors(char const* errMsg) const;
// Check whether the status indicates successful query completion, eith
er
// with the return results (in which case true is returned) or without
them
// (then false is returned). If the status corresponds to an error, thr
ows
// an exception, just as check_for_errors().
bool check_for_data(char const* errMsg) const;
// Implicit conversion to const PGresult: this is somewhat dangerous bu
t
// allows us to avoid changing the existing code that uses PGresult and
// avoids the really bad problem with calling PQclear() twice accidenta
lly
// as this would require a conversion to non-const pointer that we do n
ot
// provide.
operator const PGresult*() const { return result_; }
// Get the associated result (which may be NULL). Unlike the implicit
// conversion above, this one returns a non-const pointer, so you shoul
d be
// careful to avoid really modifying it.
PGresult* get_result() const { return result_; }
// Dtor frees the result.
~postgresql_result() { free(); }
private:
void init(PGresult* result)
{
result_ = result;
}
void free()
{
// Notice that it is safe to call PQclear() with NULL pointer, it
// simply does nothing in this case.
PQclear(result_);
}
PGresult* result_;
// This class can't be copied as it owns result_ which can't be duplica
ted.
postgresql_result(postgresql_result const &);
postgresql_result& operator=(postgresql_result const &);
};
} // namespace details
struct postgresql_statement_backend; struct postgresql_statement_backend;
struct postgresql_standard_into_type_backend : details::standard_into_type_ backend struct postgresql_standard_into_type_backend : details::standard_into_type_ backend
{ {
postgresql_standard_into_type_backend(postgresql_statement_backend & st ) postgresql_standard_into_type_backend(postgresql_statement_backend & st )
: statement_(st) {} : statement_(st) {}
virtual void define_by_pos(int & position, virtual void define_by_pos(int & position,
void * data, details::exchange_type type); void * data, details::exchange_type type);
virtual void pre_fetch(); virtual void pre_fetch();
skipping to change at line 173 skipping to change at line 248
virtual void describe_column(int colNum, data_type & dtype, virtual void describe_column(int colNum, data_type & dtype,
std::string & columnName); std::string & columnName);
virtual postgresql_standard_into_type_backend * make_into_type_backend( ); virtual postgresql_standard_into_type_backend * make_into_type_backend( );
virtual postgresql_standard_use_type_backend * make_use_type_backend(); virtual postgresql_standard_use_type_backend * make_use_type_backend();
virtual postgresql_vector_into_type_backend * make_vector_into_type_bac kend(); virtual postgresql_vector_into_type_backend * make_vector_into_type_bac kend();
virtual postgresql_vector_use_type_backend * make_vector_use_type_backe nd(); virtual postgresql_vector_use_type_backend * make_vector_use_type_backe nd();
postgresql_session_backend & session_; postgresql_session_backend & session_;
PGresult * result_; details::postgresql_result result_;
std::string query_; std::string query_;
details::statement_type stType_; details::statement_type stType_;
std::string statementName_; std::string statementName_;
std::vector<std::string> names_; // list of names for named binds std::vector<std::string> names_; // list of names for named binds
long long rowsAffectedBulk_; // number of rows affected by the last bul
k operation
int numberOfRows_; // number of rows retrieved from the server int numberOfRows_; // number of rows retrieved from the server
int currentRow_; // "current" row number to consume in postFetch int currentRow_; // "current" row number to consume in postFetch
int rowsToConsume_; // number of rows to be consumed in postFetch int rowsToConsume_; // number of rows to be consumed in postFetch
bool justDescribed_; // to optimize row description with immediately bool justDescribed_; // to optimize row description with immediately
// following actual statement execution // following actual statement execution
bool hasIntoElements_; bool hasIntoElements_;
bool hasVectorIntoElements_; bool hasVectorIntoElements_;
bool hasUseElements_; bool hasUseElements_;
skipping to change at line 242 skipping to change at line 319
postgresql_session_backend(connection_parameters const & parameters); postgresql_session_backend(connection_parameters const & parameters);
~postgresql_session_backend(); ~postgresql_session_backend();
virtual void begin(); virtual void begin();
virtual void commit(); virtual void commit();
virtual void rollback(); virtual void rollback();
void deallocate_prepared_statement(const std::string & statementName); void deallocate_prepared_statement(const std::string & statementName);
virtual bool get_next_sequence_value(session & s,
std::string const & sequence, long & value);
virtual std::string get_backend_name() const { return "postgresql"; } virtual std::string get_backend_name() const { return "postgresql"; }
void clean_up(); void clean_up();
virtual postgresql_statement_backend * make_statement_backend(); virtual postgresql_statement_backend * make_statement_backend();
virtual postgresql_rowid_backend * make_rowid_backend(); virtual postgresql_rowid_backend * make_rowid_backend();
virtual postgresql_blob_backend * make_blob_backend(); virtual postgresql_blob_backend * make_blob_backend();
std::string get_next_statement_name(); std::string get_next_statement_name();
 End of changes. 4 change blocks. 
1 lines changed or deleted 94 lines changed or added


 soci-sqlite3.h   soci-sqlite3.h 
skipping to change at line 26 skipping to change at line 26
# define SOCI_SQLITE3_DECL __declspec(dllimport) # define SOCI_SQLITE3_DECL __declspec(dllimport)
# endif // SOCI_SQLITE3_SOURCE # endif // SOCI_SQLITE3_SOURCE
# endif // SOCI_DLL # endif // SOCI_DLL
#endif // _WIN32 #endif // _WIN32
// //
// If SOCI_SQLITE3_DECL isn't defined yet define it now // If SOCI_SQLITE3_DECL isn't defined yet define it now
#ifndef SOCI_SQLITE3_DECL #ifndef SOCI_SQLITE3_DECL
# define SOCI_SQLITE3_DECL # define SOCI_SQLITE3_DECL
#endif #endif
#include <cstdarg>
#include <vector> #include <vector>
#include "soci-backend.h" #include "soci-backend.h"
// Disable flood of nonsense warnings generated for SQLite // Disable flood of nonsense warnings generated for SQLite
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(push) #pragma warning(push)
#pragma warning(disable:4510 4512 4610) #pragma warning(disable:4510 4512 4610)
#endif #endif
namespace sqlite_api namespace sqlite_api
skipping to change at line 197 skipping to change at line 198
virtual sqlite3_vector_use_type_backend * make_vector_use_type_backend( ); virtual sqlite3_vector_use_type_backend * make_vector_use_type_backend( );
sqlite3_session_backend &session_; sqlite3_session_backend &session_;
sqlite_api::sqlite3_stmt *stmt_; sqlite_api::sqlite3_stmt *stmt_;
sqlite3_recordset dataCache_; sqlite3_recordset dataCache_;
sqlite3_recordset useData_; sqlite3_recordset useData_;
bool databaseReady_; bool databaseReady_;
bool boundByName_; bool boundByName_;
bool boundByPos_; bool boundByPos_;
long long rowsAffectedBulk_; // number of rows affected by the last bul
k operation
private: private:
exec_fetch_result load_rowset(int totalRows); exec_fetch_result load_rowset(int totalRows);
exec_fetch_result load_one(); exec_fetch_result load_one();
exec_fetch_result bind_and_execute(int number); exec_fetch_result bind_and_execute(int number);
}; };
struct sqlite3_rowid_backend : details::rowid_backend struct sqlite3_rowid_backend : details::rowid_backend
{ {
sqlite3_rowid_backend(sqlite3_session_backend &session); sqlite3_rowid_backend(sqlite3_session_backend &session);
 End of changes. 2 change blocks. 
0 lines changed or deleted 4 lines changed or added


 type-conversion.h   type-conversion.h 
skipping to change at line 15 skipping to change at line 15
// http://www.boost.org/LICENSE_1_0.txt) // http://www.boost.org/LICENSE_1_0.txt)
// //
#ifndef SOCI_TYPE_CONVERSION_H_INCLUDED #ifndef SOCI_TYPE_CONVERSION_H_INCLUDED
#define SOCI_TYPE_CONVERSION_H_INCLUDED #define SOCI_TYPE_CONVERSION_H_INCLUDED
#include "type-conversion-traits.h" #include "type-conversion-traits.h"
#include "into-type.h" #include "into-type.h"
#include "use-type.h" #include "use-type.h"
// std // std
#include <cassert>
#include <cstddef> #include <cstddef>
#include <string> #include <string>
#include <vector> #include <vector>
namespace soci namespace soci
{ {
namespace details namespace details
{ {
skipping to change at line 47 skipping to change at line 48
class conversion_into_type class conversion_into_type
: private base_value_holder<T>, : private base_value_holder<T>,
public into_type<typename type_conversion<T>::base_type> public into_type<typename type_conversion<T>::base_type>
{ {
public: public:
typedef typename type_conversion<T>::base_type base_type; typedef typename type_conversion<T>::base_type base_type;
conversion_into_type(T & value) conversion_into_type(T & value)
: into_type<base_type>(details::base_value_holder<T>::val_, ownInd_ ) : into_type<base_type>(details::base_value_holder<T>::val_, ownInd_ )
, value_(value) , value_(value)
, ownInd_()
, ind_(ownInd_) , ind_(ownInd_)
{} {
assert(ownInd_ == ind_);
}
conversion_into_type(T & value, indicator & ind) conversion_into_type(T & value, indicator & ind)
: into_type<base_type>(details::base_value_holder<T>::val_, ind) : into_type<base_type>(details::base_value_holder<T>::val_, ind)
, value_(value) , value_(value)
, ownInd_(ind) // unused, just keep the pair of indicator(s) consis tent
, ind_(ind) , ind_(ind)
{} {
assert(ownInd_ == ind_);
}
private: private:
void convert_from_base() void convert_from_base()
{ {
type_conversion<T>::from_base( type_conversion<T>::from_base(
details::base_value_holder<T>::val_, ind_, value_); details::base_value_holder<T>::val_, ind_, value_);
} }
T & value_; T & value_;
skipping to change at line 86 skipping to change at line 93
class conversion_use_type class conversion_use_type
: private details::base_value_holder<T>, : private details::base_value_holder<T>,
public use_type<typename type_conversion<T>::base_type> public use_type<typename type_conversion<T>::base_type>
{ {
public: public:
typedef typename type_conversion<T>::base_type base_type; typedef typename type_conversion<T>::base_type base_type;
conversion_use_type(T & value, std::string const & name = std::string() ) conversion_use_type(T & value, std::string const & name = std::string() )
: use_type<base_type>(details::base_value_holder<T>::val_, ownInd_, name) : use_type<base_type>(details::base_value_holder<T>::val_, ownInd_, name)
, value_(value) , value_(value)
, ownInd_()
, ind_(ownInd_) , ind_(ownInd_)
, readOnly_(false) , readOnly_(false)
{ {
assert(ownInd_ == ind_);
// TODO: likely to be removed (SHA: c166625a28f7c907318134f625ff5ac ea7d9a1f8) // TODO: likely to be removed (SHA: c166625a28f7c907318134f625ff5ac ea7d9a1f8)
//convert_to_base(); //convert_to_base();
} }
conversion_use_type(T const & value, std::string const & name = std::st ring()) conversion_use_type(T const & value, std::string const & name = std::st ring())
: use_type<base_type>(details::base_value_holder<T>::val_, ownInd_, name) : use_type<base_type>(details::base_value_holder<T>::val_, ownInd_, name)
, value_(const_cast<T &>(value)) , value_(const_cast<T &>(value))
, ownInd_()
, ind_(ownInd_) , ind_(ownInd_)
, readOnly_(true) , readOnly_(true)
{ {
assert(ownInd_ == ind_);
// TODO: likely to be removed (SHA: c166625a28f7c907318134f625ff5ac ea7d9a1f8) // TODO: likely to be removed (SHA: c166625a28f7c907318134f625ff5ac ea7d9a1f8)
//convert_to_base(); //convert_to_base();
} }
conversion_use_type(T & value, indicator & ind, conversion_use_type(T & value, indicator & ind,
std::string const & name = std::string()) std::string const & name = std::string())
: use_type<base_type>(details::base_value_holder<T>::val_, ind, nam e) : use_type<base_type>(details::base_value_holder<T>::val_, ind, nam e)
, value_(value) , value_(value)
, ind_(ind) , ind_(ind)
, readOnly_(false) , readOnly_(false)
skipping to change at line 186 skipping to change at line 199
public: public:
typedef typename std::vector typedef typename std::vector
< <
typename type_conversion<T>::base_type typename type_conversion<T>::base_type
> base_type; > base_type;
conversion_into_type(std::vector<T> & value) conversion_into_type(std::vector<T> & value)
: details::base_vector_holder<T>(value.size()) : details::base_vector_holder<T>(value.size())
, into_type<base_type>(details::base_vector_holder<T>::vec_, ownInd _) , into_type<base_type>(details::base_vector_holder<T>::vec_, ownInd _)
, value_(value) , value_(value)
, ownInd_()
, ind_(ownInd_) , ind_(ownInd_)
{} {
assert(ownInd_ == ind_);
}
conversion_into_type(std::vector<T> & value, std::vector<indicator> & i nd) conversion_into_type(std::vector<T> & value, std::vector<indicator> & i nd)
: details::base_vector_holder<T>(value.size()) : details::base_vector_holder<T>(value.size())
, into_type<base_type>(details::base_vector_holder<T>::vec_, ind) , into_type<base_type>(details::base_vector_holder<T>::vec_, ind)
, value_(value) , value_(value)
, ind_(ind) , ind_(ind)
{} {}
virtual std::size_t size() const virtual std::size_t size() const
{ {
skipping to change at line 254 skipping to change at line 270
< <
typename type_conversion<T>::base_type typename type_conversion<T>::base_type
> base_type; > base_type;
conversion_use_type(std::vector<T> & value, conversion_use_type(std::vector<T> & value,
std::string const & name=std::string()) std::string const & name=std::string())
: details::base_vector_holder<T>(value.size()) : details::base_vector_holder<T>(value.size())
, use_type<base_type>( , use_type<base_type>(
details::base_vector_holder<T>::vec_, ownInd_, name) details::base_vector_holder<T>::vec_, ownInd_, name)
, value_(value) , value_(value)
, ownInd_()
, ind_(ownInd_) , ind_(ownInd_)
{} {
assert(ownInd_ == ind_);
}
conversion_use_type(std::vector<T> & value, conversion_use_type(std::vector<T> & value,
std::vector<indicator> & ind, std::vector<indicator> & ind,
std::string const & name = std::string()) std::string const & name = std::string())
: details::base_vector_holder<T>(value.size()) : details::base_vector_holder<T>(value.size())
, use_type<base_type>( , use_type<base_type>(
details::base_vector_holder<T>::vec_, ind, name) details::base_vector_holder<T>::vec_, ind, name)
, value_(value) , value_(value)
, ind_(ind) , ind_(ind)
{} {}
 End of changes. 13 change blocks. 
4 lines changed or deleted 23 lines changed or added


 utility.h   utility.h 
skipping to change at line 29 skipping to change at line 29
SQLCHAR message[SQL_MAX_MESSAGE_LENGTH + 1]; SQLCHAR message[SQL_MAX_MESSAGE_LENGTH + 1];
SQLCHAR sqlstate[SQL_SQLSTATE_SIZE + 1]; SQLCHAR sqlstate[SQL_SQLSTATE_SIZE + 1];
SQLINTEGER sqlcode; SQLINTEGER sqlcode;
SQLSMALLINT length, i; SQLSMALLINT length, i;
std::stringstream ss; std::stringstream ss;
i = 1; i = 1;
/* get multiple field settings of diagnostic record */ /* get multiple field settings of diagnostic record */
while (SQLGetDiagRec(htype, while (SQLGetDiagRecA(htype,
hndl, hndl,
i, i,
sqlstate, sqlstate,
&sqlcode, &sqlcode,
message, message,
SQL_MAX_MESSAGE_LENGTH + 1, SQL_MAX_MESSAGE_LENGTH + 1,
&length) == SQL_SUCCESS) &length) == SQL_SUCCESS)
{ {
ss << std::endl << "SOCI ODBC Error: " << msg << std::endl ss << std::endl << "SOCI ODBC Error: " << msg << std::endl
<< "SQLSTATE = " << sqlstate << std::endl << "SQLSTATE = " << sqlstate << std::endl
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 version.h   version.h 
skipping to change at line 30 skipping to change at line 30
// SOCI_VERSION / 100 % 1000 is the minor version // SOCI_VERSION / 100 % 1000 is the minor version
// SOCI_VERSION / 100000 is the major version // SOCI_VERSION / 100000 is the major version
#define SOCI_VERSION 300201 #define SOCI_VERSION 300201
// //
// SOCI_LIB_VERSION must be defined to be the same as SOCI_VERSION // SOCI_LIB_VERSION must be defined to be the same as SOCI_VERSION
// but as a *string* in the form "x_y[_z]" where x is the major version // but as a *string* in the form "x_y[_z]" where x is the major version
// number, y is the minor version number, and z is the patch level if not 0. // number, y is the minor version number, and z is the patch level if not 0.
#define SOCI_LIB_VERSION "3_2_1" #define SOCI_LIB_VERSION "3_2_2"
#endif // SOCI_VERSION_HPP #endif // SOCI_VERSION_HPP
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 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/