ODBC database can be accessed asynchronously.

znone

2020-12-02 50457f28fa7567b81ccf6a423e09312d5587cfbc

 include/qtl_odbc.hpp

@@ -16,12 +16,13 @@
#include <sys/time.h>
#endif //_WIN32

#if (ODBCVER >= 0x0380) && (WIN32_WINNT >= 0x0602)
#if (ODBCVER >= 0x0380) && (_WIN32_WINNT >= 0x0602)
#define QTL_ODBC_ENABLE_ASYNC_MODE 1
#endif //ODBC 3.80 && Windows


#include "qtl_common.hpp"
#include "qtl_async.hpp"

namespace qtl
{
@@ -30,16 +31,17 @@
{

template<SQLSMALLINT> class object;
class database;
class base_database;

class error : public std::exception
{
public:
   error() : m_errno(SQL_SUCCESS) { }
   template<SQLSMALLINT Type>
   error(const object<Type>& h, SQLINTEGER code);
   error(SQLINTEGER code, const char* msg) : m_errno(code), m_errmsg(msg) { }
   SQLINTEGER code() const { return m_errno; }
   operator bool() const { return m_errno!=SQL_SUCCESS || m_errno!=SQL_SUCCESS_WITH_INFO; }
   operator bool() const { return m_errno!=SQL_SUCCESS && m_errno!=SQL_SUCCESS_WITH_INFO; }
   virtual const char* what() const throw() override { return m_errmsg.data(); }
private:
   SQLINTEGER m_errno;
@@ -129,7 +131,7 @@
   virtual bool read_blob(char* buffer, off_type& count, pos_type position) override
   {
      SQLLEN indicator=0;
      SQLRETURN ret = SQLGetData(m_stmt->handle(), m_field + 1, SQL_C_BINARY, buffer, count, const_cast<SQLLEN*>(&indicator));
      SQLRETURN ret = SQLGetData(m_stmt->handle(), m_field + 1, SQL_C_BINARY, buffer, static_cast<SQLINTEGER>(count), const_cast<SQLLEN*>(&indicator));
      if (ret != SQL_NO_DATA)
      {
         count = (indicator > count) || (indicator == SQL_NO_TOTAL) ?
@@ -151,7 +153,12 @@
public:
   environment() : object(SQL_NULL_HANDLE) 
   {
      verify_error(SQLSetEnvAttr(m_handle, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0));
#if ODBCVER >= 0x0380
      const SQLPOINTER version = (SQLPOINTER)SQL_OV_ODBC3_80;
#else
      const SQLPOINTER version = (SQLPOINTER)SQL_OV_ODBC3;
#endif
      verify_error(SQLSetEnvAttr(m_handle, SQL_ATTR_ODBC_VERSION, version, SQL_IS_INTEGER));
   }
   environment(environment&& src) : object(std::forward<environment>(src)) { }

@@ -163,28 +170,28 @@
   }
};

class statement final : public object<SQL_HANDLE_STMT>
class base_statement : public object<SQL_HANDLE_STMT>
{
public:
   explicit statement(database& db);
   statement(statement&& src) 
      : object(std::forward<statement>(src)), m_params(std::forward<std::vector<param_data>>(src.m_params))
   explicit base_statement(base_database& db);
   base_statement(base_statement&& src) 
      : object(std::forward<base_statement>(src)), m_params(std::forward<std::vector<param_data>>(src.m_params))
   {
      m_binded_cols=src.m_binded_cols;
      src.m_binded_cols=false;
      m_blob_buffer=src.m_blob_buffer;
      src.m_blob_buffer=NULL;
   }
   ~statement()
   ~base_statement()
   {
      if(m_blob_buffer)
         free(m_blob_buffer);
   }
   statement& operator=(statement&& src)
   base_statement& operator=(base_statement&& src)
   {
      if(this!=&src)
      {
         object::operator =(std::forward<statement>(src));
         object::operator =(std::forward<base_statement>(src));
         m_params=std::forward<std::vector<param_data>>(src.m_params);
         m_binded_cols=src.m_binded_cols;
         src.m_binded_cols=false;
@@ -194,141 +201,132 @@
      return *this;
   }

   void open(const char* query_text, size_t text_length=SQL_NTS)
   {
      verify_error(SQLPrepare(m_handle, (SQLCHAR*)query_text, text_length));
   }
   void open(const std::string& query_text)
   {
      open(query_text.data(), query_text.size());
   }

   void bind_param(SQLUSMALLINT index, const std::nullptr_t&)
   void bind_param(size_t index, const std::nullptr_t&)
   {
      m_params[index].m_indicator=SQL_NULL_DATA;
      verify_error(SQLBindParameter(m_handle, index+1, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), 
         SQL_PARAM_INPUT, SQL_C_DEFAULT, SQL_DEFAULT, 0, 0, NULL, 0, &m_params[index].m_indicator));
   }
   void bind_param(SQLUSMALLINT index, const qtl::null&)
   void bind_param(size_t index, const qtl::null&)
   {
      bind_param(index, nullptr);
   }
   void bind_param(SQLUSMALLINT index, const int8_t& v)
   void bind_param(size_t index, const int8_t& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_STINYINT, SQL_TINYINT, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_STINYINT, SQL_TINYINT, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const uint8_t& v)
   void bind_param(size_t index, const uint8_t& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_UTINYINT, SQL_TINYINT, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_UTINYINT, SQL_TINYINT, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const int16_t& v)
   void bind_param(size_t index, const int16_t& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_SMALLINT, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_SMALLINT, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const uint16_t& v)
   void bind_param(size_t index, const uint16_t& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_USHORT, SQL_SMALLINT, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_USHORT, SQL_SMALLINT, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const int32_t& v)
   void bind_param(size_t index, const int32_t& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const uint32_t& v)
   void bind_param(size_t index, const uint32_t& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const int64_t& v)
   void bind_param(size_t index, const int64_t& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_SBIGINT, SQL_BIGINT, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_SBIGINT, SQL_BIGINT, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const uint64_t& v)
   void bind_param(size_t index, const uint64_t& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_UBIGINT, SQL_BIGINT, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_UBIGINT, SQL_BIGINT, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const double& v)
   void bind_param(size_t index, const double& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const float& v)
   void bind_param(size_t index, const float& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_FLOAT, SQL_FLOAT, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_FLOAT, SQL_FLOAT, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const bool& v)
   void bind_param(size_t index, const bool& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_BIT, SQL_BIT, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_BIT, SQL_BIT, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const DATE_STRUCT& v)
   void bind_param(size_t index, const DATE_STRUCT& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_DATE, SQL_DATE, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_DATE, SQL_DATE, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const TIME_STRUCT& v)
   void bind_param(size_t index, const TIME_STRUCT& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_TIME, SQL_TIME, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_TIME, SQL_TIME, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const TIMESTAMP_STRUCT& v)
   void bind_param(size_t index, const TIMESTAMP_STRUCT& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_TIMESTAMP, SQL_TIMESTAMP, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_TIMESTAMP, SQL_TIMESTAMP, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const SQLGUID& v)
   void bind_param(size_t index, const SQLGUID& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_GUID, SQL_GUID, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_GUID, SQL_GUID, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const SQL_NUMERIC_STRUCT& v)
   void bind_param(size_t index, const SQL_NUMERIC_STRUCT& v)
   {
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_NUMERIC, SQL_NUMERIC, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_NUMERIC, SQL_NUMERIC, 
         0, 0, (SQLPOINTER)&v, 0, NULL));
   }
   void bind_param(SQLUSMALLINT index, const char* v, size_t n=SQL_NTS, SQLULEN size=0)
   void bind_param(size_t index, const char* v, size_t n=SQL_NTS, SQLULEN size=0)
   {
      m_params[index].m_indicator=n;
      if(size==0) size=strlen(v);
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 
         size, 0, (SQLPOINTER)v, 0, &m_params[index].m_indicator));
   }
   void bind_param(SQLUSMALLINT index, const wchar_t* v, size_t n=SQL_NTS, SQLULEN size=0)
   void bind_param(size_t index, const wchar_t* v, size_t n=SQL_NTS, SQLULEN size=0)
   {
      m_params[index].m_indicator=n;
      if(size==0) size=wcslen(v);
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_WCHAR, SQL_WCHAR, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_WCHAR, SQL_WCHAR, 
         size, 0, (SQLPOINTER)v, 0, &m_params[index].m_indicator));
   }
   void bind_param(SQLUSMALLINT index, const std::string& v)
   void bind_param(size_t index, const std::string& v)
   {
      bind_param(index, v.data(), v.size(), v.size());
   }
   void bind_param(SQLUSMALLINT index, const std::wstring& v)
   void bind_param(size_t index, const std::wstring& v)
   {
      bind_param(index, v.data(), v.size(), v.size());
   }
   void bind_param(SQLUSMALLINT index, const const_blob_data& v)
   void bind_param(size_t index, const const_blob_data& v)
   {
      m_params[index].m_indicator=v.size;
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_BINARY, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_BINARY, SQL_BINARY, 
         v.size, 0, (SQLPOINTER)v.data, 0, &m_params[index].m_indicator));
   }
   void bind_param(SQLUSMALLINT index, std::istream& s)
   void bind_param(size_t index, std::istream& s)
   {
      if(m_blob_buffer==NULL)
         m_blob_buffer=malloc(blob_buffer_size);
      m_params[index].m_data=m_blob_buffer;
      m_params[index].m_size=blob_buffer_size;
      m_params[index].m_indicator=SQL_LEN_DATA_AT_EXEC(m_params[index].m_size);
      verify_error(SQLBindParameter(m_handle, index+1, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_LONGVARBINARY, 
      verify_error(SQLBindParameter(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_PARAM_INPUT, SQL_C_BINARY, SQL_LONGVARBINARY, 
         INT_MAX, 0, &m_params[index], 0, &m_params[index].m_indicator));
      m_params[index].m_after_fetch=[this, &s](const param_data& p) {
         SQLLEN readed=SQL_NULL_DATA;
@@ -344,86 +342,86 @@
      };
   }

   void bind_param(SQLUSMALLINT index, const blob_writer& param)
   void bind_param(size_t index, const blob_writer& param)
   {
      m_params[index].m_data = nullptr;
      m_params[index].m_size = blob_buffer_size;
      m_params[index].m_indicator = SQL_LEN_DATA_AT_EXEC(m_params[index].m_size);
      verify_error(SQLBindParameter(m_handle, index + 1, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_LONGVARBINARY,
      verify_error(SQLBindParameter(m_handle, static_cast<SQLSMALLINT>(index + 1), SQL_PARAM_INPUT, SQL_C_BINARY, SQL_LONGVARBINARY,
         INT_MAX, 0, &m_params[index], 0, &m_params[index].m_indicator));
      m_params[index].m_after_fetch = [this, index, &param](const param_data& b) {
         blobbuf buf;
         buf.open(this, index, std::ios::out);
         buf.open(this, static_cast<SQLSMALLINT>(index), std::ios::out);
         std::ostream s(&buf);
         param(s);
      };
   }

   void bind_field(SQLUSMALLINT index, bool&& v)
   void bind_field(size_t index, bool&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_BIT, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_BIT, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, int8_t&& v)
   void bind_field(size_t index, int8_t&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_STINYINT, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_STINYINT, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, uint8_t&& v)
   void bind_field(size_t index, uint8_t&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_UTINYINT, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_UTINYINT, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, int16_t&& v)
   void bind_field(size_t index, int16_t&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_SSHORT, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_SSHORT, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, uint16_t&& v)
   void bind_field(size_t index, uint16_t&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_USHORT, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_USHORT, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, int32_t&& v)
   void bind_field(size_t index, int32_t&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_SLONG, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_SLONG, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, uint32_t&& v)
   void bind_field(size_t index, uint32_t&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_ULONG, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_ULONG, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, int64_t&& v)
   void bind_field(size_t index, int64_t&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_SBIGINT, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_SBIGINT, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, uint64_t&& v)
   void bind_field(size_t index, uint64_t&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_UBIGINT, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_UBIGINT, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, float&& v)
   void bind_field(size_t index, float&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_FLOAT, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_FLOAT, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, double&& v)
   void bind_field(size_t index, double&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_DOUBLE, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_DOUBLE, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, DATE_STRUCT&& v)
   void bind_field(size_t index, DATE_STRUCT&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_TYPE_DATE, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_TYPE_DATE, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, TIME_STRUCT&& v)
   void bind_field(size_t index, TIME_STRUCT&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_TYPE_TIME, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_TYPE_TIME, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, TIMESTAMP_STRUCT&& v)
   void bind_field(size_t index, TIMESTAMP_STRUCT&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_TYPE_TIMESTAMP, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_TYPE_TIMESTAMP, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, SQLGUID&& v)
   void bind_field(size_t index, SQLGUID&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_GUID, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_GUID, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, SQL_NUMERIC_STRUCT&& v)
   void bind_field(size_t index, SQL_NUMERIC_STRUCT&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_NUMERIC, &v, 0, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_NUMERIC, &v, 0, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, char* v, size_t n)
   void bind_field(size_t index, char* v, size_t n)
   {
      m_params[index].m_data=v;
      m_params[index].m_size=n;
@@ -436,9 +434,9 @@
            text[p.m_indicator]='\0';
         }
      };
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_CHAR, v, n, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_CHAR, v, n, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, wchar_t* v, size_t n)
   void bind_field(size_t index, wchar_t* v, size_t n)
   {
      m_params[index].m_data=v;
      m_params[index].m_size=n;
@@ -451,13 +449,13 @@
            text[p.m_indicator]='\0';
         }
      };
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_WCHAR, v, n, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_WCHAR, v, n, &m_params[index].m_indicator));
   }
   template<typename T>
   void bind_field(SQLUSMALLINT index, qtl::bind_string_helper<T>&& v)
   void bind_field(size_t index, qtl::bind_string_helper<T>&& v)
   {
      SQLLEN length=0;
      verify_error(SQLColAttribute(m_handle, index+1, SQL_DESC_LENGTH, NULL, 0, NULL, &length));
      verify_error(SQLColAttribute(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_DESC_LENGTH, NULL, 0, NULL, &length));
      typename qtl::bind_string_helper<T>::char_type* data=v.alloc(length);
      bind_field(index, data, length+1);
      m_params[index].m_after_fetch=[v](const param_data& p) mutable {
@@ -468,49 +466,49 @@
      };
   }
   template<size_t N>
   void bind_field(SQLUSMALLINT index, std::array<char, N>&& value)
   void bind_field(size_t index, std::array<char, N>&& value)
   {
      bind_field(index, value.data(), value.size());
   }
   template<size_t N>
   void bind_field(SQLUSMALLINT index, std::array<wchar_t, N>&& value)
   void bind_field(size_t index, std::array<wchar_t, N>&& value)
   {
      bind_field(index, value.data(), value.size());
   }
   void bind_field(SQLUSMALLINT index, qtl::blob_data&& v)
   void bind_field(size_t index, qtl::blob_data&& v)
   {
      verify_error(SQLBindCol(m_handle, index+1, SQL_C_BINARY, v.data, v.size, &m_params[index].m_indicator));
      verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_BINARY, v.data, v.size, &m_params[index].m_indicator));
   }
   void bind_field(SQLUSMALLINT index, std::ostream&& v)
   void bind_field(size_t index, std::ostream&& v)
   {
      if(m_blob_buffer==NULL)
         m_blob_buffer=malloc(blob_buffer_size);
      m_params[index].m_data=m_blob_buffer;
      m_params[index].m_size=blob_buffer_size;
      m_params[index].m_after_fetch=[this, index, &v](const param_data& p) {
         SQLRETURN ret=SQLGetData(m_handle, index+1, SQL_C_BINARY, p.m_data, p.m_size, const_cast<SQLLEN*>(&p.m_indicator));
         SQLRETURN ret=SQLGetData(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_BINARY, p.m_data, p.m_size, const_cast<SQLLEN*>(&p.m_indicator));
         while(ret!=SQL_NO_DATA)
         {
            size_t n = (p.m_indicator > blob_buffer_size) || (p.m_indicator == SQL_NO_TOTAL) ?
               blob_buffer_size : p.m_indicator;
            verify_error(ret);
            v.write((const char*)p.m_data, n);
            ret=SQLGetData(m_handle, index+1, SQL_C_BINARY, p.m_data, p.m_size, const_cast<SQLLEN*>(&p.m_indicator));
            ret=SQLGetData(m_handle, static_cast<SQLUSMALLINT>(index+1), SQL_C_BINARY, p.m_data, p.m_size, const_cast<SQLLEN*>(&p.m_indicator));
         }
      };
   }

   void bind_field(SQLUSMALLINT index, blobbuf&& value)
   void bind_field(size_t index, blobbuf&& value)
   {
      m_params[index].m_data = nullptr;
      m_params[index].m_size = 0;
      m_params[index].m_after_fetch = [this, index, &value](const param_data& p) {
         value.open(this, index, std::ios::in);
         value.open(this, static_cast<SQLSMALLINT>(index), std::ios::in);
      };
   }

   template<typename Type>
   void bind_field(SQLUSMALLINT index, indicator<Type>&& value)
   void bind_field(size_t index, indicator<Type>&& value)
   {
      qtl::bind_field(*this, index, value.data);
      param_data& param=m_params[index];
@@ -536,7 +534,7 @@
#ifdef _QTL_ENABLE_CPP17

   template<typename Type>
   void bind_field(SQLUSMALLINT index, std::optional<Type>&& value)
   void bind_field(size_t index, std::optional<Type>&& value)
   {
      qtl::bind_field(*this, index, *value);
      param_data& param = m_params[index];
@@ -548,7 +546,7 @@
      };
   }

   void bind_field(SQLUSMALLINT index, std::any&& value)
   void bind_field(size_t index, std::any&& value)
   {
      SQLLEN type = 0, isUnsigned=SQL_FALSE;
      verify_error(SQLColAttribute(m_handle, index + 1, SQL_DESC_TYPE, NULL, 0, NULL, &type));
@@ -672,90 +670,6 @@
   }

