#ifndef _QTL_ODCB_H_
#define _QTL_ODCB_H_

#include <sql.h>
#include <sqlext.h>
#include <sstream>
#include <vector>
#include <array>
#include <time.h>
#include <assert.h>
#include <malloc.h>
#include <limits.h>
#include <stdint.h>

#if !defined(_WIN32) || defined(__MINGW32__)
#include <sys/time.h>
#endif //_WIN32

#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
{

	namespace odbc
	{

		template <SQLSMALLINT>
		class object;
		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; }
			virtual const char *what() const throw() override { return m_errmsg.data(); }

		private:
			SQLINTEGER m_errno;
			std::string m_errmsg;
		};

		template <SQLSMALLINT Type>
		class object
		{
		public:
			enum
			{
				handler_type = Type
			};
			object() : m_handle(SQL_NULL_HANDLE){};
			object(const object &) = delete;
			object(object &&src) : m_handle(src.m_handle)
			{
				src.m_handle = SQL_NULL_HANDLE;
			}
			explicit object(SQLHANDLE parent)
			{
				verify_error(SQLAllocHandle(handler_type, parent, &m_handle));
			}
			~object()
			{
				close();
			}
			object &operator=(const object &) = delete;
			object &operator=(object &&src)
			{
				if (this != &src)
				{
					close();
					m_handle = src.m_handle;
					src.m_handle = NULL;
				}
				return *this;
			}
			SQLHANDLE handle() const { return m_handle; }

			void close()
			{
				if (m_handle)
				{
					verify_error(SQLFreeHandle(handler_type, m_handle));
					m_handle = SQL_NULL_HANDLE;
				}
			}

			void verify_error(SQLINTEGER code) const
			{
				if (code < 0)
					throw odbc::error(*this, code);
			}

		protected:
			SQLHANDLE m_handle;
		};

		class blobbuf : public qtl::blobbuf
		{
		public:
			blobbuf() : m_stmt(nullptr), m_field(0)
			{
			}
			blobbuf(const blobbuf &) = default;
			blobbuf &operator=(const blobbuf &) = default;
			virtual ~blobbuf() { overflow(); }

			void open(object<SQL_HANDLE_STMT> *stmt, SQLSMALLINT field, std::ios_base::openmode mode)
			{
				if (m_stmt && m_field)
				{
					overflow();
				}

				assert(stmt != SQL_NULL_HANDLE);
				m_stmt = stmt;
				m_field = field;
				m_size = INTMAX_MAX;
				init_buffer(mode);
			}

		private:
			object<SQL_HANDLE_STMT> *m_stmt;
			SQLSMALLINT m_field;

		protected:
			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, static_cast<SQLINTEGER>(count), const_cast<SQLLEN *>(&indicator));
				if (ret != SQL_NO_DATA)
				{
					count = (indicator > count) || (indicator == SQL_NO_TOTAL) ? count : indicator;
					m_stmt->verify_error(ret);
					return true;
				}
				else
					return false;
			}

			virtual void write_blob(const char *buffer, size_t count) override
			{
				m_stmt->verify_error(SQLPutData(m_stmt->handle(), (SQLPOINTER)buffer, count));
			}
		};

		class environment final : public object<SQL_HANDLE_ENV>
		{
		public:
			environment() : object(SQL_NULL_HANDLE)
			{
#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)) {}

			int32_t version() const
			{
				int32_t ver = 0;
				verify_error(SQLGetEnvAttr(m_handle, SQL_ATTR_ODBC_VERSION, &ver, sizeof(DWORD), NULL));
				return ver;
			}
		};

		class base_statement : public object<SQL_HANDLE_STMT>
		{
		public:
			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;
			}
			~base_statement()
			{
				if (m_blob_buffer)
					free(m_blob_buffer);
			}
			base_statement &operator=(base_statement &&src)
			{
				if (this != &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;
					m_blob_buffer = src.m_blob_buffer;
					src.m_blob_buffer = NULL;
				}
				return *this;
			}

			void bind_param(size_t index, const std::nullptr_t &)
			{
				m_params[index].m_indicator = SQL_NULL_DATA;
				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(size_t index, const qtl::null &)
			{
				bind_param(index, nullptr);
			}
			void bind_param(size_t index, const int8_t &v)
			{
				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(size_t index, const uint8_t &v)
			{
				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(size_t index, const int16_t &v)
			{
				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(size_t index, const uint16_t &v)
			{
				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(size_t index, const int32_t &v)
			{
				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(size_t index, const uint32_t &v)
			{
				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(size_t index, const int64_t &v)
			{
				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(size_t index, const uint64_t &v)
			{
				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(size_t index, const double &v)
			{
				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(size_t index, const float &v)
			{
				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(size_t index, const bool &v)
			{
				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(size_t index, const DATE_STRUCT &v)
			{
				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(size_t index, const TIME_STRUCT &v)
			{
				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(size_t index, const TIMESTAMP_STRUCT &v)
			{
				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(size_t index, const SQLGUID &v)
			{
				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(size_t index, const SQL_NUMERIC_STRUCT &v)
			{
				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(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, 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(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, 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(size_t index, const std::string &v)
			{
				bind_param(index, v.data(), v.size(), v.size());
			}
			void bind_param(size_t index, const std::wstring &v)
			{
				bind_param(index, v.data(), v.size(), v.size());
			}
			void bind_param(size_t index, const const_blob_data &v)
			{
				m_params[index].m_indicator = v.size;
				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(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, 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;
					while (!s.eof() && !s.fail())
					{
						s.read((char *)p.m_data, p.m_size);
						readed = (unsigned long)s.gcount();
						if (readed > 0)
						{
							verify_error(SQLPutData(m_handle, p.m_data, readed));
						}
					}
				};
			}

			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, 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, static_cast<SQLSMALLINT>(index), std::ios::out);
					std::ostream s(&buf);
					param(s);
				};
			}

			void bind_field(size_t index, bool &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_BIT, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, int8_t &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_STINYINT, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, uint8_t &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_UTINYINT, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, int16_t &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_SSHORT, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, uint16_t &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_USHORT, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, int32_t &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_SLONG, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, uint32_t &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_ULONG, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, int64_t &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_SBIGINT, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, uint64_t &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_UBIGINT, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, float &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_FLOAT, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, double &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_DOUBLE, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, DATE_STRUCT &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_TYPE_DATE, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, TIME_STRUCT &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_TYPE_TIME, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, TIMESTAMP_STRUCT &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_TYPE_TIMESTAMP, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, SQLGUID &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_GUID, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, SQL_NUMERIC_STRUCT &&v)
			{
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_NUMERIC, &v, 0, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, char *v, size_t n)
			{
				m_params[index].m_data = v;
				m_params[index].m_size = n;
				m_params[index].m_after_fetch = [](const param_data &p)
				{
					if (p.m_indicator == SQL_NULL_DATA)
						memset(p.m_data, 0, p.m_size * sizeof(char));
					else
					{
						char *text = reinterpret_cast<char *>(p.m_data);
						text[p.m_indicator] = '\0';
					}
				};
				verify_error(SQLBindCol(m_handle, static_cast<SQLUSMALLINT>(index + 1), SQL_C_CHAR, v, n, &m_params[index].m_indicator));
			}
			void bind_field(size_t index, wchar_t *v, size_t n)
			{
				m_params[index].m_data = v;
				m_params[index].m_size = n;
				m_params[index].m_after_fetch = [](const param_data &p)
				{
					if (p.m_indicator == SQL_NULL_DATA)
						memset(p.m_data, 0, p.m_size * sizeof(wchar_t));
					else
					{
						wchar_t *text = reinterpret_cast<wchar_t *>(p.m_data);
						text[p.m_indicator] = '\0';
					}
				};
				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(size_t index, qtl::bind_string_helper<T> &&v)
			{
				SQLLEN length = 0;
				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
				{
					if (p.m_indicator == SQL_NULL_DATA)
						v.clear();
					else
						v.truncate(p.m_indicator);
				};
			}
			template <size_t N>
			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(size_t index, std::array<wchar_t, N> &&value)
			{
				bind_field(index, value.data(), value.size());
			}
			void bind_field(size_t index, qtl::blob_data &&v)
			{
				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(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, 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, static_cast<SQLUSMALLINT>(index + 1), SQL_C_BINARY, p.m_data, p.m_size, const_cast<SQLLEN *>(&p.m_indicator));
					}
				};
			}

			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, static_cast<SQLSMALLINT>(index), std::ios::in);
				};
			}

			template <typename Type>
			void bind_field(size_t index, indicator<Type> &&value)
			{
				qtl::bind_field(*this, index, value.data);
				param_data &param = m_params[index];
				auto fetch_fun = param.m_after_fetch;
				param.m_after_fetch = [fetch_fun, &value](const param_data &p)
				{
					value.is_truncated = false;
					if (p.m_indicator == SQL_NULL_DATA)
					{
						value.is_null = true;
						value.length = 0;
					}
					else if (p.m_indicator >= 0)
					{
						value.is_null = false;
						value.length = p.m_indicator;
						if (p.m_size > 0 && p.m_indicator >= p.m_size)
							value.is_truncated = true;
					}
					if (fetch_fun)
						fetch_fun(p);
				};
			}

#ifdef _QTL_ENABLE_CPP17

			template <typename Type>
			void bind_field(size_t index, std::optional<Type> &&value)
			{
				qtl::bind_field(*this, index, *value);
				param_data &param = m_params[index];
				auto fetch_fun = param.m_after_fetch;
				param.m_after_fetch = [fetch_fun, &value](const param_data &p)
				{
					if (fetch_fun)
						fetch_fun(p);
					if (p.m_indicator == SQL_NULL_DATA)
						value.reset();
				};
			}

			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));
				verify_error(SQLColAttribute(m_handle, index + 1, SQL_DESC_UNSIGNED, NULL, 0, NULL, &isUnsigned));
				switch (type)
				{
				case SQL_BIT:
					value.emplace<bool>();
					bind_field(index, std::forward<bool>(std::any_cast<bool &>(value)));
					break;
				case SQL_TINYINT:
					if (isUnsigned)
					{
						value.emplace<uint8_t>();
						bind_field(index, std::forward<uint8_t>(std::any_cast<uint8_t &>(value)));
					}
					else
					{
						value.emplace<int8_t>();
						bind_field(index, std::forward<int8_t>(std::any_cast<int8_t &>(value)));
					}
					break;
				case SQL_SMALLINT:
					if (isUnsigned)
					{
						value.emplace<uint16_t>();
						bind_field(index, std::forward<uint16_t>(std::any_cast<uint16_t &>(value)));
					}
					else
					{
						value.emplace<int16_t>();
						bind_field(index, std::forward<int16_t>(std::any_cast<int16_t &>(value)));
					}
					break;
				case SQL_INTEGER:
					if (isUnsigned)
					{
						value.emplace<uint32_t>();
						bind_field(index, std::forward<uint32_t>(std::any_cast<uint32_t &>(value)));
					}
					else
					{
						value.emplace<int32_t>();
						bind_field(index, std::forward<int32_t>(std::any_cast<int32_t &>(value)));
					}
					break;
				case SQL_BIGINT:
					if (isUnsigned)
					{
						value.emplace<uint64_t>();
						bind_field(index, std::forward<uint64_t>(std::any_cast<uint64_t &>(value)));
					}
					else
					{
						value.emplace<int64_t>();
						bind_field(index, std::forward<int64_t>(std::any_cast<int64_t &>(value)));
					}
					break;
				case SQL_FLOAT:
					value.emplace<float>();
					bind_field(index, std::forward<float>(std::any_cast<float &>(value)));
					break;
				case SQL_DOUBLE:
					value.emplace<double>();
					bind_field(index, std::forward<double>(std::any_cast<double &>(value)));
					break;
				case SQL_NUMERIC:
					value.emplace<SQL_NUMERIC_STRUCT>();
					bind_field(index, std::forward<SQL_NUMERIC_STRUCT>(std::any_cast<SQL_NUMERIC_STRUCT &>(value)));
					break;
				case SQL_TIME:
					value.emplace<SQL_TIME_STRUCT>();
					bind_field(index, std::forward<SQL_TIME_STRUCT>(std::any_cast<SQL_TIME_STRUCT &>(value)));
					break;
				case SQL_DATE:
					value.emplace<SQL_DATE_STRUCT>();
					bind_field(index, std::forward<SQL_DATE_STRUCT>(std::any_cast<SQL_DATE_STRUCT &>(value)));
					break;
				case SQL_TIMESTAMP:
					value.emplace<SQL_TIMESTAMP_STRUCT>();
					bind_field(index, std::forward<SQL_TIMESTAMP_STRUCT>(std::any_cast<SQL_TIMESTAMP_STRUCT &>(value)));
					break;
				case SQL_INTERVAL_MONTH:
				case SQL_INTERVAL_YEAR:
				case SQL_INTERVAL_YEAR_TO_MONTH:
				case SQL_INTERVAL_DAY:
				case SQL_INTERVAL_HOUR:
				case SQL_INTERVAL_MINUTE:
				case SQL_INTERVAL_SECOND:
				case SQL_INTERVAL_DAY_TO_HOUR:
				case SQL_INTERVAL_DAY_TO_MINUTE:
				case SQL_INTERVAL_DAY_TO_SECOND:
				case SQL_INTERVAL_HOUR_TO_MINUTE:
				case SQL_INTERVAL_HOUR_TO_SECOND:
				case SQL_INTERVAL_MINUTE_TO_SECOND:
					value.emplace<SQL_INTERVAL_STRUCT>();
					bind_field(index, std::forward<SQL_INTERVAL_STRUCT>(std::any_cast<SQL_INTERVAL_STRUCT &>(value)));
					break;
				case SQL_CHAR:
					value.emplace<std::string>();
					bind_field(index, qtl::bind_string(std::any_cast<std::string &>(value)));
					break;
				case SQL_GUID:
					value.emplace<SQLGUID>();
					bind_field(index, std::forward<SQLGUID>(std::any_cast<SQLGUID &>(value)));
					break;
				case SQL_BINARY:
					value.emplace<blobbuf>();
					bind_field(index, std::forward<blobbuf>(std::any_cast<blobbuf &>(value)));
					break;
				default:
					throw odbc::error(*this, SQL_ERROR);
				}
				param_data &param = m_params[index];
				auto fetch_fun = param.m_after_fetch;
				param.m_after_fetch = [fetch_fun, &value](const param_data &p)
				{
					if (fetch_fun)
						fetch_fun(p);
					if (p.m_indicator == SQL_NULL_DATA)
						value.reset();
				};
			}

#endif // C++17

			SQLLEN affetced_rows()
			{
				SQLLEN count = 0;
				verify_error(SQLRowCount(m_handle, &count));
				return count;
			}

			size_t find_field(const char *name) const
			{
				SQLSMALLINT count = 0;
				verify_error(SQLNumResultCols(m_handle, &count));
				for (SQLSMALLINT i = 0; i != count; i++)
				{
					SQLCHAR field_name[256] = {0};
					SQLSMALLINT name_length = 0;
					SQLSMALLINT data_type;
					SQLULEN column_size;
					SQLSMALLINT digits;
					SQLSMALLINT nullable;
					verify_error(SQLDescribeColA(m_handle, i, field_name, sizeof(field_name), &name_length,
												 &data_type, &column_size, &digits, &nullable));
					if (strncmp((char *)field_name, name, name_length) == 0)
						return i;
				}
				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;
				For MySQL: SELECT LAST_INSERT_ID();
				For SQLite: SELECT last_insert_rowid();
			 */
			/*uint64_t insert_id()
			{
				assert(false);
				return 0;
			}*/

		protected:
			struct param_data
			{
				SQLPOINTER m_data;
				SQLLEN m_size;
				SQLLEN m_indicator;
				std::function<void(const param_data &)> m_after_fetch;

				param_data() : m_data(NULL), m_size(0), m_indicator(0) {}
			};
			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
		{
			std::string m_name;
			std::string m_prompt;
			std::string m_value;
			std::vector<std::string> m_value_list;
			bool m_optinal;
			bool m_assigned;

			connection_parameter() : m_optinal(false), m_assigned(false) {}
			void reset()
			{
				m_name.clear();
				m_prompt.clear();
				m_value.clear();
				m_value_list.clear();
				m_optinal = false;
				m_assigned = false;
			}
		};
		typedef std::vector<connection_parameter> connection_parameters;

		class base_database : public object<SQL_HANDLE_DBC>
		{
		public:
			typedef odbc::error exception_type;

			explicit base_database(environment &env) : object(env.handle()), m_opened(false)
			{
			}
			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;
			}
			~base_database()
			{
				close();
			}
			base_database &operator=(base_database &&src)
			{
				if (this != &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);
				}
				return *this;
			}

			void close()
			{
				if (m_opened)
				{
					verify_error(SQLDisconnect(m_handle));
					m_opened = false;
				}
			}

			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(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(SQLSetConnectAttrA(m_handle, attr, (SQLPOINTER)value, SQL_NTS));
			}
			void set_attribute(SQLINTEGER attr, const std::string &value)
			{
				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
			{
				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);
			}

			std::string dbms_name() const
			{
				std::string name;
				get_info(SQL_DBMS_NAME, name);
				return name;
			}
			std::string server_name() const
			{
				std::string name;
				get_info(SQL_SERVER_NAME, name);
				return name;
			}
			std::string user_name() const
			{
				std::string name;
				get_info(SQL_USER_NAME, name);
				return name;
			}
			std::string db_name() const
			{
				std::string name;
				get_info(SQL_DATABASE_NAME, name);
				return name;
			}
			const std::string &connection_text() const
			{
				return m_connection;
			}

		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)
			{
			}
			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)
			{
				statement stmt(*this);
				stmt.open(query_text, text_length);
				return stmt;
			}
			statement open_command(const char *query_text)
			{
				return open_command(query_text, strlen(query_text));
			}
			statement open_command(const std::string &query_text)
			{
				return open_command(query_text.data(), query_text.length());
			}

			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)
					verify_error(ret);
			}
			void simple_execute(const std::string &query_text)
			{
				simple_execute(query_text.data(), query_text.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);
			}

			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
		{
			date()
			{
				memset(this, 0, sizeof(SQL_DATE_STRUCT));
			}
		};

		struct time : public SQL_TIME_STRUCT
		{
			time()
			{
				memset(this, 0, sizeof(SQL_TIME_STRUCT));
			}
		};

		struct timestamp : public SQL_TIMESTAMP_STRUCT
		{
			timestamp()
			{
				memset(this, 0, sizeof(SQL_TIMESTAMP_STRUCT));
			}
			timestamp(struct tm &tm)
			{
				year = tm.tm_year + 1900;
				month = tm.tm_mon + 1;
				day = tm.tm_mday;
				hour = tm.tm_hour;
				minute = tm.tm_min;
				second = tm.tm_sec;
			}
			timestamp(time_t value)
			{
				struct tm tm;
#if defined(_MSC_VER)
				localtime_s(&tm, &value);
#elif defined(_POSIX_VERSION)
				localtime_r(&value, &tm);
#else
				tm = *localtime(&value);
#endif
				new (this) timestamp(tm);
			}
			timestamp(const timestamp &src)
			{
				memcpy(this, &src, sizeof(SQL_TIMESTAMP_STRUCT));
			}
			timestamp &operator=(const timestamp &src)
			{
				if (this != &src)
					memcpy(this, &src, sizeof(SQL_TIMESTAMP_STRUCT));
				return *this;
			}

			static timestamp now()
			{
				time_t value;
				::time(&value);
				return timestamp(value);
			}

			time_t as_tm(struct tm &tm) const
			{
				tm.tm_year = year - 1900;
				tm.tm_mon = month - 1;
				tm.tm_mday = day;
				tm.tm_hour = hour;
				tm.tm_min = minute;
				tm.tm_sec = second;
				return mktime(&tm);
			}
			time_t get_time() const
			{
				struct tm tm;
				return as_tm(tm);
			}
			timeval get_timeval() const
			{
				timeval tv;
				struct tm tm;
				tv.tv_sec = as_tm(tm);
				tv.tv_usec = fraction / 1000;
			}
		};

#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>
		using query_iterator = qtl::query_iterator<statement, Record>;

		template <typename Record>
		using query_result = qtl::query_result<statement, Record>;

		template <typename Params>
		inline statement &operator<<(statement &stmt, const Params &params)
		{
			stmt.reset();
			stmt.execute(params);
			return stmt;
		}

		template <SQLSMALLINT Type>
		inline error::error(const object<Type> &h, SQLINTEGER code)
		{
			m_errno = code;
			if (code == SQL_ERROR || code == SQL_SUCCESS_WITH_INFO)
			{
				SQLSMALLINT i = 0;
				SQLINTEGER err = SQL_SUCCESS;
				SQLCHAR message[SQL_MAX_MESSAGE_LENGTH];
				SQLCHAR state[SQL_SQLSTATE_SIZE + 1];
				std::ostringstream oss;
				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();
			}
			else if (code == SQL_INVALID_HANDLE)
			{
				m_errmsg = "Invalid handle.";
			}
		}

		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;
			const char *token = sp;
			connection_parameter parameter;
			int part_type = part_name;
			while (sp != output_text + text_length)
			{
				switch (*sp)
				{
				case ';':
					parameters.emplace_back(parameter);
					parameter.reset();
					part_type = part_name;
					token = sp + 1;
					break;
				case '=':
					if (part_type == part_prompt)
						parameter.m_prompt.assign(token, sp - token);
					part_type = part_value;
					token = sp + 1;
					break;
				case ':':
					if (part_type == part_name)
						parameter.m_name.assign(token, sp - token);
					part_type = part_prompt;
					token = sp + 1;
					break;
				case '{':
					part_type = part_list;
					parameter.m_value_list.clear();
					token = sp + 1;
					break;
					;
				case '}':
				case ',':
					if (part_type == part_list)
						parameter.m_value_list.emplace_back(token, sp - token);
					token = sp + 1;
					break;
				case '*':
					if (part_type == part_name && token == sp)
					{
						parameter.m_optinal = true;
						token = sp + 1;
					}
					break;
				case '?':
					token = sp + 1;
					break;
				}
				++sp;
			}
			if (!parameter.m_name.empty())
				parameters.emplace_back(parameter);
		}

		inline std::string base_database::create_connection_text(const connection_parameters &parameters)
		{
			std::ostringstream oss;
			for (auto &parameter : parameters)
			{
				if (parameter.m_assigned)
					oss << parameter.m_name << '=' << parameter.m_value << ';';
			}
			return oss.str();
		}

		inline base_statement::base_statement(base_database &db)
			: object(db.handle()), m_blob_buffer(NULL), m_binded_cols(false)
		{
		}

	} // odbc

#ifdef _WIN32

	namespace mssql
	{

		class database : public odbc::database
		{
		public:
			explicit database(odbc::environment &env) : odbc::database(env) {}
			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)
			{
				std::ostringstream oss;
				oss << "DRIVER={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::database::open(oss.str());
			}
		};

#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
	{

		class database : public odbc::database
		{
		public:
			explicit database(odbc::environment &env) : odbc::database(env) {}
			database(database &&src) : odbc::database(std::forward<database>(src)) {}

			void open(const char *filename, const char *user = NULL, const char *password = NULL)
			{
				std::ostringstream oss;
				oss << "DRIVER={Microsoft Access Driver};DBQ=" << filename;
				if (user)
					oss << ";UID:" << user;
				if (password)
					oss << ";PWD=" << password;
				odbc::database::open(oss.str());
			}
		};

	} // msaccess

#endif //_WIN32

}

#endif //_QTL_ODCB_H_