diff options
| -rw-r--r-- | odb/mssql/auto-handle.hxx | 2 | ||||
| -rw-r--r-- | odb/mssql/binding.hxx | 45 | ||||
| -rw-r--r-- | odb/mssql/connection.cxx | 21 | ||||
| -rw-r--r-- | odb/mssql/connection.hxx | 15 | ||||
| -rw-r--r-- | odb/mssql/database.hxx | 8 | ||||
| -rw-r--r-- | odb/mssql/error.cxx | 3 | ||||
| -rw-r--r-- | odb/mssql/error.hxx | 2 | ||||
| -rw-r--r-- | odb/mssql/exceptions.hxx | 2 | ||||
| -rw-r--r-- | odb/mssql/makefile | 2 | ||||
| -rw-r--r-- | odb/mssql/mssql-fwd.hxx | 73 | ||||
| -rw-r--r-- | odb/mssql/mssql-types.hxx | 133 | ||||
| -rw-r--r-- | odb/mssql/mssql.hxx | 32 | ||||
| -rw-r--r-- | odb/mssql/statement.cxx | 805 | ||||
| -rw-r--r-- | odb/mssql/statement.hxx | 228 | ||||
| -rw-r--r-- | odb/mssql/tracer.cxx | 62 | ||||
| -rw-r--r-- | odb/mssql/tracer.hxx | 63 | ||||
| -rw-r--r-- | odb/mssql/transaction-impl.cxx | 9 | ||||
| -rw-r--r-- | odb/mssql/transaction.hxx | 6 |
18 files changed, 1465 insertions, 46 deletions
diff --git a/odb/mssql/auto-handle.hxx b/odb/mssql/auto-handle.hxx index d545629..56f2fc2 100644 --- a/odb/mssql/auto-handle.hxx +++ b/odb/mssql/auto-handle.hxx @@ -8,8 +8,8 @@ #include <odb/pre.hxx> -#include <odb/mssql/version.hxx> #include <odb/mssql/mssql-fwd.hxx> +#include <odb/mssql/version.hxx> #include <odb/mssql/details/export.hxx> diff --git a/odb/mssql/binding.hxx b/odb/mssql/binding.hxx new file mode 100644 index 0000000..f8f4fc4 --- /dev/null +++ b/odb/mssql/binding.hxx @@ -0,0 +1,45 @@ +// file : odb/mssql/binding.hxx +// author : Constantin Michael <constantin@codesynthesis.com> +// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC +// license : ODB NCUEL; see accompanying LICENSE file + +#ifndef ODB_MSSQL_BINDING_HXX +#define ODB_MSSQL_BINDING_HXX + +#include <odb/pre.hxx> + +#include <cstddef> // std::size_t + +#include <odb/mssql/version.hxx> +#include <odb/mssql/mssql-types.hxx> + +#include <odb/mssql/details/export.hxx> + +namespace odb +{ + namespace mssql + { + class LIBODB_MSSQL_EXPORT binding + { + public: + typedef mssql::bind bind_type; + + binding (bind_type* b, std::size_t n) + : bind (b), count (n), version (0) + { + } + + bind_type* bind; + std::size_t count; + std::size_t version; + + private: + binding (const binding&); + binding& operator= (const binding&); + }; + } +} + +#include <odb/post.hxx> + +#endif // ODB_MSSQL_BINDING_HXX diff --git a/odb/mssql/connection.cxx b/odb/mssql/connection.cxx index 3ba10ba..1609b80 100644 --- a/odb/mssql/connection.cxx +++ b/odb/mssql/connection.cxx @@ -25,8 +25,9 @@ namespace odb connection (database_type& db) : odb::connection (db), db_ (db), - state_ (state_disconnected) + state_ (state_disconnected), // statement_cache_ (new statement_cache_type (*this)) + long_buffer_ (0) { SQLRETURN r; @@ -46,7 +47,7 @@ namespace odb // r = SQLSetConnectAttr (handle_, SQL_ATTR_AUTOCOMMIT, - SQL_AUTOCOMMIT_OFF, + (SQLPOINTER) SQL_AUTOCOMMIT_OFF, 0); if (!SQL_SUCCEEDED (r)) @@ -55,6 +56,16 @@ namespace odb // translate_error (r, handle_, SQL_HANDLE_DBC); + // Enable Multiple Active Result Sets (MARS). + // + r = SQLSetConnectAttr (handle_, + SQL_COPT_SS_MARS_ENABLED, + (SQLPOINTER) SQL_MARS_ENABLED_YES, + SQL_IS_UINTEGER); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, handle_, SQL_HANDLE_DBC); + // Connect. // { @@ -84,8 +95,9 @@ namespace odb : odb::connection (db), db_ (db), handle_ (handle), - state_ (state_connected) + state_ (state_connected), // statement_cache_ (new statement_cache_type (*this)) + long_buffer_ (0) { } @@ -109,8 +121,6 @@ namespace odb unsigned long long connection:: execute (const char* s, std::size_t n) { - /* - @@ { odb::tracer* t; if ((t = transaction_tracer ()) || @@ -121,7 +131,6 @@ namespace odb t->execute (*this, str.c_str ()); } } - */ SQLRETURN r; diff --git a/odb/mssql/connection.hxx b/odb/mssql/connection.hxx index 1a6cd24..c38692b 100644 --- a/odb/mssql/connection.hxx +++ b/odb/mssql/connection.hxx @@ -15,14 +15,15 @@ #include <odb/forward.hxx> #include <odb/connection.hxx> +#include <odb/details/buffer.hxx> #include <odb/details/shared-ptr.hxx> +#include <odb/mssql/mssql-fwd.hxx> #include <odb/mssql/version.hxx> #include <odb/mssql/forward.hxx> -//#include <odb/mssql/tracer.hxx> +#include <odb/mssql/tracer.hxx> #include <odb/mssql/transaction-impl.hxx> #include <odb/mssql/auto-handle.hxx> -#include <odb/mssql/mssql-fwd.hxx> #include <odb/mssql/details/export.hxx> @@ -66,7 +67,6 @@ namespace odb // SQL statement tracing. // public: - /* typedef mssql::tracer tracer_type; void @@ -82,7 +82,6 @@ namespace odb } using odb::connection::tracer; - */ public: bool @@ -112,6 +111,12 @@ namespace odb } */ + details::buffer& + long_buffer () + { + return long_buffer_; + } + private: connection (const connection&); connection& operator= (const connection&); @@ -133,6 +138,8 @@ namespace odb auto_handle<SQL_HANDLE_STMT> direct_stmt_; //std::auto_ptr<statement_cache_type> statement_cache_; + + details::buffer long_buffer_; }; } } diff --git a/odb/mssql/database.hxx b/odb/mssql/database.hxx index cabdbb4..5bb5e4f 100644 --- a/odb/mssql/database.hxx +++ b/odb/mssql/database.hxx @@ -6,8 +6,6 @@ #ifndef ODB_MSSQL_DATABASE_HXX #define ODB_MSSQL_DATABASE_HXX -//@@ disabled functionality - #include <odb/pre.hxx> #include <string> @@ -16,13 +14,13 @@ #include <odb/database.hxx> +#include <odb/mssql/mssql-fwd.hxx> #include <odb/mssql/version.hxx> #include <odb/mssql/forward.hxx> -//#include <odb/mssql/tracer.hxx> +#include <odb/mssql/tracer.hxx> #include <odb/mssql/connection.hxx> #include <odb/mssql/connection-factory.hxx> #include <odb/mssql/auto-handle.hxx> -#include <odb/mssql/mssql-fwd.hxx> #include <odb/mssql/details/export.hxx> @@ -211,7 +209,6 @@ namespace odb // SQL statement tracing. // public: - /* typedef mssql::tracer tracer_type; void @@ -227,7 +224,6 @@ namespace odb } using odb::database::tracer; - */ public: virtual diff --git a/odb/mssql/error.cxx b/odb/mssql/error.cxx index dffe4cf..613f346 100644 --- a/odb/mssql/error.cxx +++ b/odb/mssql/error.cxx @@ -87,13 +87,12 @@ namespace odb 0, &msg_size); - string s (sqlstate); - if (r == SQL_NO_DATA) break; else if (SQL_SUCCEEDED (r)) { code nc; + string s (sqlstate); if (s == "40001") // Serialization failure (native code 1205). nc = code_deadlock; diff --git a/odb/mssql/error.hxx b/odb/mssql/error.hxx index 126f7d9..fd7cfb6 100644 --- a/odb/mssql/error.hxx +++ b/odb/mssql/error.hxx @@ -8,9 +8,9 @@ #include <odb/pre.hxx> +#include <odb/mssql/mssql-fwd.hxx> #include <odb/mssql/version.hxx> #include <odb/mssql/forward.hxx> // connection -#include <odb/mssql/mssql-fwd.hxx> #include <odb/mssql/auto-handle.hxx> #include <odb/mssql/details/export.hxx> diff --git a/odb/mssql/exceptions.hxx b/odb/mssql/exceptions.hxx index 321a41d..3e7a845 100644 --- a/odb/mssql/exceptions.hxx +++ b/odb/mssql/exceptions.hxx @@ -13,8 +13,8 @@ #include <odb/exceptions.hxx> -#include <odb/mssql/version.hxx> #include <odb/mssql/mssql-fwd.hxx> +#include <odb/mssql/version.hxx> #include <odb/mssql/details/export.hxx> namespace odb diff --git a/odb/mssql/makefile b/odb/mssql/makefile index 63aa888..4758abf 100644 --- a/odb/mssql/makefile +++ b/odb/mssql/makefile @@ -13,6 +13,8 @@ connection-factory.cxx \ database.cxx \ error.cxx \ exceptions.cxx \ +statement.cxx \ +tracer.cxx \ transaction.cxx \ transaction-impl.cxx diff --git a/odb/mssql/mssql-fwd.hxx b/odb/mssql/mssql-fwd.hxx index b4afbb6..3579403 100644 --- a/odb/mssql/mssql-fwd.hxx +++ b/odb/mssql/mssql-fwd.hxx @@ -8,25 +8,78 @@ #include <odb/pre.hxx> +#include <cstddef> // std::size_t + // Forward declaration for some of the types defined in sqltypes.h or // sqlncli.h. This allows us to avoid having to include these files // in public headers. // #ifdef _WIN32 -typedef long SQLINTEGER; -typedef unsigned long SQLUINTEGER; + +// Keep consistent with Windows ODBC headers. +// + +typedef long SQLINTEGER; +typedef unsigned long SQLUINTEGER; + +#ifdef _WIN64 +typedef __int64 SQLLEN; +typedef unsigned __int64 SQLULEN; +#else +#ifndef SQLLEN +typedef SQLINTEGER SQLLEN; +typedef SQLUINTEGER SQLULEN; +#endif +#endif + +#else // _WIN32 + +// Keep consistent with unixODBC headers. +// + +template <std::size_t sizeof_long> +struct odbc_types; + +template <> +struct odbc_types<4> +{ + typedef long integer; + typedef unsigned long uinteger; + + typedef integer len; + typedef uinteger ulen; +}; + +template <> +struct odbc_types<8> +{ + typedef int integer; + typedef unsigned int uinteger; + + typedef long len; + typedef unsigned long ulen; +}; + +typedef odbc_types<sizeof (long)>::integer SQLINTEGER; +typedef odbc_types<sizeof (long)>::uinteger SQLUINTEGER; + +#ifndef SQLLEN +typedef odbc_types<sizeof (long)>::len SQLLEN; +typedef odbc_types<sizeof (long)>::ulen SQLULEN; #endif -typedef short SQLSMALLINT; -typedef unsigned short SQLUSMALLINT; +#endif // _WIN32 + +typedef short SQLSMALLINT; +typedef unsigned short SQLUSMALLINT; -typedef SQLSMALLINT SQLRETURN; +typedef SQLSMALLINT SQLRETURN; -typedef void* SQLHANDLE; -typedef SQLHANDLE SQLHENV; -typedef SQLHANDLE SQLHDBC; -typedef SQLHANDLE SQLHSTMT; -typedef SQLHANDLE SQLHDESC; +typedef void* SQLHANDLE; +typedef SQLHANDLE SQLHENV; +typedef SQLHANDLE SQLHDBC; +typedef SQLHANDLE SQLHSTMT; +typedef SQLHANDLE SQLHDESC; // If you get a redefinition error or warning for one of these macros, // then that means you included this header (or one that includes it), diff --git a/odb/mssql/mssql-types.hxx b/odb/mssql/mssql-types.hxx new file mode 100644 index 0000000..2ce7940 --- /dev/null +++ b/odb/mssql/mssql-types.hxx @@ -0,0 +1,133 @@ +// file : odb/mssql/mssql-types.hxx +// author : Constantin Michael <constantin@codesynthesis.com> +// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC +// license : ODB NCUEL; see accompanying LICENSE file + +#ifndef ODB_MSSQL_MSSQL_TYPES_HXX +#define ODB_MSSQL_MSSQL_TYPES_HXX + +#include <odb/pre.hxx> + +#include <cstddef> // std::size_t + +#include <odb/mssql/mssql-fwd.hxx> +#include <odb/mssql/version.hxx> + +namespace odb +{ + namespace mssql + { + enum chunk_type + { + first_chunk, + next_chunk, + last_chunk, + one_chunk, + null_chunk + }; + + typedef void (*param_callback_type) ( + const void* context, // User context. + std::size_t* position, // Position context. Am implementation is free + // to use this to track position information. It + // is initialized to zero before the first call. + const void** buffer, // [out] Buffer contaning the data. + std::size_t* size, // [out] Data size. + chunk_type*, // [out] The position of this chunk of data. + void* temp_buffer, // A temporary buffer that may be used by the + // implementation. + std::size_t capacity); // Capacity of the temporary buffer. + + typedef void (*result_callback_type) ( + void* context, // User context. + std::size_t* position, // Position context. Am implementation is free + // to use this to track position information. It + // is initialized to zero before the first call. + void** buffer, // [out] Buffer to copy the data to. + std::size_t* size, // [in/out] In: amount of data copied into the + // buffer after the previous call. Out: capacity + // of the buffer. + chunk_type, // The position of this chunk; first_chunk means + // this is the first call, last_chunk means there + // is no more data, null_chunk means this value is + // NULL, and one_chunk means the value is empty + // (in this case *size is 0). + std::size_t size_left, // Contains the amount of data left or 0 if this + // information is not available. + void* temp_buffer, // A temporary buffer that may be used by the + // implementation. + std::size_t capacity); // Capacity of the temporary buffer. + + struct long_callback + { + union + { + param_callback_type param; + result_callback_type result; + } callback; + + union + { + const void* param; + void* result; + } context; + }; + + struct bind + { + // This enumeration identifies the possible buffer types that can be + // bound to a parameter or result. In most cases, these map directly + // to SQL_XXX/SQL_C_XXX codes. + // + enum buffer_type + { + bit, // Buffer is a 1-byte integer. + tinyint, // Buffer is a 1-byte integer. + smallint, // Buffer is a 2-byte integer. + int_, // Buffer is a 4-byte integer. + bigint, // Buffer is an 8-byte integer. + + /* + numeric, // Buffer is an SQL_NUMERIC_STRUCT. + + smallmoney, // Buffer is a 4-byte integer (*10,000 value). + money, // Buffer is an 8-byte integer (*10,000 value). + */ + + float4, // Buffer is a float. + float8, // Buffer is a double. + + string, // Buffer is a char array. + long_string, // Buffer is a long_callback. + + nstring, // Buffer is a wchar_t (2-byte) array. + long_nstring, // Buffer is a long_callback. + + binary, // Buffer is a byte array. + long_binary, // Buffer is a long_callback. + + /* + date, // Buffer is an SQL_DATE_STRUCT. + time, // Buffer is an SQL_SS_TIME2_STRUCT. + datetime, // Buffer is an SQL_TIMESTAMP_STRUCT. + datetimeoffset, // Buffer is an SQL_SS_TIMESTAMPOFFSET_STRUCT. + + uuid, // Buffer is a 16-byte array (or SQLGUID). + rowversion, // Buffer is an 8-byte array. + */ + + last // Used as an end of list marker. + }; + + buffer_type type; // The buffer type. + void* buffer; // The buffer. For long data this is a long_callback. + SQLLEN* size_ind; // Pointer to the size/inidicator variable. + SQLLEN capacity; // Buffer capacity. For string/binary parameters + // this value is also used as maximum column size. + }; + } +} + +#include <odb/post.hxx> + +#endif // ODB_MSSQL_MSSQL_TYPES_HXX diff --git a/odb/mssql/mssql.hxx b/odb/mssql/mssql.hxx index 80cff65..8c455ba 100644 --- a/odb/mssql/mssql.hxx +++ b/odb/mssql/mssql.hxx @@ -24,7 +24,37 @@ #include <sqlext.h> // Standard ODBC. //#define _SQLNCLI_ODBC_ -//#include <sqlncli.h> // SQL Server native client driver specifics. +//#include <sqlncli.h> // SQL Server Native Client driver specifics. + +// Instead of having a dependency on <sqlncli.h> (which, BTW, is not +// currently available for the Linux version of the Native Client), +// we are going to provide the few definitions that we need ourselves. +// +#ifndef SQL_SS_LENGTH_UNLIMITED +# define SQL_SS_LENGTH_UNLIMITED 0 +#endif + +#ifndef SQL_COPT_SS_BASE +# define SQL_COPT_SS_BASE 1200 +#endif + +#ifndef SQL_COPT_SS_MARS_ENABLED +# define SQL_COPT_SS_MARS_ENABLED (SQL_COPT_SS_BASE + 24) +#endif + +#ifndef SQL_MARS_ENABLED_NO +# define SQL_MARS_ENABLED_NO 0L +# define SQL_MARS_ENABLED_YES 1L +#endif + +// unixODBC doesn't define SQL_PARAM_DATA_AVAILABLE even though it +// claims ODBC version 3.80. +// +#if ODBCVER >= 0x0380 +# ifndef SQL_PARAM_DATA_AVAILABLE +# define SQL_PARAM_DATA_AVAILABLE 101 +# endif +#endif #include <odb/post.hxx> diff --git a/odb/mssql/statement.cxx b/odb/mssql/statement.cxx new file mode 100644 index 0000000..8e61d82 --- /dev/null +++ b/odb/mssql/statement.cxx @@ -0,0 +1,805 @@ +// file : odb/mssql/statement.cxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include <cstring> // std::strlen +#include <cassert> + +#include <odb/tracer.hxx> + +#include <odb/mssql/mssql.hxx> +#include <odb/mssql/database.hxx> +#include <odb/mssql/connection.hxx> +#include <odb/mssql/statement.hxx> +#include <odb/mssql/exceptions.hxx> +#include <odb/mssql/error.hxx> + +using namespace std; + +namespace odb +{ + namespace mssql + { + // Mapping of bind::buffer_type to SQL_* SQL types. + // + static const SQLSMALLINT sql_type_lookup [bind::last] = + { + SQL_BIT, // bind::bit + SQL_TINYINT, // bind::tinyint + SQL_SMALLINT, // bind::smallint + SQL_INTEGER, // bind::integer + SQL_BIGINT, // bind::bigint + + SQL_REAL, // bind::float4 + SQL_DOUBLE, // bind::float8 + + SQL_VARCHAR, // bind::string + SQL_VARCHAR, // bind::long_string + + SQL_WVARCHAR, // bind::nstring + SQL_WVARCHAR, // bind::long_nstring + + SQL_VARBINARY, // bind::binary + SQL_VARBINARY // bind::long_binary + }; + + // Mapping of bind::buffer_type to SQL_C_* C types. + // + static const SQLSMALLINT c_type_lookup [bind::last] = + { + SQL_C_BIT, // bind::bit + SQL_C_UTINYINT, // bind::tinyint + SQL_C_SSHORT, // bind::smallint + SQL_C_SLONG, // bind::integer + SQL_C_SBIGINT, // bind::bigint + + SQL_C_FLOAT, // bind::float4 + SQL_C_DOUBLE, // bind::float8 + + SQL_C_CHAR, // bind::string + SQL_C_CHAR, // bind::long_string + + SQL_C_WCHAR, // bind::nstring + SQL_C_WCHAR, // bind::long_nstring + + SQL_C_BINARY, // bind::binary + SQL_C_BINARY // bind::long_binary + }; + + // + // statement + // + + statement:: + statement (connection& conn, const string& text) + : conn_ (conn), text_copy_ (text), text_ (text_copy_.c_str ()) + { + init (text_copy_.size ()); + } + + statement:: + statement (connection& conn, const char* text, bool copy) + : conn_ (conn) + { + size_t n; + + if (copy) + { + text_copy_ = text; + text_ = text_copy_.c_str (); + n = text_copy_.size (); + } + else + { + text_ = text; + n = strlen (text_); + } + + init (n); + } + + void statement:: + init (size_t text_size) + { + SQLRETURN r; + + // Allocate the handle. + // + { + SQLHANDLE h; + r = SQLAllocHandle (SQL_HANDLE_STMT, conn_.handle (), &h); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_); + + stmt_.reset (h); + } + + // Disable escape sequences. + // + r = SQLSetStmtAttr (stmt_, + SQL_ATTR_NOSCAN, + (SQLPOINTER) SQL_NOSCAN_OFF, + 0); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + + // Prepare the statement. + // + r = SQLPrepare (stmt_, (SQLCHAR*) text_, (SQLINTEGER) text_size); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + + { + odb::tracer* t; + if ((t = conn_.transaction_tracer ()) || + (t = conn_.tracer ()) || + (t = conn_.database ().tracer ())) + t->prepare (conn_, *this); + } + } + + statement:: + ~statement () + { + { + odb::tracer* t; + if ((t = conn_.transaction_tracer ()) || + (t = conn_.tracer ()) || + (t = conn_.database ().tracer ())) + t->deallocate (conn_, *this); + } + } + + const char* statement:: + text () const + { + return text_; + } + + void statement:: + bind_param (bind* b, size_t n) + { + SQLRETURN r; + + n++; // Parameters are counted from 1. + + for (size_t i (1); i < n; ++i, ++b) + { + SQLULEN col_size; + SQLPOINTER buf; + + switch (b->type) + { + case bind::long_string: + case bind::long_binary: + { + buf = (SQLPOINTER) b; + col_size = b->capacity != 0 + ? (SQLULEN) b->capacity + : SQL_SS_LENGTH_UNLIMITED; + break; + } + case bind::long_nstring: + { + buf = (SQLPOINTER) b; + col_size = b->capacity != 0 + ? (SQLULEN) b->capacity / 2 // In characters, not bytes. + : SQL_SS_LENGTH_UNLIMITED; + break; + } + case bind::string: + case bind::binary: + { + buf = (SQLPOINTER) b->buffer; + col_size = (SQLULEN) b->capacity; + break; + } + case bind::nstring: + { + buf = (SQLPOINTER) b->buffer; + col_size = (SQLULEN) b->capacity / 2; // In characters, not bytes. + break; + } + default: + { + buf = (SQLPOINTER) b->buffer; + break; + } + } + + r = SQLBindParameter ( + stmt_, + (SQLUSMALLINT) i, + SQL_PARAM_INPUT, + c_type_lookup[b->type], + sql_type_lookup[b->type], + col_size, + 0, // decimal digits + buf, + 0, // buffer capacity (shouldn't be needed for input parameters) + b->size_ind); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + } + } + + size_t statement:: + bind_result (bind* b, size_t n) + { + SQLRETURN r; + + size_t i (0); + for (bind* end (b + n); b != end; ++b) + { + switch (b->type) + { + case bind::long_string: + case bind::long_nstring: + case bind::long_binary: + { + // Long data is not bound. + // + continue; + } + default: + { + break; + } + } + + r = SQLBindCol (stmt_, + (SQLUSMALLINT) (i + 1), // Results are counted from 1. + c_type_lookup[b->type], + (SQLPOINTER) b->buffer, + b->capacity, + b->size_ind); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + + ++i; + } + + return i; + } + + SQLRETURN statement:: + execute () + { + { + odb::tracer* t; + if ((t = conn_.transaction_tracer ()) || + (t = conn_.tracer ()) || + (t = conn_.database ().tracer ())) + t->execute (conn_, *this); + } + + SQLRETURN r (SQLExecute (stmt_)); + + if (r == SQL_NEED_DATA) + { + details::buffer& tmp_buf (conn_.long_buffer ()); + + if (tmp_buf.capacity () == 0) + tmp_buf.capacity (4096); + + bind* b; + for (;;) + { + r = SQLParamData (stmt_, (SQLPOINTER*) &b); + + // If we get anything other than SQL_NEED_DATA, then this is + // the return code of SQLExecute(). + // + if (r != SQL_NEED_DATA) + break; + + // See if we have a NULL value. + // + if (*b->size_ind == SQL_NULL_DATA) + { + r = SQLPutData (stmt_, 0, SQL_NULL_DATA); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + } + else + { + long_callback& cb (*static_cast<long_callback*> (b->buffer)); + + size_t position (0); + for (;;) + { + size_t n; + const void* buf; + chunk_type chunk; + + cb.callback.param ( + cb.context.param, + &position, + &buf, + &n, + &chunk, + tmp_buf.data (), + tmp_buf.capacity ()); + + r = SQLPutData ( + stmt_, + (SQLPOINTER) buf, + chunk != null_chunk ? (SQLLEN) n : SQL_NULL_DATA); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + + if (chunk == one_chunk || + chunk == last_chunk || + chunk == null_chunk) + break; + } + } + } + } + + return r; + } + + void statement:: + stream_result (bind* b, size_t i, size_t n) + { + details::buffer& tmp_buf (conn_.long_buffer ()); + + if (tmp_buf.capacity () == 0) + tmp_buf.capacity (4096); + + SQLRETURN r; + + for (bind* end (b + n); b != end; ++b) + { + bool char_data; + + switch (b->type) + { + case bind::long_string: + case bind::long_nstring: + { + char_data = true; + break; + } + case bind::long_binary: + { + char_data = false; + break; + } + default: + { + continue; // Not long data. + } + } + + long_callback& cb (*static_cast<long_callback*> (b->buffer)); + + // First determine if the value is NULL as well as try to + // get the total data size. + // + SQLLEN si; + r = SQLGetData (stmt_, + (SQLUSMALLINT) (i + 1), + c_type_lookup[b->type], + tmp_buf.data (), // Dummy value. + 0, + &si); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + + void* buf; + size_t size (0); + size_t position (0); + size_t size_left (si == SQL_NO_TOTAL ? 0 : static_cast<size_t> (si)); + + chunk_type c (si == SQL_NULL_DATA + ? null_chunk + : (si == 0 ? one_chunk : first_chunk)); + + for (;;) + { + cb.callback.result ( + cb.context.result, + &position, + &buf, + &size, + c, + size_left, + tmp_buf.data (), + tmp_buf.capacity ()); + + if (c == last_chunk || c == one_chunk || c == null_chunk) + break; + + // SQLGetData() can keep returning SQL_SUCCESS_WITH_INFO (truncated) + // with SQL_NO_TOTAL for all the calls except the last one. For the + // last call we should get SQL_SUCCESS and the size_indicator should + // contain a valid value. + // + r = SQLGetData (stmt_, + (SQLUSMALLINT) (i + 1), + c_type_lookup[b->type], + (SQLPOINTER) buf, + (SQLLEN) size, + &si); + + if (r == SQL_SUCCESS) + { + assert (si != SQL_NO_TOTAL); + + // Actual amount of data copied to the buffer (appears not to + // include the NULL teminator). + // + size = static_cast<size_t> (si); + c = last_chunk; + } + else if (r == SQL_SUCCESS_WITH_INFO) + { + if (char_data) + size--; // NULL terminator. + + c = next_chunk; + } + else + translate_error (r, conn_, stmt_); + + // Update the total. + // + if (size_left != 0) + size_left -= size; + } + + ++i; + } + } + + // + // select_statement + // + + select_statement:: + select_statement (connection& conn, + const string& t, + binding& param, + binding& result) + : statement (conn, t), result_ (result), executed_ (false) + { + bind_param (param.bind, param.count); + first_long_ = bind_result (result.bind, result.count); + } + + select_statement:: + select_statement (connection& conn, + const char* t, + binding& param, + binding& result, + bool ct) + : statement (conn, t, ct), result_ (result), executed_ (false) + { + bind_param (param.bind, param.count); + first_long_ = bind_result (result.bind, result.count); + } + + select_statement:: + select_statement (connection& conn, const string& t, binding& result) + : statement (conn, t), result_ (result), executed_ (false) + { + first_long_ = bind_result (result.bind, result.count); + } + + select_statement:: + select_statement (connection& conn, + const char* t, + binding& result, + bool ct) + : statement (conn, t, ct), result_ (result), executed_ (false) + { + first_long_ = bind_result (result.bind, result.count); + } + + select_statement:: + ~select_statement () + { + if (executed_) + { + try + { + free_result (); + } + catch (...) + { + } + } + } + + void select_statement:: + execute () + { + if (executed_) + free_result (); + + SQLRETURN r (statement::execute ()); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + + executed_ = true; + } + + select_statement::result select_statement:: + fetch () + { + SQLRETURN r (SQLFetch (stmt_)); + + if (r == SQL_NO_DATA) + return no_data; + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + + return success; + } + + void select_statement:: + free_result () + { + if (executed_) + { + // If we cannot close the cursor, there is no point in trying again. + // + executed_ = false; + + SQLRETURN r (SQLCloseCursor (stmt_)); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + } + } + + // + // insert_statement + // + + insert_statement:: + ~insert_statement () + { + } + + insert_statement:: + insert_statement (connection& conn, + const string& t, + binding& param, + bool returning) + : statement (conn, t), returning_ (returning) + { + bind_param (param.bind, param.count); + + if (returning) + init_result (); + } + + insert_statement:: + insert_statement (connection& conn, + const char* t, + binding& param, + bool returning, + bool ct) + : statement (conn, t, ct), returning_ (returning) + { + bind_param (param.bind, param.count); + + if (returning) + init_result (); + } + + void insert_statement:: + init_result () + { + SQLRETURN r ( + SQLBindCol (stmt_, + 1, + SQL_C_SBIGINT, + (SQLPOINTER) &id_, + sizeof (id_), + &id_size_ind_)); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + } + + bool insert_statement:: + execute () + { + SQLRETURN r (statement::execute ()); + + if (!SQL_SUCCEEDED (r)) + { + // Translate the integrity contraint violation (SQLSTATE 23000) + // to the flase return value. This code is similar to that found + // in translate_error(). + // + char sqlstate[SQL_SQLSTATE_SIZE + 1]; + SQLINTEGER native_code; + SQLSMALLINT msg_size; + + bool cv (false); + + for (SQLSMALLINT i (1);; ++i) + { + SQLRETURN r (SQLGetDiagRec (SQL_HANDLE_STMT, + stmt_, + i, + (SQLCHAR*) sqlstate, + &native_code, + 0, + 0, + &msg_size)); + + if (r == SQL_NO_DATA) + break; + else if (SQL_SUCCEEDED (r)) + { + string s (sqlstate); + + if (s == "23000") // Integrity contraint violation. + cv = true; + else if (s != "01000") // General warning. + { + // Some other code. + // + cv = false; + break; + } + } + else + { + // SQLGetDiagRec() failure. + // + cv = false; + break; + } + } + + if (cv) + return false; + else + translate_error (r, conn_, stmt_); + } + + // Fetch the row containing the id if this statement is returning. + // + if (returning_) + { + r = SQLFetch (stmt_); + + if (r != SQL_NO_DATA && !SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + + { + SQLRETURN r (SQLCloseCursor (stmt_)); // Don't overwrite r. + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + } + + if (r == SQL_NO_DATA) + throw database_exception ( + 0, + "?????", + "result set expected from a statement with the OUTPUT clause"); + } + + return true; + } + + // + // update_statement + // + + update_statement:: + ~update_statement () + { + } + + update_statement:: + update_statement (connection& conn, const string& t, binding& param) + : statement (conn, t) + { + bind_param (param.bind, param.count); + } + + update_statement:: + update_statement (connection& conn, + const char* t, + binding& param, + bool ct) + : statement (conn, t, ct) + { + bind_param (param.bind, param.count); + } + + unsigned long long update_statement:: + execute () + { + SQLRETURN r (statement::execute ()); + + // SQL_NO_DATA indicates that the statement hasn't affected any rows. + // + if (r == SQL_NO_DATA) + return 0; + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + + // Get the number of affected rows. + // + SQLLEN rows; + r = SQLRowCount (stmt_, &rows); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + + return static_cast<unsigned long long> (rows); + } + + // + // delete_statement + // + + delete_statement:: + ~delete_statement () + { + } + + delete_statement:: + delete_statement (connection& conn, const string& t, binding& param) + : statement (conn, t) + { + bind_param (param.bind, param.count); + } + + delete_statement:: + delete_statement (connection& conn, + const char* t, + binding& param, + bool ct) + : statement (conn, t, ct) + { + bind_param (param.bind, param.count); + } + + unsigned long long delete_statement:: + execute () + { + SQLRETURN r (statement::execute ()); + + // SQL_NO_DATA indicates that the statement hasn't affected any rows. + // + if (r == SQL_NO_DATA) + return 0; + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + + // Get the number of affected rows. + // + SQLLEN rows; + r = SQLRowCount (stmt_, &rows); + + if (!SQL_SUCCEEDED (r)) + translate_error (r, conn_, stmt_); + + return static_cast<unsigned long long> (rows); + } + } +} diff --git a/odb/mssql/statement.hxx b/odb/mssql/statement.hxx new file mode 100644 index 0000000..15e64a0 --- /dev/null +++ b/odb/mssql/statement.hxx @@ -0,0 +1,228 @@ +// file : odb/mssql/statement.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_MSSQL_STATEMENT_HXX +#define ODB_MSSQL_STATEMENT_HXX + +#include <odb/pre.hxx> + +#include <string> +#include <cstddef> // std::size_t + +#include <odb/forward.hxx> +#include <odb/statement.hxx> + +#include <odb/mssql/mssql-fwd.hxx> +#include <odb/mssql/version.hxx> +#include <odb/mssql/binding.hxx> +#include <odb/mssql/auto-handle.hxx> + +#include <odb/mssql/details/export.hxx> + +namespace odb +{ + namespace mssql + { + class connection; + + class LIBODB_MSSQL_EXPORT statement: public odb::statement + { + public: + virtual + ~statement () = 0; + + SQLHSTMT + handle () const + { + return stmt_; + } + + virtual const char* + text () const; + + protected: + statement (connection&, const std::string& text); + statement (connection&, const char* text, bool copy_text); + + private: + void + init (std::size_t text_size); + + protected: + void + bind_param (bind*, std::size_t count); + + std::size_t + bind_result (bind*, std::size_t count); + + SQLRETURN + execute (); + + void + stream_result (bind*, std::size_t start, std::size_t count); + + protected: + connection& conn_; + std::string text_copy_; + const char* text_; + auto_handle<SQL_HANDLE_STMT> stmt_; + }; + + class LIBODB_MSSQL_EXPORT select_statement: public statement + { + public: + virtual + ~select_statement (); + + // While the long data columns can appear in any order in the + // result binding, they should appear last in the statement + // text. + // + select_statement (connection& conn, + const std::string& text, + binding& param, + binding& result); + + select_statement (connection& conn, + const char* text, + binding& param, + binding& result, + bool copy_text = true); + + select_statement (connection& conn, + const std::string& text, + binding& result); + + select_statement (connection& conn, + const char* text, + binding& result, + bool copy_text = true); + + enum result + { + success, + no_data + }; + + void + execute (); + + result + fetch (); + + void + stream_result () + { + if (first_long_ != result_.count) + statement::stream_result (result_.bind, first_long_, result_.count); + } + + void + free_result (); + + private: + select_statement (const select_statement&); + select_statement& operator= (const select_statement&); + + private: + binding& result_; + std::size_t first_long_; // First long data column. + bool executed_; + }; + + class LIBODB_MSSQL_EXPORT insert_statement: public statement + { + public: + virtual + ~insert_statement (); + + insert_statement (connection& conn, + const std::string& text, + binding& param, + bool returning); + + insert_statement (connection& conn, + const char* text, + binding& param, + bool returning, + bool copy_text = true); + + // 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 id_; + } + + private: + insert_statement (const insert_statement&); + insert_statement& operator= (const insert_statement&); + + private: + void + init_result (); + + private: + bool returning_; + unsigned long long id_; + SQLLEN id_size_ind_; + }; + + class LIBODB_MSSQL_EXPORT update_statement: public statement + { + public: + virtual + ~update_statement (); + + update_statement (connection& conn, + const std::string& text, + binding& param); + + update_statement (connection& conn, + const char* text, + binding& param, + bool copy_text = true); + + unsigned long long + execute (); + + private: + update_statement (const update_statement&); + update_statement& operator= (const update_statement&); + }; + + class LIBODB_MSSQL_EXPORT delete_statement: public statement + { + public: + virtual + ~delete_statement (); + + delete_statement (connection& conn, + const std::string& text, + binding& param); + + delete_statement (connection& conn, + const char* text, + binding& param, + bool copy_text = true); + + unsigned long long + execute (); + + private: + delete_statement (const delete_statement&); + delete_statement& operator= (const delete_statement&); + }; + } +} + +#include <odb/post.hxx> + +#endif // ODB_MSSQL_STATEMENT_HXX diff --git a/odb/mssql/tracer.cxx b/odb/mssql/tracer.cxx new file mode 100644 index 0000000..023d192 --- /dev/null +++ b/odb/mssql/tracer.cxx @@ -0,0 +1,62 @@ +// file : odb/mssql/tracer.cxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : ODB NCUEL; see accompanying LICENSE file + +#include <odb/mssql/tracer.hxx> +#include <odb/mssql/connection.hxx> +#include <odb/mssql/statement.hxx> + +namespace odb +{ + namespace mssql + { + tracer:: + ~tracer () + { + } + + void tracer:: + prepare (connection&, const statement&) + { + } + + void tracer:: + execute (connection& c, const statement& s) + { + execute (c, s.text ()); + } + + void tracer:: + deallocate (connection&, const statement&) + { + } + + void tracer:: + prepare (odb::connection& c, const odb::statement& s) + { + prepare (static_cast<connection&> (c), + static_cast<const statement&> (s)); + } + + void tracer:: + execute (odb::connection& c, const odb::statement& s) + { + execute (static_cast<connection&> (c), + static_cast<const statement&> (s)); + } + + void tracer:: + execute (odb::connection& c, const char* s) + { + execute (static_cast<connection&> (c), s); + } + + void tracer:: + deallocate (odb::connection& c, const odb::statement& s) + { + deallocate (static_cast<connection&> (c), + static_cast<const statement&> (s)); + } + } +} diff --git a/odb/mssql/tracer.hxx b/odb/mssql/tracer.hxx new file mode 100644 index 0000000..46c7c48 --- /dev/null +++ b/odb/mssql/tracer.hxx @@ -0,0 +1,63 @@ +// file : odb/mssql/tracer.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : ODB NCUEL; see accompanying LICENSE file + +#ifndef ODB_MSSQL_TRACER_HXX +#define ODB_MSSQL_TRACER_HXX + +#include <odb/pre.hxx> + +#include <odb/tracer.hxx> + +#include <odb/mssql/version.hxx> +#include <odb/mssql/forward.hxx> +#include <odb/mssql/details/export.hxx> + +namespace odb +{ + namespace mssql + { + class LIBODB_MSSQL_EXPORT tracer: private odb::tracer + { + public: + virtual + ~tracer (); + + virtual void + prepare (connection&, const statement&); + + virtual void + execute (connection&, const statement&); + + virtual void + execute (connection&, const char* statement) = 0; + + virtual void + deallocate (connection&, const statement&); + + private: + // Allow these classes to convert mssql::tracer to odb::tracer. + // + friend class database; + friend class connection; + friend class transaction; + + virtual void + prepare (odb::connection&, const odb::statement&); + + virtual void + execute (odb::connection&, const odb::statement&); + + virtual void + execute (odb::connection&, const char* statement); + + virtual void + deallocate (odb::connection&, const odb::statement&); + }; + } +} + +#include <odb/post.hxx> + +#endif // ODB_MSSQL_TRACER_HXX diff --git a/odb/mssql/transaction-impl.cxx b/odb/mssql/transaction-impl.cxx index 308f078..68fee22 100644 --- a/odb/mssql/transaction-impl.cxx +++ b/odb/mssql/transaction-impl.cxx @@ -43,14 +43,11 @@ namespace odb odb::transaction_impl::connection_ = connection_.get (); } - /* - @@ TODO { odb::tracer* t; if ((t = connection_->tracer ()) || (t = database_.tracer ())) t->execute (*connection_, "BEGIN"); } - */ // In ODBC a transaction is started automatically before the first // statement is executed. @@ -60,14 +57,11 @@ namespace odb void transaction_impl:: commit () { - /* - @@ TODO { odb::tracer* t; if ((t = connection_->tracer ()) || (t = database_.tracer ())) t->execute (*connection_, "COMMIT"); } - */ SQLRETURN r ( SQLEndTran (SQL_HANDLE_DBC, connection_->handle (), SQL_COMMIT)); @@ -84,14 +78,11 @@ namespace odb void transaction_impl:: rollback () { - /* - @@ TODO { odb::tracer* t; if ((t = connection_->tracer ()) || (t = database_.tracer ())) t->execute (*connection_, "ROLLBACK"); } - */ SQLRETURN r ( SQLEndTran (SQL_HANDLE_DBC, connection_->handle (), SQL_ROLLBACK)); diff --git a/odb/mssql/transaction.hxx b/odb/mssql/transaction.hxx index 57806b8..9837401 100644 --- a/odb/mssql/transaction.hxx +++ b/odb/mssql/transaction.hxx @@ -3,8 +3,6 @@ // copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC // license : ODB NCUEL; see accompanying LICENSE file -//@@ disabled functionality - #ifndef ODB_MSSQL_TRANSACTION_HXX #define ODB_MSSQL_TRANSACTION_HXX @@ -14,7 +12,7 @@ #include <odb/mssql/version.hxx> #include <odb/mssql/forward.hxx> -//#include <odb/mssql/tracer.hxx> +#include <odb/mssql/tracer.hxx> #include <odb/mssql/details/export.hxx> @@ -54,7 +52,6 @@ namespace odb static void current (transaction&); - /* // SQL statement tracing. // public: @@ -73,7 +70,6 @@ namespace odb } using odb::transaction::tracer; - */ public: transaction_impl& |