#endif // C++17
   template<typename Types>
   void execute(const Types& params)
   {
      SQLSMALLINT count=0;
      verify_error(SQLNumParams(m_handle, &count));
      if(count>0)
      {
         m_params.resize(count);
         qtl::bind_params(*this, params);
      }

      SQLRETURN ret=SQLExecute(m_handle);
      verify_error(ret);
      if(ret==SQL_NEED_DATA)
      {
         SQLPOINTER token;
         size_t i=0;
         ret=SQLParamData(m_handle, &token);
         verify_error(ret);
         while(ret==SQL_NEED_DATA)
         {
            while(i!=count)
            {
               if(&m_params[i]==token)
               {
                  if(m_params[i].m_after_fetch)
                     m_params[i].m_after_fetch(m_params[i]);
                  break;
               }
               ++i;
            }
            ret=SQLParamData(m_handle, &token);
            verify_error(ret);
         }
      }
   }

   template<typename Types>
   bool fetch(Types&& values)
   {
      if(!m_binded_cols)
      {
         SQLSMALLINT count=0;
         verify_error(SQLNumResultCols(m_handle, &count));
         if(count>0)
         {
            m_params.resize(count);
            qtl::bind_record(*this, std::forward<Types>(values));
         }
         m_binded_cols=true;
      }
      return fetch();
   }

   bool fetch()
   {
      SQLRETURN ret=SQLFetch(m_handle);
      if(ret==SQL_SUCCESS || ret==SQL_SUCCESS_WITH_INFO)
      {
         for(const param_data& data : m_params)
         {
            if(data.m_after_fetch)
               data.m_after_fetch(data);
         }
         return true;
      }
      verify_error(ret);
      return false;
   }

   bool next_result()
   {
      SQLRETURN ret;
      SQLSMALLINT count=0;
      m_binded_cols=false;
      do
      {
         ret=SQLMoreResults(m_handle);
         if(ret==SQL_ERROR || ret==SQL_INVALID_HANDLE)
            verify_error(ret);
         verify_error(SQLNumResultCols(m_handle, &count));
      }while(count==0);
      return ret==SQL_SUCCESS || ret==SQL_SUCCESS_WITH_INFO;
   }

   SQLLEN affetced_rows()
   {
@@ -784,6 +698,11 @@
      return -1;
   }

   void reset()
   {
      verify_error(SQLFreeStmt(m_handle, SQL_RESET_PARAMS));
   }

   /*
      ODBC do not support this function, but you can use query to instead it:
      For MS SQL Server: SELECT @@IDENTITY;
@@ -796,12 +715,7 @@
      return 0;
   }*/

   void reset()
   {
      verify_error(SQLFreeStmt(m_handle, SQL_RESET_PARAMS));
   }

private:
protected:
   struct param_data
   {
      SQLPOINTER m_data;
@@ -814,6 +728,119 @@
   SQLPOINTER m_blob_buffer;
   std::vector<param_data> m_params;
   bool m_binded_cols;
};

class statement : public base_statement
{
public:
   statement() = default;
   explicit statement(base_database& db) : base_statement(db) { }
   statement(statement&& src) : base_statement(std::move(src)) { }
   statement& operator=(statement&& src)
   {
      base_statement::operator =(std::move(src));
      return *this;
   }
   ~statement()
   {
      close();
   }

   void open(const char* query_text, size_t text_length = SQL_NTS)
   {
      reset();
      verify_error(SQLPrepareA(m_handle, (SQLCHAR*)query_text, text_length));
   }
   void open(const std::string& query_text)
   {
      open(query_text.data(), query_text.size());
   }


   template<typename Types>
   void execute(const Types& params)
   {
      SQLSMALLINT count = 0;
      verify_error(SQLNumParams(m_handle, &count));
      if (count > 0)
      {
         m_params.resize(count);
         qtl::bind_params(*this, params);
      }

      SQLRETURN ret = SQLExecute(m_handle);
      verify_error(ret);
      if (ret == SQL_NEED_DATA)
      {
         SQLPOINTER token;
         size_t i = 0;
         ret = SQLParamData(m_handle, &token);
         verify_error(ret);
         while (ret == SQL_NEED_DATA)
         {
            while (i != count)
            {
               if (&m_params[i] == token)
               {
                  if (m_params[i].m_after_fetch)
                     m_params[i].m_after_fetch(m_params[i]);
                  break;
               }
               ++i;
            }
            ret = SQLParamData(m_handle, &token);
            verify_error(ret);
         }
      }
   }

   template<typename Types>
   bool fetch(Types&& values)
   {
      if (!m_binded_cols)
      {
         SQLSMALLINT count = 0;
         verify_error(SQLNumResultCols(m_handle, &count));
         if (count > 0)
         {
            m_params.resize(count);
            qtl::bind_record(*this, std::forward<Types>(values));
         }
         m_binded_cols = true;
      }
      return fetch();
   }

   bool fetch()
   {
      SQLRETURN ret = SQLFetch(m_handle);
      if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO)
      {
         for (const param_data& data : m_params)
         {
            if (data.m_after_fetch)
               data.m_after_fetch(data);
         }
         return true;
      }
      verify_error(ret);
      return false;
   }

   bool next_result()
   {
      SQLRETURN ret;
      SQLSMALLINT count = 0;
      m_binded_cols = false;
      do
      {
         ret = SQLMoreResults(m_handle);
         if (ret == SQL_ERROR || ret == SQL_INVALID_HANDLE)
            verify_error(ret);
         verify_error(SQLNumResultCols(m_handle, &count));
      } while (count == 0);
      return ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO;
   }
};

struct connection_parameter
@@ -838,29 +865,30 @@
};
typedef std::vector<connection_parameter> connection_parameters;

class database : public object<SQL_HANDLE_DBC>, public qtl::base_database<database, statement>
class base_database : public object<SQL_HANDLE_DBC>
{
public:
   typedef odbc::error exception_type;

   explicit database(environment& env) : object(env.handle()), m_opened(false)
   explicit base_database(environment& env) : object(env.handle()), m_opened(false)
   {
   }
   database(database&& src) 
      : object(std::forward<database>(src)), m_connection(std::forward<std::string>(src.m_connection)) 
   base_database(const base_database&) = delete;
   base_database(base_database&& src) 
      : object(std::forward<base_database>(src)), m_connection(std::forward<std::string>(src.m_connection)) 
   {
      m_opened=src.m_opened;
      src.m_opened=false;
   }
   ~database()
   ~base_database()
   {
      close();
   }
   database& operator=(database&& src)
   base_database& operator=(base_database&& src)
   {
      if(this!=&src)
      {
         object::operator =(std::forward<database>(src));
         object::operator =(std::forward<base_database>(src));
         m_opened=src.m_opened;
         src.m_opened=false;
         m_connection=std::forward<std::string>(src.m_connection);
@@ -868,76 +896,6 @@
      return *this;
   }

   void open(const char* server_name, size_t server_name_length, 
      const char* user_name, size_t user_name_length, const char* password, size_t password_length)
   {
      if (m_opened) close();
      verify_error(SQLConnectA(m_handle, (SQLCHAR*)server_name, server_name_length, (SQLCHAR*)user_name, user_name_length, (SQLCHAR*)password, password_length));
      m_opened = true;
   }
   void open(const char* server_name, const char* user_name, const char* password)
   {
      verify_error(SQLConnectA(m_handle, (SQLCHAR*)server_name, SQL_NTS, (SQLCHAR*)user_name, SQL_NTS, (SQLCHAR*)password, SQL_NTS));
   }
   void open(const std::string& server_name, const std::string& user_name, const std::string& password)
   {
      open(server_name.data(), server_name.size(), user_name.data(), user_name.size(), password.data(), password.size());
   }
   void open(const char* input_text, size_t text_length = SQL_NTS, SQLSMALLINT driver_completion = SQL_DRIVER_NOPROMPT, SQLHWND hwnd = NULL)
   {
      m_connection.resize(512);
      SQLSMALLINT out_len;
      if (m_opened) close();
      verify_error(SQLDriverConnectA(m_handle, hwnd, (SQLCHAR*)input_text, (SQLSMALLINT)text_length,
         (SQLCHAR*)m_connection.data(), (SQLSMALLINT)m_connection.size(), &out_len, driver_completion));
      m_connection.resize(out_len);
      m_opened = true;
   }
   void open(const std::string& input_text, SQLSMALLINT driver_completion = SQL_DRIVER_NOPROMPT, SQLHWND hwnd = NULL)
   {
      open(input_text.data(), input_text.size(), driver_completion, hwnd);
   }
   void open(SQLHWND hwnd, SQLSMALLINT driver_completion = SQL_DRIVER_COMPLETE)
   {
      open("", SQL_NTS, driver_completion, hwnd);
   }
   // InputPred like:
   // bool input_parameters(connection_parameters& parameters);
   template<typename InputPred>
   void open(const char* connection_text, size_t text_length, InputPred&& pred)
   {
      SQLSMALLINT length = 0;
      SQLINTEGER ret = SQL_SUCCESS;
      std::string input_text;
      if (m_opened) close();
      if (text_length == SQL_NTS)
         input_text = connection_text;
      else
         input_text.assign(connection_text, text_length);
      m_connection.resize(1024);
      while ((ret = SQLBrowseConnectA(m_handle, (SQLCHAR*)input_text.data(), SQL_NTS,
         (SQLCHAR*)m_connection.data(), m_connection.size(), &length)) == SQL_NEED_DATA)
      {
         connection_parameters parameters;
         parse_browse_string(m_connection.data(), length, parameters);
         if (!pred(parameters))
            throw error(SQL_NEED_DATA, "User cancel operation.");
         input_text = create_connection_text(parameters);
      }
      if (ret == SQL_ERROR || ret == SQL_SUCCESS_WITH_INFO)
         verify_error(ret);
      m_opened = true;
   }
   template<typename InputPred>
   void open(const char* connection_text, InputPred&& pred)
   {
      open(connection_text, SQL_NTS, std::forward<InputPred>(pred));
   }
   template<typename InputPred>
   void open(const std::string& connection_text, InputPred&& pred)
   {
      open(connection_text.data(), connection_text.size(), std::forward<InputPred>(pred));
   }
   void close()
   {
      if(m_opened)
@@ -947,46 +905,83 @@
      }
   }

   void set_attribute(SQLINTEGER attr, SQLPOINTER value)
   {
      verify_error(SQLSetConnectAttrA(m_handle, attr, (SQLPOINTER)value, SQL_IS_POINTER));
   }
   void set_attribute(SQLINTEGER attr, SQLINTEGER value)
   {
      verify_error(SQLSetConnectAttr(m_handle, attr, (SQLPOINTER)value, 0));
      verify_error(SQLSetConnectAttrA(m_handle, attr, (SQLPOINTER)value, SQL_IS_INTEGER));
   }
   void set_attribute(SQLINTEGER attr, SQLUINTEGER value)
   {
      verify_error(SQLSetConnectAttrA(m_handle, attr, (SQLPOINTER)value, SQL_IS_UINTEGER));
   }
   void set_attribute(SQLINTEGER attr, SQLSMALLINT value)
   {
      verify_error(SQLSetConnectAttrA(m_handle, attr, (SQLPOINTER)value, SQL_IS_SMALLINT));
   }
   void set_attribute(SQLINTEGER attr, SQLUSMALLINT value)
   {
      verify_error(SQLSetConnectAttrA(m_handle, attr, (SQLPOINTER)value, SQL_IS_USMALLINT));
   }
   void set_attribute(SQLINTEGER attr, const char* value)
   {
      verify_error(SQLSetConnectAttr(m_handle, attr, (SQLPOINTER)value, SQL_NTS));
      verify_error(SQLSetConnectAttrA(m_handle, attr, (SQLPOINTER)value, SQL_NTS));
   }
   void set_attribute(SQLINTEGER attr, const std::string& value)
   {
      verify_error(SQLSetConnectAttr(m_handle, attr, (SQLPOINTER)value.data(), value.size()));
      verify_error(SQLSetConnectAttrA(m_handle, attr, (SQLPOINTER)value.data(), value.size()));
   }
   void set_attribute(SQLINTEGER attr, const void* value, SQLINTEGER length)
   {
      verify_error(SQLSetConnectAttrA(m_handle, attr, (SQLPOINTER)value, SQL_LEN_BINARY_ATTR(length)));
   }
   void get_attribute(SQLINTEGER attr, SQLPOINTER& value) const
   {
      verify_error(SQLGetConnectAttrA(m_handle, attr, &value, SQL_IS_POINTER, 0));
   }
   void get_attribute(SQLINTEGER attr, SQLINTEGER& value) const
   {
      verify_error(SQLGetConnectAttr(m_handle, attr, &value, sizeof(SQLINTEGER), 0));
      value = 0;
      verify_error(SQLGetConnectAttrA(m_handle, attr, &value, SQL_IS_INTEGER, 0));
   }
   void get_attribute(SQLINTEGER attr, SQLUINTEGER& value) const
   {
      value = 0;
      verify_error(SQLGetConnectAttrA(m_handle, attr, &value, SQL_IS_UINTEGER, 0));
   }
   void get_attribute(SQLINTEGER attr, SQLSMALLINT& value) const
   {
      value = 0;
      verify_error(SQLGetConnectAttrA(m_handle, attr, &value, SQL_IS_SMALLINT, 0));
   }
   void get_attribute(SQLINTEGER attr, SQLUSMALLINT& value) const
   {
      value = 0;
      verify_error(SQLGetConnectAttrA(m_handle, attr, &value, SQL_IS_USMALLINT, 0));
   }
   void get_attribute(SQLINTEGER attr, void* buffer, SQLINTEGER length) const
   {
      verify_error(SQLGetConnectAttrA(m_handle, attr, buffer, SQL_LEN_BINARY_ATTR(length), 0));
   }
   void get_attribute(SQLINTEGER attr, char* buffer, size_t length) const
   {
      verify_error(SQLGetConnectAttrA(m_handle, attr, buffer, length, 0));
   }
   void get_attribute(SQLINTEGER attr, std::string& value) const
   {
      SQLINTEGER length = 0;
      verify_error(SQLGetConnectAttrA(m_handle, attr, NULL, 0, &length));
      value.resize(length);
      if(length>0)
         verify_error(SQLGetConnectAttrA(m_handle, attr, (SQLPOINTER)value.data(), length, 0));
   }
   void get_info(SQLSMALLINT info, std::string& value, SQLSMALLINT size=SQL_MAX_OPTION_STRING_LENGTH) const
   {
      value.resize(size);
      verify_error(SQLGetInfo(m_handle, info, (SQLPOINTER)value.data(), size, &size));
      value.resize(size);
   }

   void auto_commit(bool on)
   {
      set_attribute(SQL_ATTR_AUTOCOMMIT, on ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF);
   }
   void begin_transaction()
   {
      auto_commit(false);
   }
   void rollback()
   {
      verify_error(SQLEndTran(handler_type, m_handle, SQL_ROLLBACK));
      auto_commit(true);
   }
   void commit()
   {
      verify_error(SQLEndTran(handler_type, m_handle, SQL_COMMIT));
      auto_commit(true);
   }

   std::string dbms_name() const
@@ -1018,11 +1013,95 @@
      return m_connection;
   }

   bool is_alive()
protected:
   bool m_opened;
   std::string m_connection;

   void parse_browse_string(const char* output_text, size_t text_length, connection_parameters& parameters);
   std::string create_connection_text(const connection_parameters& parameters);
};

class database : public base_database, public qtl::base_database<database, statement>
{
public:
   database() = default;
   explicit database(environment& env) : odbc::base_database(env)
   {
      SQLINTEGER value;
      get_attribute(SQL_ATTR_CONNECTION_DEAD, value);
      return value == SQL_CD_FALSE;
   }
   database(database&& src) : odbc::base_database(std::move(src))
   {
   }

   void open(const char* server_name, size_t server_name_length,
      const char* user_name, size_t user_name_length, const char* password, size_t password_length)
   {
      if (m_opened) close();
      verify_error(SQLConnectA(m_handle, (SQLCHAR*)server_name, static_cast<SQLSMALLINT>(server_name_length), 
         (SQLCHAR*)user_name, static_cast<SQLSMALLINT>(user_name_length), (SQLCHAR*)password, static_cast<SQLSMALLINT>(password_length)));
      m_opened = true;
   }
   void open(const char* server_name, const char* user_name, const char* password)
   {
      verify_error(SQLConnectA(m_handle, (SQLCHAR*)server_name, SQL_NTS, (SQLCHAR*)user_name, SQL_NTS, (SQLCHAR*)password, SQL_NTS));
   }
   void open(const std::string& server_name, const std::string& user_name, const std::string& password)
   {
      open(server_name.data(), server_name.size(), user_name.data(), user_name.size(), password.data(), password.size());
   }
   void open(const char* input_text, size_t text_length = SQL_NTS, SQLSMALLINT driver_completion = SQL_DRIVER_NOPROMPT, SQLHWND hwnd = NULL)
   {
      m_connection.resize(512);
      SQLSMALLINT out_len=0;
      if (m_opened) close();
      verify_error(SQLDriverConnectA(m_handle, hwnd, (SQLCHAR*)input_text, (SQLSMALLINT)text_length,
         (SQLCHAR*)m_connection.data(), (SQLSMALLINT)m_connection.size(), &out_len, driver_completion));
      m_connection.resize(out_len);
      m_opened = true;
   }
   void open(const std::string& input_text, SQLSMALLINT driver_completion = SQL_DRIVER_NOPROMPT, SQLHWND hwnd = NULL)
   {
      open(input_text.data(), input_text.size(), driver_completion, hwnd);
   }
   void open(SQLHWND hwnd, SQLSMALLINT driver_completion = SQL_DRIVER_COMPLETE)
   {
      open("", SQL_NTS, driver_completion, hwnd);
   }
   // InputPred like:
   // bool input_parameters(connection_parameters& parameters);
   template<typename InputPred>
   void open(const char* connection_text, size_t text_length, InputPred&& pred)
   {
      SQLSMALLINT length = 0;
      SQLRETURN ret = SQL_SUCCESS;
      std::string input_text;
      if (m_opened) close();
      if (text_length == SQL_NTS)
         input_text = connection_text;
      else
         input_text.assign(connection_text, text_length);
      m_connection.resize(1024);
      while ((ret = SQLBrowseConnectA(m_handle, (SQLCHAR*)input_text.data(), SQL_NTS,
         (SQLCHAR*)m_connection.data(), m_connection.size(), &length)) == SQL_NEED_DATA)
      {
         connection_parameters parameters;
         parse_browse_string(m_connection.data(), length, parameters);
         if (!pred(parameters))
            throw error(SQL_NEED_DATA, "User cancel operation.");
         input_text = create_connection_text(parameters);
      }
      if (ret == SQL_ERROR || ret == SQL_SUCCESS_WITH_INFO)
         verify_error(ret);
      m_opened = true;
   }
   template<typename InputPred>
   void open(const char* connection_text, InputPred&& pred)
   {
      open(connection_text, SQL_NTS, std::forward<InputPred>(pred));
   }
   template<typename InputPred>
   void open(const std::string& connection_text, InputPred&& pred)
   {
      open(connection_text.data(), connection_text.size(), std::forward<InputPred>(pred));
   }

   statement open_command(const char* query_text, size_t text_length)
@@ -1040,11 +1119,11 @@
      return open_command(query_text.data(), query_text.length());
   }

   void simple_execute(const char* query_text, size_t text_length=SQL_NTS)
   void simple_execute(const char* query_text, size_t text_length = SQL_NTS)
   {
      statement command(*this);
      SQLRETURN ret=SQLExecDirectA(command.handle(), (SQLCHAR*)query_text, text_length);
      if(ret!=SQL_SUCCESS && ret!=SQL_NO_DATA)
      SQLRETURN ret = SQLExecDirectA(command.handle(), (SQLCHAR*)query_text, text_length);
      if (ret != SQL_SUCCESS && ret != SQL_NO_DATA)
         verify_error(ret);
   }
   void simple_execute(const std::string& query_text)
@@ -1052,12 +1131,38 @@
      simple_execute(query_text.data(), query_text.size());
   }

private:
   bool m_opened;
   std::string m_connection;
   void auto_commit(bool on)
   {
      set_attribute(SQL_ATTR_AUTOCOMMIT, on ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF);
   }
   void begin_transaction()
   {
      auto_commit(false);
   }
   void rollback()
   {
      verify_error(SQLEndTran(handler_type, m_handle, SQL_ROLLBACK));
      auto_commit(true);
   }
   void commit()
   {
      verify_error(SQLEndTran(handler_type, m_handle, SQL_COMMIT));
      auto_commit(true);
   }

   void parse_browse_string(const char* output_text, size_t text_length, connection_parameters& parameters);
   std::string create_connection_text(const connection_parameters& parameters);
   bool is_alive()
   {
      SQLINTEGER value;
      get_attribute(SQL_ATTR_CONNECTION_DEAD, value);
      return value == SQL_CD_FALSE;
   }

#ifdef QTL_ODBC_ENABLE_ASYNC_MODE

   //async_connection async_mode();

#endif //ODBC 3.80

};

struct date : public SQL_DATE_STRUCT
@@ -1145,6 +1250,490 @@
   }
};

#ifdef QTL_ODBC_ENABLE_ASYNC_MODE

class async_connection;

inline bool is_still_executing(SQLINTEGER code)
{
   return code == SQL_STILL_EXECUTING;
}

class async_statement : public base_statement
{
public:
   explicit async_statement(async_connection& db);
   async_statement(async_statement&& src)
      : base_statement(std::move(src))
   {
      m_hCompleteEvent = src.m_hCompleteEvent;
      m_event=src.m_event;
      m_nQueryTimeout = src.m_nQueryTimeout;
      src.m_hCompleteEvent = nullptr;
      src.m_event = nullptr;
   }
   async_statement& operator=(async_statement&& src)
   {
      if (this != &src)
      {
         base_statement::operator =(std::move(src));
         m_hCompleteEvent = src.m_hCompleteEvent;
         m_event = src.m_event;
         m_nQueryTimeout = src.m_nQueryTimeout;
         src.m_hCompleteEvent = nullptr;
         src.m_event = nullptr;
      }
      return *this;
   }
   ~async_statement()
   {
      close();
   }

   /*
      Handler defiens as:
      void handler(const qtl::odbc::error& e);
    */
   template<typename Handler>
   void open(Handler&& handler, const char *query_text, size_t text_length = 0)
   {
      if (text_length == 0) text_length = strlen(query_text);
      reset();
      SQLRETURN ret = SQLPrepareA(m_handle, (SQLCHAR*)query_text, text_length);
      async_wait(ret, std::forward<Handler>(handler));
   }

   /*
      ExecuteHandler defiens as:
      void handler(const qtl::odbc::error& e, uint64_t affected);
    */
   template<typename Types, typename Handler>
   void execute(const Types& params, Handler&& handler)
   {
      SQLSMALLINT count = 0;
      SQLRETURN ret = SQLNumParams(m_handle, &count);
      if (!SQL_SUCCEEDED(ret))
      {
         handler(error(*this, ret), 0);
         return;
      }
      if (count > 0)
      {
         m_params.resize(count);
         qtl::bind_params(*this, params);
      }

      if (m_nQueryTimeout == 0)
         m_nQueryTimeout = query_timeout();
      ret = SQLExecute(m_handle);
      async_wait(ret, [this, count, handler](const error& e) mutable {
         SQLINTEGER ret = e.code();
         if (ret == SQL_NEED_DATA)
            async_param_data(0, count, std::forward<Handler>(handler));
         else if(ret>=0)
            handler(error(*this, ret), affetced_rows());
         else
            handler(error(*this, ret), 0);
      });
   }

   template<typename Types, typename RowHandler, typename FinishHandler>
   void fetch(Types&& values, RowHandler&& row_handler, FinishHandler&& finish_handler)
   {
      if (!m_binded_cols)
      {
         SQLSMALLINT count = 0;
         SQLRETURN ret = SQLNumResultCols(m_handle, &count);
         if(!SQL_SUCCEEDED(ret))
         { 
            finish_handler(error(*this, ret));
            return;
         }
         if (count > 0)
         {
            m_params.resize(count);
            qtl::bind_record(*this, std::forward<Types>(values));
         }
         m_binded_cols = true;
      }
      return fetch(std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
   }

   template<typename RowHandler, typename FinishHandler>
   void fetch(RowHandler&& row_handler, FinishHandler&& finish_handler)
   {
      SQLRETURN ret = SQLFetch(m_handle);
      async_wait(ret, [this, row_handler, finish_handler](const error& e) mutable {
         SQLINTEGER ret = e.code();
         if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO)
         {
            for (const param_data& data : m_params)
            {
               if (data.m_after_fetch)
                  data.m_after_fetch(data);
            }
            if (row_handler())
               fetch(row_handler, finish_handler);
            else
               finish_handler(error());
         }
         else
         {
            if (e.code() == SQL_NO_DATA)
               finish_handler(error());
            else
               finish_handler(e);
         }
      });
   }

   template<typename Handler>
   void next_result(Handler handler)
   {
      SQLRETURN ret;
      m_binded_cols = false;
      ret = SQLMoreResults(m_handle);
      async_wait(ret, [this, handler](const error& e) mutable {
         SQLINTEGER ret=e.code();
         SQLSMALLINT count = 0;
         if (ret == SQL_ERROR || ret == SQL_INVALID_HANDLE)
         {
            reset();
            handler(error(*this, ret));
            return;
         }
         ret = SQLNumResultCols(m_handle, &count);
         if (ret == SQL_ERROR || ret == SQL_INVALID_HANDLE)
         {
            reset();
            handler(error(*this, ret));
            return;
         }
         if (count > 0)
            handler(error());
         else
            next_result(handler);
      });
   }

   HANDLE event_handle() const { return m_hCompleteEvent; }

   void close()
   {
      close_event();
      base_statement::close();
   }

   template<typename CloseHandler>
   void close(CloseHandler&& handler)
   {
      if (m_handle)
      {
         close_event();
         SQLRETURN ret = SQLFreeHandle(handler_type, m_handle);
         if(SQL_SUCCEEDED(ret))
            m_handle = SQL_NULL_HANDLE;
         handler(error(*this, ret));
      }
      else
      {
         handler(error());
      }
   }

private:

   void close_event()
   {
      if (m_hCompleteEvent)
      {
         if (m_event)
            m_event->remove();
         verify_error(SQLCancelHandle(handler_type, m_handle));
         verify_error(SQLSetStmtAttr(m_handle, SQL_ATTR_ASYNC_STMT_EVENT, NULL, SQL_IS_POINTER));
         verify_error(SQLSetStmtAttr(m_handle, SQL_ATTR_ASYNC_ENABLE, (SQLPOINTER)SQL_ASYNC_ENABLE_OFF, SQL_IS_INTEGER));
         CloseHandle(m_hCompleteEvent);
         m_hCompleteEvent = NULL;
      }
   }

   template<typename Handler>
   void async_wait(SQLINTEGER ret, Handler&& handler) NOEXCEPT
   {
      if(is_still_executing(ret))
      {
         m_event->set_io_handler(0, m_nQueryTimeout,
            [this, handler](int flags) mutable {
               RETCODE code;
               SQLCompleteAsync(SQL_HANDLE_STMT, m_handle, &code);
               if (SQL_SUCCEEDED(code))
               {
                  handler(odbc::error());
               }
               else
               {
                  SetEvent(m_hCompleteEvent);
                  handler(odbc::error(*this, code));
               }
         });
      }
      else
      {
         handler(error(*this, ret));
      }
   }

   template<typename Handler>
   void async_param_data(SQLSMALLINT index, SQLSMALLINT count, Handler&& handler) NOEXCEPT
   {
      SQLPOINTER token;
      SQLRETURN ret = SQLParamData(m_handle, &token);
      async_wait(ret, [this, index, count, token, handler](const error& e) mutable {
         SQLINTEGER ret = e.code();
         if (ret == SQL_NEED_DATA)
         {
            while (index != count)
            {
               if (&m_params[index] == token)
               {
                  if (m_params[index].m_after_fetch)
                     m_params[index].m_after_fetch(m_params[index]);
                  break;
               }
               ++index;
            }
            async_param_data(index, count, handler);
         }
         else
         {
            handler(error(*this, ret), affetced_rows());
         }
      });
   }

   int query_timeout() const
   {
      SQLULEN timeout = 0;
      verify_error(SQLGetStmtAttr(m_handle, SQL_ATTR_QUERY_TIMEOUT, (SQLPOINTER)&timeout, NULL, NULL));
      return timeout;
   }

private:
   HANDLE m_hCompleteEvent;
   qtl::event* m_event;
   SQLULEN m_nQueryTimeout;
};

class async_connection : public base_database, public qtl::async_connection<async_connection, async_statement>
{
public:
   async_connection(environment& env) : base_database(env) 
   { 
      set_attribute(SQL_ATTR_ASYNC_DBC_FUNCTIONS_ENABLE, SQL_ASYNC_DBC_ENABLE_ON);
      m_hCompleteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
      if (m_hCompleteEvent == NULL)
      {
         throw std::system_error(std::error_code(GetLastError(), std::system_category()));
      }
      set_attribute(SQL_ATTR_ASYNC_DBC_EVENT, m_hCompleteEvent);
   }
   async_connection(async_connection&& src) : 
      base_database(std::move(src)), 
      qtl::async_connection<async_connection, async_statement>(std::move(src)),
      m_BindFunc(std::move(src.m_BindFunc))
   {
      m_hCompleteEvent = src.m_hCompleteEvent;
      src.m_hCompleteEvent = nullptr;
   }
   ~async_connection()
   {
      if (m_hCompleteEvent)
      {
         verify_error(SQLCancelHandle(handler_type, m_handle));
         set_attribute(SQL_ATTR_ASYNC_DBC_EVENT, (SQLPOINTER)NULL);
      }
      if (m_opened)
      {
         set_attribute(SQL_ATTR_ASYNC_DBC_FUNCTIONS_ENABLE, SQL_ASYNC_DBC_ENABLE_OFF);
         verify_error(SQLDisconnect(m_handle));
         m_opened = false;
      }
      if (m_hCompleteEvent)
      {
         CloseHandle(m_hCompleteEvent);
      }
   }

   /*
      OpenHandler defines as:
         void handler(const qtl::odbc::error& e) NOEXCEPT;
   */
   template<class EventLoop, typename OpenHandler>
   void open(EventLoop& ev, OpenHandler&& handler, const char* server_name, size_t server_name_length,
      const char* user_name, size_t user_name_length, const char* password, size_t password_length)
   {
      if (m_opened) close();
      SQLRETURN err = SQLConnectA(m_handle, (SQLCHAR*)server_name, static_cast<SQLSMALLINT>(server_name_length), 
         (SQLCHAR*)user_name, static_cast<SQLSMALLINT>(user_name_length), (SQLCHAR*)password, static_cast<SQLSMALLINT>(password_length));
      async_wait_connect(err, ev, std::forward<OpenHandler>(handler));
   }
   template<class EventLoop, typename OpenHandler>
   void open(EventLoop& ev, OpenHandler&& handler, const char* server_name, const char* user_name, const char* password)
   {
      if (m_opened) close();
      SQLRETURN err = SQLConnectA(m_handle, (SQLCHAR*)server_name, SQL_NTS, (SQLCHAR*)user_name, SQL_NTS, (SQLCHAR*)password, SQL_NTS);
      async_wait_connect(err, ev, std::forward<OpenHandler>(handler));
   }
   template<class EventLoop, typename OpenHandler>
   void open(EventLoop& ev, OpenHandler&& handler, const std::string& server_name, const std::string& user_name, const std::string& password)
   {
      open(ev, std::forward<OpenHandler>(handler), server_name.data(), server_name.size(), user_name.data(), user_name.size(), password.data(), password.size());
   }
   template<class EventLoop, typename OpenHandler>
   void open(EventLoop& ev, OpenHandler&& handler, const char* input_text, size_t text_length = SQL_NTS, SQLSMALLINT driver_completion = SQL_DRIVER_NOPROMPT, SQLHWND hwnd = NULL)
   {
      m_connection.resize(512);
      SQLSMALLINT out_len=0;
      SQLRETURN err = SQLDriverConnectA(m_handle, hwnd, (SQLCHAR*)input_text, (SQLSMALLINT)text_length,
         (SQLCHAR*)m_connection.data(), (SQLSMALLINT)m_connection.size(), &out_len, driver_completion);
      m_connection.resize(out_len);
      async_wait_connect(err, ev, std::forward<OpenHandler>(handler));
   }
   template<class EventLoop, typename OpenHandler>
   void open(EventLoop& ev, OpenHandler&& handler, const std::string& input_text, SQLSMALLINT driver_completion = SQL_DRIVER_NOPROMPT, SQLHWND hwnd = NULL)
   {
      open(ev, std::forward<OpenHandler>(handler), input_text.data(), input_text.size(), driver_completion, hwnd);
   }
   template<class EventLoop, typename OpenHandler>
   void open(EventLoop& ev, OpenHandler&& handler, SQLHWND hwnd, SQLSMALLINT driver_completion = SQL_DRIVER_COMPLETE)
   {
      open(ev, std::forward<OpenHandler>(handler), "", SQL_NTS, driver_completion, hwnd);
   }

   /*
      CloseHandler defines as:
         void handler(const qtl::odbc::error& e) NOEXCEPT;
   */
   template<typename CloseHandler >
   void close(CloseHandler&& handler) NOEXCEPT
   {
      SQLRETURN ret = SQLDisconnect(m_handle);
      m_opened = false;
      async_wait(ret, [this, handler](const error& e) {
         if (!e) m_opened = false;
         handler(e);
      });
   }

   /*
      ExecuteHandler defines as:
         void handler(const qtl::odbc::error& e) NOEXCEPT;
   */
   template<typename ExecuteHandler>
   void simple_execute(ExecuteHandler&& handler, const char* query_text, size_t text_length = SQL_NTS) NOEXCEPT
   {
      statement command(*this);
      SQLRETURN ret = SQLExecDirectA(command.handle(), (SQLCHAR*)query_text, static_cast<SQLINTEGER>(text_length));
      async_wait(ret, std::forward<ExecuteHandler>(handler));
   }
   template<typename ExecuteHandler>
   void simple_execute(ExecuteHandler&& handler, const std::string& query_text)
   {
      simple_execute(std::forward<ExecuteHandler>(handler), query_text.data(), query_text.size());
   }

   template<typename Handler>
   void open_command(const char* query_text, size_t text_length, Handler&& handler)
   {
      std::shared_ptr<async_statement> stmt = std::make_shared<async_statement>(*this);
      stmt->open([stmt, handler](const odbc::error& e) mutable {
         handler(e, stmt);
      }, query_text, text_length);
   }

   HANDLE event_handle() const { return m_hCompleteEvent; }

   qtl::event* rebind(HANDLE hEvent)
   {
      return m_BindFunc(hEvent);
   }

private:

   template<typename Handler>
   void async_wait(SQLRETURN ret, Handler&& handler) NOEXCEPT
   {
      if (is_still_executing(ret))
      {
         m_event_handler->set_io_handler(0, connect_timeout(),
            [this, handler](int flags) mutable {
            RETCODE code;
            SQLCompleteAsync(SQL_HANDLE_DBC, m_handle, &code);
            if (SQL_SUCCEEDED(code))
            {
               handler(odbc::error());
            }
            else
            {
               SetEvent(m_hCompleteEvent);
               handler(odbc::error(*this, code));
            }
         });
      }
      else
      {
         handler(odbc::error(*this, ret));
      }
   }

   template<typename EventLoop, typename Handler>
   void async_wait_connect(SQLRETURN err, EventLoop& ev, Handler&& handler)
   {
      bind(ev);
      m_BindFunc = [&ev](HANDLE hEvent) {
         return ev.add(hEvent);
      };
      if(is_still_executing(err))
      {
         async_wait(err, [this, handler](const error& e) mutable {
            if (!e) m_opened = true;
            handler(e);
         });
      }
      else
      {
         handler(odbc::error(*this, err));
      }
   }

   int connect_timeout() const
   {
      int timeout=0;
      verify_error(SQLGetConnectAttr(m_handle, SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER)&timeout, 0, NULL));
      return timeout;
   }

private:
   HANDLE m_hCompleteEvent;
   std::function<qtl::event*(HANDLE)> m_BindFunc;
};

inline    async_statement::async_statement(async_connection& db)
   : base_statement(static_cast<base_database&>(db))
{
   verify_error(SQLSetStmtAttr(m_handle, SQL_ATTR_ASYNC_ENABLE, (SQLPOINTER)SQL_ASYNC_ENABLE_ON, SQL_IS_INTEGER));
   m_hCompleteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
   if (m_hCompleteEvent == NULL)
   {
      throw std::system_error(std::error_code(GetLastError(), std::system_category()));
   }
   verify_error(SQLSetStmtAttr(m_handle, SQL_ATTR_ASYNC_STMT_EVENT, m_hCompleteEvent, SQL_IS_POINTER));
   m_event = db.rebind(this->m_hCompleteEvent);
   m_nQueryTimeout = query_timeout();
}

#endif //ODBC 3.80

typedef qtl::transaction<database> transaction;

template<typename Record>
@@ -1172,10 +1761,13 @@
      SQLCHAR message[SQL_MAX_MESSAGE_LENGTH];
      SQLCHAR state[SQL_SQLSTATE_SIZE+1];
      std::ostringstream oss;
      while(SQLGetDiagRecA(object<Type>::handler_type, h.handle(), ++i, state, &err, 
         message, SQL_MAX_MESSAGE_LENGTH, NULL)==SQL_SUCCESS)
      SQLRETURN ret = SQLGetDiagRecA(object<Type>::handler_type, h.handle(), ++i, state, &err,
         message, SQL_MAX_MESSAGE_LENGTH, NULL);
      while(ret==SQL_SUCCESS)
      {
         oss<<"["<<state<<"] ("<<err<<") "<<message<<std::endl;
         ret = SQLGetDiagRecA(object<Type>::handler_type, h.handle(), ++i, state, &err,
            message, SQL_MAX_MESSAGE_LENGTH, NULL);
      }
      m_errmsg=oss.str();
   }
@@ -1185,7 +1777,7 @@
   }
}

inline void database::parse_browse_string(const char* output_text, size_t text_length, connection_parameters& parameters)
inline void base_database::parse_browse_string(const char* output_text, size_t text_length, connection_parameters& parameters)
{
   enum { part_name, part_prompt, part_list, part_value };
   const char* sp=output_text;
@@ -1242,7 +1834,7 @@
      parameters.emplace_back(parameter);
}

inline std::string database::create_connection_text(const connection_parameters& parameters)
inline std::string base_database::create_connection_text(const connection_parameters& parameters)
{
   std::ostringstream oss;
   for(auto& parameter : parameters)
@@ -1253,7 +1845,7 @@
   return oss.str();
}

inline statement::statement(database& db)
inline base_statement::base_statement(base_database& db)
   : object(db.handle()), m_blob_buffer(NULL), m_binded_cols(false)
{
}
@@ -1269,7 +1861,7 @@
{
public:
   explicit database(odbc::environment& env) : odbc::database(env) { }
   database(database&& src) : odbc::database(std::forward<database>(src)) { }
   database(database&& src) : odbc::database(std::move(src)) { }

   void open(const char* server, const char* db=NULL, const char* user=NULL, const char* password=NULL)
   {
@@ -1288,6 +1880,35 @@
   }
};

#ifdef QTL_ODBC_ENABLE_ASYNC_MODE

class async_connection : public odbc::async_connection
{
public:
   explicit async_connection(odbc::environment& env) : odbc::async_connection(env) { }
   async_connection(async_connection&& src) : odbc::async_connection(std::move(src)) { }

   template<typename EventLoop, typename OpenHandler>
   void open(EventLoop& ev, const OpenHandler& handler, const char* server, const char* db = NULL, const char* user = NULL, const char* password = NULL)
   {
      std::ostringstream oss;
      oss << "DRIVER={ODBC Driver 11 for SQL Server};SERVER=" << server << ";";
      if (user == NULL)
         oss << "UID=;PWD=;Trusted_Connection=yes;";
      else
      {
         oss << "UID=" << user << ";PWD=";
         if (password) oss << password;
         oss << ";Trusted_Connection=no;";
      }
      oss << "DATABASE=" << db;
      odbc::async_connection::open(ev, handler, oss.str());
   }

};

#endif

} //mssql

namespace msaccess