qsqloledb.cpp

/****************************************************************************
** QSQLOLEDB - Qt OLE DB Driver Plugin for Microsoft SQL Server
**
** Copyright (c) 2025 qsqloledb contributors
** Licensed under the MIT License. See LICENSE file for details.
****************************************************************************/
#include "stdafx.h"
#include <atldbsch.h>
#include <limits>
#include "qsqloledb.h"
#include <msoledbsql.h>
#include <atldbcli.h>
#include <qsqlrecord.h>
#include <msdadc.h>
#include <comdef.h>
#include "OLEDBManager.h"

static QString getComErrorString(HRESULT hr)
{
	_com_error err(hr);
	LPCTSTR errMsg = err.ErrorMessage();
	return QString::fromUtf16(errMsg);
}

class MemoryStream : public ISequentialStream
{
public:
	MemoryStream(const QByteArray& data)
		: m_ref(1), m_data(data), m_pos(0) {
	}

	STDMETHODIMP QueryInterface(REFIID riid, void** ppv) override
	{
		if (riid == IID_IUnknown || riid == IID_ISequentialStream)
		{
			*ppv = static_cast<ISequentialStream*>(this);
			AddRef();
			return S_OK;
		}
		*ppv = 0;
		return E_NOINTERFACE;
	}

	STDMETHODIMP_(ULONG) AddRef() override
	{
		return InterlockedIncrement(&m_ref);
	}

	STDMETHODIMP_(ULONG) Release() override
	{
		ULONG r = InterlockedDecrement(&m_ref);
		if (!r) delete this;
		return r;
	}

	STDMETHODIMP Read(void* pv, ULONG cb, ULONG* pcbRead) override
	{
		ULONG remain = m_data.size() - m_pos;
		ULONG toRead = qMin(cb, remain);

		memcpy(pv, m_data.constData() + m_pos, toRead);
		m_pos += toRead;

		if (pcbRead) *pcbRead = toRead;

		return toRead ? S_OK : S_FALSE;
	}

	STDMETHODIMP Write(const void*, ULONG, ULONG*) override
	{
		return STG_E_ACCESSDENIED;
	}

private:
	LONG m_ref;
	QByteArray m_data;
	ULONG m_pos;
};



class CDynamicParameterAccessorEx : public CDynamicParameterAccessor
{
public:
	// Captures original DB types before base class modifies them during BLOB binding,
	// then delegates all binding work to the base class.
	HRESULT BindColumns(IUnknown* pUnk) throw()
	{
		originDbType.clear();

		CComPtr<IColumnsInfo> spColumnsInfo;
		HRESULT hr = pUnk->QueryInterface(&spColumnsInfo);
		if (FAILED(hr))
			return hr;

		DBORDINAL nCols = 0;
		DBCOLUMNINFO* pColInfo = NULL;
		LPOLESTR pStrBuf = NULL;
		hr = spColumnsInfo->GetColumnInfo(&nCols, &pColInfo, &pStrBuf);
		if (SUCCEEDED(hr))
		{
			for (DBORDINAL i = 0; i < nCols; i++)
				originDbType << pColInfo[i].wType;
			CoTaskMemFree(pColInfo);
			CoTaskMemFree(pStrBuf);
		}

		return CDynamicParameterAccessor::BindColumns(pUnk);
	}

	// Binds command parameters with original type tracking and
	// ISequentialStream conversion for large (>8000 byte) parameters.
	HRESULT BindParameters(HACCESSOR* pHAccessor, ICommand* pCommand,
		void** ppParameterBuffer, bool fBindLength = false,
		bool fBindStatus = false) throw()
	{
		if (m_pParameterBuffer != NULL)
		{
			*ppParameterBuffer = m_pParameterBuffer;
			return S_OK;
		}
		if (*pHAccessor != NULL)
		{
			*ppParameterBuffer = m_pParameterBuffer;
			return S_OK;
		}

		ATLENSURE_RETURN(pCommand != NULL);
		CComPtr<IAccessor> spAccessor;
		HRESULT hr = pCommand->QueryInterface(&spAccessor);
		if (FAILED(hr))
			return hr;

		CComPtr<ICommandWithParameters> spCmdParams;
		hr = pCommand->QueryInterface(&spCmdParams);
		if (FAILED(hr))
			return hr;

		DB_UPARAMS paramCount = 0;
		CComHeapPtr<DBPARAMINFO> paramInfo;
		LPOLESTR namesBuf;
		hr = spCmdParams->GetParameterInfo(&paramCount, &paramInfo, &namesBuf);
		if (FAILED(hr))
			return hr;

		hr = AllocateParameterInfo(paramCount);
		if (FAILED(hr))
		{
			CoTaskMemFree(namesBuf);
			return hr;
		}

		originDbType.clear();
		DBBYTEOFFSET bufOffset = 0, dataOff = 0, lenOff = 0, statusOff = 0;
		DBBINDING* pCur = m_pParameterEntry;

		for (ULONG i = 0; i < paramCount; i++)
		{
			originDbType << paramInfo[i].wType;
			m_pParameterEntry[i].eParamIO = 0;

			DBOBJECT* pStreamObj = NULL;
			if (paramInfo[i].ulParamSize > 8000)
			{
				pStreamObj = new (std::nothrow) DBOBJECT;
				if (!pStreamObj)
					return E_OUTOFMEMORY;
				pStreamObj->dwFlags = STGM_READWRITE;
				pStreamObj->iid = IID_ISequentialStream;
				paramInfo[i].wType = DBTYPE_IUNKNOWN;
				paramInfo[i].ulParamSize = sizeof(IUnknown*);
			}

			if (paramInfo[i].dwFlags & DBPARAMFLAGS_ISINPUT)
				m_pParameterEntry[i].eParamIO |= DBPARAMIO_INPUT;
			if (paramInfo[i].dwFlags & DBPARAMFLAGS_ISOUTPUT)
				m_pParameterEntry[i].eParamIO |= DBPARAMIO_OUTPUT;

			DBLENGTH len = paramInfo[i].ulParamSize;
			if (paramInfo[i].wType == DBTYPE_STR)
				len += 1;
			if (paramInfo[i].wType == DBTYPE_WSTR)
				len = len * 2 + 2;

			dataOff = AlignAndIncrementOffset(bufOffset, len, GetAlignment(paramInfo[i].wType));
			if (fBindLength)
				lenOff = AlignAndIncrementOffset(bufOffset, sizeof(DBLENGTH), __alignof(DBLENGTH));
			if (fBindStatus)
				statusOff = AlignAndIncrementOffset(bufOffset, sizeof(DBSTATUS), __alignof(DBSTATUS));

			Bind(pCur, paramInfo[i].iOrdinal, paramInfo[i].wType,
				len, paramInfo[i].bPrecision, paramInfo[i].bScale,
				m_pParameterEntry[i].eParamIO, dataOff, lenOff, statusOff, pStreamObj);
			pCur++;

			m_ppParamName[i] = namesBuf;
			if (namesBuf && *namesBuf)
			{
				while (*namesBuf++)
					;
			}
		}

		m_pParameterBuffer = new (std::nothrow) BYTE[bufOffset];
		if (!m_pParameterBuffer)
			return E_OUTOFMEMORY;

		*ppParameterBuffer = m_pParameterBuffer;
		m_nParameterBufferSize = bufOffset;
		m_nParams = paramCount;
		BindEntries(m_pParameterEntry, paramCount, pHAccessor, bufOffset, spAccessor);

		return S_OK;
	}

	QList<int> originDbType;
};
static DBTIMESTAMP toDBTimeStamp(const QDateTime& t)
{
	DBTIMESTAMP stamp;
	if (t.isValid())
	{
		stamp.day = t.date().day();
		stamp.month = t.date().month();
		stamp.year = t.date().year();
		stamp.hour = t.time().hour();
		stamp.minute = t.time().minute();
		stamp.second = t.time().second();
		stamp.fraction = t.time().msec() * 1000000;
	}
	return stamp;
}

static DBTIME toDBTime(const QTime& t)
{
	DBTIME stamp;
	stamp.hour = t.hour();
	stamp.minute = t.minute();
	stamp.second = t.second();
	return stamp;
}


static QString getErrorString(IUnknown* pUnk, const IID& iid)
{
	CDBErrorInfo	error;
	unsigned long	errrecord = 0;
	if (pUnk == 0)
	{
		return QString::fromUtf16(L"Critical Error");
	}
	HRESULT hr = error.GetErrorRecords(pUnk, iid, &errrecord);
	if (FAILED(hr) || hr == S_FALSE || errrecord == 0)
	{
		return QString::fromUtf16(L"Critical Error");
	}
	LCID lcid = GetUserDefaultLCID();
	QString strdescriptions;
	for (int i = 0; i < errrecord; i++)
	{
		BSTR description;
		hr = error.GetAllErrorInfo(i, lcid, &description, 0, 0, 0, 0);
		QString strDes = QString::fromUtf16(description);
		if (i < errrecord - 1)
			strDes += QString::fromUtf16(L" ");
		strdescriptions += strDes;
		SysFreeString(description);
	}
	return strdescriptions;
}

static QSqlError	qMakeError(const QString& error, QSqlError::ErrorType type)
{
	return QSqlError("MSSQL DB: ", error, type);
}
static QVariant::Type decodeOLEDBType(DBTYPE sqltype, bool isSigned = true)
{
	QVariant::Type type = QVariant::Invalid;
	switch (sqltype)
	{
	case DBTYPE_R4:
	case DBTYPE_R8:
		type = QVariant::Double;
		break;
	case DBTYPE_NUMERIC:
	case DBTYPE_CY:
	case DBTYPE_I8:
		type = QVariant::LongLong;
		break;
	case DBTYPE_I2:
	case DBTYPE_UI1:
	case DBTYPE_I4:
		type = QVariant::Int;
		break;

	case DBTYPE_BOOL:
		type = QVariant::Bool;
		break;

	case DBTYPE_UI4:
		type = QVariant::UInt;
		break;
	case DBTYPE_UI8:
		type = QVariant::ULongLong;
		break;

	case DBTYPE_BYTES:
		type = QVariant::ByteArray;
		break;

	case DBTYPE_DBDATE:
	case DBTYPE_DBTIMESTAMP:
		type = QVariant::DateTime;
		break;
	case DBTYPE_DBTIME:
		type = QVariant::Time;
		break;

	case DBTYPE_WSTR:
	case DBTYPE_STR:
	case DBTYPE_BSTR:
		type = QVariant::String;
		break;
	default:
		type = QVariant::ByteArray;
		break;
	}
	return type;
}



class QSqlOLEDBResultPrivate
{
public:
	QSqlOLEDBResultPrivate(QSqlOLEDBDriverPrivate* priv);
	~QSqlOLEDBResultPrivate() {
		cleanup();
	}

public:
	bool	checkDriver();
	void	cleanup();
	inline void clearValues()
	{
		fieldCache.fill(QVariant()); fieldIndex = 0;
	}
	template<typename T> void getDataWithNull(int Index, T* value, bool& isNull)
	{
		isNull = false;
		*value = (T)cmd.GetValue(Index);
		DBSTATUS status;
		cmd.GetStatus(Index, &status);
		DBTYPE type;
		cmd.GetColumnType(Index, &type);
		if (status == DBSTATUS_S_ISNULL)
		{
			isNull = true;
			if (type == DBTYPE_STR || type == DBTYPE_WSTR)
				*value = 0;
			else
				**value = 0;
		}
	}
	template<> void getDataWithNull<DBTIMESTAMP*>(int Index, DBTIMESTAMP** value, bool& isNull)
	{
		isNull = false;
		*value = (DBTIMESTAMP*)cmd.GetValue(Index);
		DBSTATUS status;
		cmd.GetStatus(Index, &status);
		DBTYPE type;
		cmd.GetColumnType(Index, &type);
		if (status == DBSTATUS_S_ISNULL)
		{
			isNull = true;
			*value = 0;
		}
	}

	template<> void getDataWithNull<DBTIME*>(int Index, DBTIME** value, bool& isNull)
	{
		isNull = false;
		*value = (DBTIME*)cmd.GetValue(Index);
		DBSTATUS status;
		cmd.GetStatus(Index, &status);
		DBTYPE type;
		cmd.GetColumnType(Index, &type);
		if (status == DBSTATUS_S_ISNULL)
		{
			isNull = true;
			*value = 0;
		}
	}

	template<> void getDataWithNull<DB_NUMERIC*>(int Index, DB_NUMERIC** value, bool& isNull)
	{
		isNull = false;
		*value = (DB_NUMERIC*)cmd.GetValue(Index);
		DBSTATUS status;
		cmd.GetStatus(Index, &status);
		DBTYPE type;
		cmd.GetColumnType(Index, &type);
		if (status == DBSTATUS_S_ISNULL)
		{
			isNull = true;
			*value = 0;
		}
	}

	template<> void getDataWithNull<IUnknown*>(int Index, IUnknown** value, bool& isNull)
	{
		isNull = false;
		*value = (IUnknown*)cmd.GetValue(Index);
		DBSTATUS status;
		cmd.GetStatus(Index, &status);
		DBTYPE type;
		cmd.GetColumnType(Index, &type);
		if (status == DBSTATUS_S_ISNULL)
		{
			isNull = true;
			*value = 0;
		}
	}
public:
	ATL::CCommand<CDynamicParameterAccessorEx, CRowset>	cmd;
	QSqlOLEDBDriverPrivate* driverPrivate;
	CDBPropSet				rowsetProperty;
	DBROWCOUNT				affectedRow;
	QSqlRecord				fieldInfo;
	QVector<QVariant>		fieldCache;
	unsigned long			fieldIndex;
	bool					m_inited;
};


class QSqlOLEDBDriverPrivate
{
public:
	QSqlOLEDBDriverPrivate() :m_isClientCursor(true) 
	{
	}
	~QSqlOLEDBDriverPrivate() 
	{
		m_db.Close();
		m_session.Close();
	}
public:
	bool isClientCursor() { return m_isClientCursor; }
public:
	CDataSource	m_db;
	CSession	m_session;
	QString		m_currentTable;
	QSqlIndex	primaryIndex;
	bool		m_isClientCursor;
};


QSqlOLEDBResultPrivate::QSqlOLEDBResultPrivate(QSqlOLEDBDriverPrivate* priv)
	:driverPrivate(priv), rowsetProperty(DBPROPSET_ROWSET), affectedRow(0), fieldIndex(0), m_inited(false)
{
	cmd.SetBlobHandling(DBBLOBHANDLING_DEFAULT);
	cmd.SetBlobSizeLimit(1000000);
	long  cmdTimeout = 30;
	if (priv->m_isClientCursor == false)
	{
		rowsetProperty.AddProperty(DBPROP_CLIENTCURSOR, VARIANT_FALSE);
	}
	else
	{
		rowsetProperty.AddProperty(DBPROP_CLIENTCURSOR, VARIANT_TRUE);
	}
	rowsetProperty.AddProperty(DBPROP_IRowsetChange, VARIANT_TRUE);
	rowsetProperty.AddProperty(DBPROP_ISequentialStream, VARIANT_TRUE);

	rowsetProperty.AddProperty(DBPROP_COMMANDTIMEOUT, cmdTimeout);
	rowsetProperty.AddProperty(DBPROP_UPDATABILITY, DBPROPVAL_UP_CHANGE | DBPROPVAL_UP_INSERT | DBPROPVAL_UP_DELETE);
}

void QSqlOLEDBResultPrivate::cleanup()
{
	cmd.Close();
	cmd.FreeRecordMemory();
	cmd.ReleaseCommand(); // ICommand Release
}
static QSqlField qMakeFieldInfo(int i, QSqlOLEDBResultPrivate* p)
{
	DBORDINAL c = i;
	DBTYPE type;
	p->cmd.TranslateColumnNo(c);
	if (p->cmd.originDbType.count() > c)
		type = p->cmd.originDbType[c];
	else
		p->cmd.GetColumnType(i, &type);
	QString strColumnName = QString::fromUtf16(p->cmd.GetColumnName(i));
	QSqlField field(strColumnName, decodeOLEDBType(type));
	field.setSqlType(type);
	return field;
}

static QSqlField qMakeFieldInfo(DBCOLUMNINFO* pColumn, DBTYPE type)
{
	QSqlField field(QString::fromUtf16(pColumn->pwszName), decodeOLEDBType(type));
	field.setSqlType(type);
	field.setLength(pColumn->dwFlags & DBCOLUMNFLAGSENUM::DBCOLUMNFLAGS_ISFIXEDLENGTH ? pColumn->ulColumnSize : -1);
	field.setPrecision(pColumn->bPrecision);
	return field;
}

static bool longlongToNumeric(quint64 n, DB_NUMERIC& dest)
{
	IDataConvert* data_convert_ptr = 0;
	DBSTATUS pdbsStatus;
	HRESULT hr = CoCreateInstance(CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, IID_IDataConvert, (void**)&data_convert_ptr);
	if (hr != S_OK)
		return false;
	DBLENGTH cbdest;
	hr = data_convert_ptr->DataConvert(
		DBTYPE_I8, DBTYPE_NUMERIC, (ULONG)sizeof(qlonglong), &cbdest,
		(void*)&n, (void*)&dest, (ULONG)sizeof(DB_NUMERIC), DBSTATUS_S_OK, &pdbsStatus,
		0, 0, DBDATACONVERT_DEFAULT);
	data_convert_ptr->Release();
	return true;
}

static double getNumericValue(DB_NUMERIC* n)
{
	IDataConvert* data_convert_ptr = 0;
	DBSTATUS pdbsStatus;
	HRESULT hr = CoCreateInstance(CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, IID_IDataConvert, (void**)&data_convert_ptr);
	if (hr != S_OK)
		return 0;
	double dest;
	DBLENGTH cbdest;
	hr = data_convert_ptr->DataConvert(
		DBTYPE_NUMERIC, DBTYPE_R8, (ULONG)sizeof(struct tagDB_NUMERIC), &cbdest,
		(void*)n, (void*)&dest, (ULONG)sizeof(double), DBSTATUS_S_OK, &pdbsStatus,
		n->precision, n->scale, DBDATACONVERT_DEFAULT);
	data_convert_ptr->Release();
	return dest;
}

static double getNumericValue(QSqlOLEDBResultPrivate* result, int column, bool& isNull)
{
	QByteArray fieldVal;
	DB_NUMERIC* v;
	result->getDataWithNull(column, &v, isNull);
	if (v != 0)
		return getNumericValue(v);
	return 0;
}

static QByteArray getBinaryData(QSqlOLEDBResultPrivate* result, int column)
{
	IUnknown** iUnknown = 0;
	bool isNull = false;
	result->getDataWithNull(column, &iUnknown, isNull);
	if (isNull || !iUnknown || !*iUnknown)
		return QByteArray();
	ISequentialStream* stream = 0;
	HRESULT hr = (*iUnknown)->QueryInterface(IID_ISequentialStream, (void**)&stream);

	if (FAILED(hr) || !stream)
		return QByteArray();

	const int chunkSize = 64 * 1024;
	QByteArray buffer;
	buffer.reserve(chunkSize);

	ULONG bytesRead = 0;
	char chunk[chunkSize];
	while (true)
	{
		hr = stream->Read(chunk, chunkSize, &bytesRead);
		if (FAILED(hr) || bytesRead == 0)
			break;
		buffer.append(chunk, bytesRead);
	}
	stream->Release();
	return buffer;
}

static QString getStringData(QSqlOLEDBResultPrivate* result, int column)
{
	QString fieldValue;
	DBORDINAL c = column;
	result->cmd.TranslateColumnNo(c);

	DBCOLUMNINFO info = result->cmd.m_pColumnInfo[c];
	bool isNull = false;
	if (info.wType == DBTYPE_STR)
	{
		char* value = 0;
		result->getDataWithNull(column, &value, isNull);
		if (value != 0)
			fieldValue = QString::fromLocal8Bit(value);
	}
	else if (info.wType == DBTYPE_WSTR)
	{
		wchar_t* value = 0;
		result->getDataWithNull(column, &value, isNull);
		if (value != 0)
			fieldValue = QString::fromUtf16(value);
	}
	return fieldValue;
}

QSqlOLEDBResult::QSqlOLEDBResult(const QSqlOLEDBDriver* db, QSqlOLEDBDriverPrivate* p)
	:QSqlResult(db), oldebd(p)
{
	d = new QSqlOLEDBResultPrivate(p);
	if (!p->isClientCursor())
	{
		CDBPropSet p = CDBPropSet(DBPROPSET_ROWSET);
		d->rowsetProperty = p;
	}
}

QSqlOLEDBResult::~QSqlOLEDBResult()
{
	delete d;
}

QVariant QSqlOLEDBResult::handle() const
{
	return QVariant();
}

QSqlRecord QSqlOLEDBResult::record() const
{
	if (!isActive() || !isSelect())
		return QSqlRecord();
	return d->fieldInfo;
}

QVariant QSqlOLEDBResult::lastInsertId() const
{
	QString query;
	QString tableName = d->driverPrivate->m_currentTable;
	query = QString::fromUtf16(L"SELECT  @@IDENTITY  AS LASTID ");
	ATL::CCommand<CDynamicAccessor, CRowset>	cmd;
	HRESULT hr = cmd.Open(oldebd->m_session, query.utf16(), 0);

	if (hr == S_OK)
	{
		if (cmd.MoveNext() == S_OK)
		{
			DB_NUMERIC* id = 0;
			DBSTATUS status;
			cmd.GetStatus(1, &status);
			DBTYPE ty;
			cmd.GetColumnType(1, &ty);
			if (status != DBSTATUS_S_ISNULL)
			{
				id = (DB_NUMERIC*)cmd.GetValue("LASTID");
				if (id != 0)
					return getNumericValue(id);
			}
		}
	}
	return QVariant();
}

bool QSqlOLEDBResult::reset(const QString& query)
{
	setActive(false);
	setAt(QSql::BeforeFirstRow);
	if (prepare(query))
		if (exec())
			return true;
	return false;
}

bool QSqlOLEDBResult::prepare(const QString& query)
{
	if (!driver() || !driver()->isOpen() || driver()->isOpenError())
		return false;
	d->cleanup();
	setSelect(false);
	d->cmd.SetBlobHandling(DBBLOBHANDLING_DEFAULT);
	HRESULT hr = d->cmd.Create(oldebd->m_session, query.utf16());
	if (hr != S_OK)
	{
		setLastError(qMakeError(getErrorString(d->cmd.m_spCommand, IID_ICommand), QSqlError::StatementError));
		return false;
	}
	hr = d->cmd.Prepare();
	if (hr != S_OK)
	{
		setLastError(qMakeError(getErrorString(d->cmd.m_spCommand, IID_ICommand), QSqlError::StatementError));
		return false;
	}
	return hr == S_OK ? true : false;
}
static void doCheckNumeric(ATL::CCommand<CDynamicParameterAccessorEx, CRowset>* cmd, const QVariant& v, DBTYPE t, int i, QVector<ISequentialStream*>* streams)
{
	if (t == DBTYPE_NUMERIC)
	{
		qlonglong value = v.toLongLong();
		DB_NUMERIC numeric;
		if (longlongToNumeric(value, numeric))
		{
			cmd->SetParam<DB_NUMERIC>(i + 1, &numeric);
		}
	}
	else if (t == DBTYPE_UI1)
	{
		quint8 value = v.toInt();
		cmd->SetParam(i + 1, &value);
	}
	else if (t == DBTYPE_I1)
	{
		qint8 value = v.toInt();
		cmd->SetParam(i + 1, &value);
	}
	else if (t == DBTYPE_I2)
	{
		short value = v.toInt();
		cmd->SetParam(i + 1, &value);
	}
	else if (t == DBTYPE_UI2)
	{
		quint16 value = v.toInt();
		cmd->SetParam(i + 1, &value);
	}
	else if (t == DBTYPE_I4)
	{
		int value = v.toInt();
		cmd->SetParam(i + 1, &value);
	}
	else if (t == DBTYPE_UI4)
	{
		qint32 value = v.toUInt();
		cmd->SetParam(i + 1, &value);
	}
	else if (t == DBTYPE_BOOL)
	{
		VARIANT_BOOL value = v.toBool();
		cmd->SetParam<VARIANT_BOOL>(i + 1, &value);
	}
	else if (t == DBTYPE_I8)
	{
		qlonglong value = v.toLongLong();
		cmd->SetParam<qlonglong>(i + 1, &value);
	}
	else if (t == DBTYPE_UI8)
	{
		qulonglong value = v.toULongLong();
		cmd->SetParam<qulonglong>(i + 1, &value);
	}
	else if (t == DBTYPE_DBTIMESTAMP)
	{
		DBTIMESTAMP stamp = toDBTimeStamp(QDateTime::fromMSecsSinceEpoch(0));
		cmd->SetParam<DBTIMESTAMP>(i + 1, &stamp);
		cmd->SetParamStatus(i + 1, DBSTATUS_S_ISNULL);
	}
	else if (t == DBTYPE_IUNKNOWN)
	{
		DBTYPE originType = DBTYPE_IUNKNOWN;
		if (cmd->originDbType.count() > i)
			originType = cmd->originDbType[i];
		ULONG cbWritten;

		MemoryStream* stream = 0;
		if (originType == DBTYPE_BYTES || originType == DBTYPE_STR)
		{
			QByteArray buf = v.toString().toLatin1();
			stream = new MemoryStream(buf);
			stream->AddRef();
			cbWritten = buf.size();
		}
		else if (originType == DBTYPE_WSTR)
		{
			QString string = v.toString();
			QByteArray utf16(reinterpret_cast<const char*>(string.utf16()), string.size() * sizeof(ushort));
			stream = new MemoryStream(utf16);
			stream->AddRef();
			cbWritten = utf16.size();
		}
		if (stream)
		{
			IUnknown** p = (IUnknown**)cmd->GetParam(i + 1);
			*p = stream;
			streams->append(stream);
			DBLENGTH* size = cmd->GetParamLength(i + 1);
			*size = cbWritten;
		}
	}
	else
	{
		int value = v.toInt();
		cmd->SetParam(i + 1, &value);
	}
}
bool QSqlOLEDBResult::exec()
{
	setActive(false);
	setSelect(false);
	setAt(QSql::BeforeFirstRow);
	if (d->cmd.m_spCommand == 0)
		return false;
	d->affectedRow = 0;
	const QVector<QVariant> values = boundValues();
	HRESULT hr;
	QVector<ISequentialStream*> streams;
	if (!values.empty())
	{
		void* pDummy;
		hr = d->cmd.BindParameters(&d->cmd.m_hParameterAccessor, d->cmd.m_spCommand, &pDummy, 1, 1);

		ULONG ulParamCount = d->cmd.GetParamCount();
		memset(d->cmd.m_pParameterBuffer, 0, d->cmd.m_nParameterBufferSize);

		for (int i = 0; i < values.size(); i++)
		{
			QVariant v = values[i];
			DBSTATUS* status = d->cmd.GetParamStatus(i + 1);
			if (v.isNull() && *status == DBSTATUS_S_ISNULL)
			{
				d->cmd.SetParamStatus(i + 1, DBSTATUS_S_ISNULL);
				continue;
			}
			DBTYPE t;
			d->cmd.GetParamType(i + 1, &t);
			*status = DBSTATUS_S_OK;
			switch (v.type())
			{
			case QVariant::Time:
			{
				DBTIME stamp;
				if (v.toTime().isValid())
				{
					stamp = toDBTime(v.toTime());
					d->cmd.SetParam<DBTIME>(i + 1, &stamp);
				}
				else
				{
					DBTIME stamp = toDBTime(QTime(0, 0, 0));

					d->cmd.SetParam<DBTIME>(i + 1, &stamp);
					d->cmd.SetParamStatus(i + 1, DBSTATUS_S_ISNULL);
				}
			}
			break;
			case QVariant::DateTime:
			{
				DBTIMESTAMP stamp;
				if (v.toDateTime().isValid() && v.toDateTime().toTime_t() != 0)
				{
					stamp = toDBTimeStamp(v.toDateTime());
					d->cmd.SetParam<DBTIMESTAMP>(i + 1, &stamp);
				}
				else
				{
					DBTIMESTAMP stamp = toDBTimeStamp(QDateTime::fromMSecsSinceEpoch(0));

					d->cmd.SetParam<DBTIMESTAMP>(i + 1, &stamp);
					d->cmd.SetParamStatus(i + 1, DBSTATUS_S_ISNULL);
				}
			}
			break;
			case QVariant::ByteArray:
			{
				DBTYPE t;
				d->cmd.GetParamType(i + 1, &t);
				ULONG cbWritten;
				QByteArray buf = v.toByteArray();
				if (t == DBTYPE_BYTES || t == DBTYPE_STR)
				{
					d->cmd.SetParamString(i + 1, buf);
				}
				else if (t == DBTYPE_IUNKNOWN)
				{
					DBTYPE originType = DBTYPE_IUNKNOWN;
					if (d->cmd.originDbType.count() > i)
					{
						originType = d->cmd.originDbType[i];
					}
					MemoryStream* stream = 0;
					if (originType == DBTYPE_BYTES || originType == DBTYPE_STR)
					{
						stream = new MemoryStream(buf);
						stream->AddRef();
						cbWritten = buf.size();
					}
					else if (originType == DBTYPE_WSTR)
					{
						QString utf16String = QString::fromUtf8(buf);
						QByteArray utf16(reinterpret_cast<const char*>(utf16String.utf16()), utf16String.size() * sizeof(ushort));
						stream = new MemoryStream(utf16);
						stream->AddRef();
						cbWritten = utf16.size();
					}
					if (stream)
					{
						IUnknown** p = (IUnknown**)d->cmd.GetParam(i + 1);
						*p = stream;
						streams.append(stream);
						DBLENGTH* size = d->cmd.GetParamLength(i + 1);
						*size = cbWritten;
					}
				}
				else
				{
					QString s = QString::fromLatin1(buf);
					d->cmd.SetParamString(i + 1, s.utf16());
				}
			}
			break;
			case QVariant::String:
			{
				QString string = v.toString();
				d->cmd.GetParamType(i + 1, &t);
				if (t == DBTYPE_BYTES || t == DBTYPE_STR)
				{

					d->cmd.SetParamString(i + 1, string.toLatin1());
				}
				else if (t == DBTYPE_IUNKNOWN)
				{
					DBTYPE originType = DBTYPE_IUNKNOWN;
					ULONG cbWritten;
					if (d->cmd.originDbType.count() > i)
						originType = d->cmd.originDbType[i];

					DBLENGTH* size = d->cmd.GetParamLength(i + 1);
					MemoryStream* stream = 0;
					if (originType == DBTYPE_BYTES || originType == DBTYPE_STR)
					{
						QByteArray buf = string.toLatin1();
						stream = new MemoryStream(buf);
						stream->AddRef();
						cbWritten = buf.size();
					}
					else if (originType == DBTYPE_WSTR)
					{
						QByteArray utf16(reinterpret_cast<const char*>(string.utf16()), string.size() * sizeof(ushort));
						stream = new MemoryStream(utf16);
						stream->AddRef();
						cbWritten = utf16.size();
					}
					if (stream)
					{
						IUnknown** p = (IUnknown**)d->cmd.GetParam(i + 1);
						*p = stream;
						streams.append(stream);
						DBLENGTH* size = d->cmd.GetParamLength(i + 1);
						*size = cbWritten;
					}

				}
				else if (t == DBTYPE_BOOL)
				{
					VARIANT_BOOL value = v.toBool();
					d->cmd.SetParam<VARIANT_BOOL>(i + 1, &value);
				}
				else  if (t == DBTYPE_WSTR)
				{
					QString string = v.toString();
					d->cmd.SetParamString(i + 1, string.utf16());
				}
				else if (t == DBTYPE_DBTIMESTAMP)
				{

					QVariant dt = QVariant(string);
					if (dt.toDateTime().isValid() && dt.toDateTime().toTime_t() != 0)
					{
						DBTIMESTAMP stamp = toDBTimeStamp(v.toDateTime());
						d->cmd.SetParam<DBTIMESTAMP>(i + 1, &stamp);
					}
					else
					{
						DBTIMESTAMP stamp = toDBTimeStamp(QDateTime::fromMSecsSinceEpoch(0));

						d->cmd.SetParam<DBTIMESTAMP>(i + 1, &stamp);
						d->cmd.SetParamStatus(i + 1, DBSTATUS_S_ISNULL);
					}
				}
				else
				{
					qint32 value = v.toInt();
					d->cmd.SetParam(i + 1, &value);
				}
			}
			break;
			case QVariant::Double:
			case QMetaType::Float:
			{
				if (t == DBTYPE_R4)
				{
					float  value = v.toFloat();
					d->cmd.SetParam(i + 1, &value);
				}
				else if (t == DBTYPE_R8)
				{
					qreal  value = v.toDouble();
					d->cmd.SetParam<qreal>(i + 1, &value);
				}

			}
			break;
			default:
			{
				doCheckNumeric(&d->cmd, v, t, i, &streams);
			}
			break;
			}
		}

		hr = d->cmd.Open(0, 0, FALSE, 0);
		{
			if (d->cmd.GetMultiplePtr() != NULL)
			{
				d->cmd.GetMultiplePtr()->Release();
				*d->cmd.GetMultiplePtrAddress() = NULL;
			}

		}

	}
	else
	{
		if (oldebd->isClientCursor())
			hr = d->cmd.ExecuteAndBind(0, &d->rowsetProperty, &d->affectedRow, false);
		else
			hr = d->cmd.ExecuteAndBind(0, 0, 0, 0);
	}

	if (FAILED(hr))
	{
		for (int i = 0; i < streams.count(); i++)
			streams[i]->Release();

		if (hr == E_FAIL)
		{
			setLastError(qMakeError(getErrorString(d->cmd.m_spCommand, IID_ICommand), QSqlError::ConnectionError));
			return false;
		}
		else
		{
			if (d->cmd.GetMultiplePtr() != NULL)
			{
				d->cmd.GetMultiplePtr()->Release();
				*d->cmd.GetMultiplePtrAddress() = NULL;
			}
			setLastError(qMakeError(getErrorString(d->cmd.m_spCommand, IID_ICommand), QSqlError::StatementError));
			return false;
		}
	}
	if (d->cmd.GetInterface() != NULL || d->cmd.m_spRowset != 0)
	{
		hr = d->cmd.Bind();
		if (!SUCCEEDED(hr))
		{
			for (int i = 0; i < streams.count(); i++)
				streams[i]->Release();
			setLastError(qMakeError(getErrorString(d->cmd.m_spCommand, IID_ICommand), QSqlError::StatementError));
			return false;
		}
		setSelect(true);
		d->fieldInfo.clear();
		for (int i = 1; i < d->cmd.GetColumnCount() + d->cmd.m_pColumnInfo->iOrdinal; i++)
		{
			d->fieldInfo.append(qMakeFieldInfo(i, d));
		}
		d->fieldCache.resize(d->cmd.GetColumnCount() + d->cmd.m_pColumnInfo->iOrdinal - 1);
	}
	for (int i = 0; i < streams.count(); i++)
		streams[i]->Release();
	setActive(true);
	return true;
}

int QSqlOLEDBResult::size()
{
	if (d->cmd.m_spRowset && isSelect())
	{
		DBCOUNTITEM nCount;
		d->cmd.GetApproximatePosition(NULL, NULL, &nCount);
		return nCount;
	}
	return 0;
}

int QSqlOLEDBResult::numRowsAffected()
{
	return d->affectedRow;
}

QVariant QSqlOLEDBResult::data(int field)
{
	if (field >= d->fieldInfo.count() || field < 0) {
		qWarning() << "QLEDBResult::data: column" << field << "out of range";
		return QVariant();
	}
	if (field < d->fieldIndex)
		return d->fieldCache.at(field);
	DBLENGTH lengthIndicator = 0;

	for (int i = d->fieldIndex; i <= field; ++i) {
		const QSqlField info = d->fieldInfo.field(i);
		QVariant value;
		bool isNull;
		switch (info.type())
		{
		case QVariant::LongLong:
		{
			DBORDINAL c = i + 1;
			d->cmd.TranslateColumnNo(c);
			DBCOLUMNINFO info = d->cmd.m_pColumnInfo[c];

			bool isNull = false;
			if (info.wType == DBTYPE_NUMERIC)
			{
				d->fieldCache[i] = getNumericValue(d, i + 1, isNull);
				if (isNull == true)
					d->fieldCache[i] = QVariant(QVariant::LongLong);
			}
			else
			{
				LONGLONG* v = 0;
				d->getDataWithNull(i + 1, &v, isNull);
				if (isNull == true)
					d->fieldCache[i] = QVariant(QVariant::LongLong);
				else
				{
					if (v != 0)
						d->fieldCache[i] = QVariant(*v);
					else
						d->fieldCache[i] = QVariant(QVariant::LongLong);
				}
			}
		}
		break;
		case QVariant::ULongLong:
		{
			ULONGLONG* v = 0;
			d->getDataWithNull(i + 1, &v, isNull);

			if (isNull == true)
				d->fieldCache[i] = QVariant(QVariant::ULongLong);
			else
			{
				if (v != 0)
					d->fieldCache[i] = QVariant(*v);
				else
					d->fieldCache[i] = QVariant(QVariant::ULongLong);
			}
		}
		break;
		case QVariant::Int:
		{
			int* v = 0;
			d->getDataWithNull(i + 1, &v, isNull);
			if (isNull == true)
				d->fieldCache[i] = QVariant(QVariant::Int);
			else
			{
				DBTYPE type;
				d->cmd.GetColumnType(i + 1, &type);
				if (type == DBTYPE_I2)
					d->fieldCache[i] = qint16(*v);
				else if (v != 0)
					d->fieldCache[i] = QVariant(*v);
				else
					d->fieldCache[i] = QVariant(QVariant::Int);
			}
		}
		break;

		case QVariant::Bool:
		{
			/* 0 == FALSE, -1 == TRUE */
			VARIANT_BOOL* v = 0;
			d->getDataWithNull(i + 1, &v, isNull);

			if (isNull == true)
				d->fieldCache[i] = QVariant(false);
			else
			{
				if (*v == -1)
					d->fieldCache[i] = QVariant(true);
				else
					d->fieldCache[i] = QVariant(false);
			}
		}
		break;
		case QVariant::UInt:
		{
			unsigned int* v = 0;
			d->getDataWithNull(i + 1, &v, isNull);

			if (isNull == true)
				d->fieldCache[i] = QVariant(QVariant::UInt);
			else
			{

				if (v != 0)
					d->fieldCache[i] = QVariant(*v);
				else
					d->fieldCache[i] = QVariant(QVariant::UInt);
			}
		}
		break;
		case QVariant::Time:
		{
			DBTIME* v = 0;
			d->getDataWithNull(i + 1, &v, isNull);

			if (isNull == true)
				d->fieldCache[i] = QVariant(QVariant::Time);
			else
			{
				if (v != 0)
				{
					d->fieldCache[i] = QVariant(QTime(v->hour, v->minute, v->second, 0));
				}
				else
					d->fieldCache[i] = QVariant(QVariant::Time);
			}
		}
		break;
		case QVariant::DateTime:
		{
			DBTIMESTAMP* v = 0;
			d->getDataWithNull(i + 1, &v, isNull);

			if (isNull == true)
				d->fieldCache[i] = QVariant(QVariant::DateTime);
			else
			{
				if (v != 0)
				{
					if (v->year < 1970)
					{
						d->fieldCache[i] = QVariant(QDateTime::fromTime_t(0));
					}
					else
					{
						d->fieldCache[i] = QVariant(QDateTime(QDate(v->year, v->month, v->day),
							QTime(v->hour, v->minute, v->second, v->fraction / 1000000)));
					}
				}
				else
					d->fieldCache[i] = QVariant(QVariant::DateTime);
			}
		}
		break;
		case QVariant::ByteArray:
		case QVariant::String:
		{
			DBORDINAL c = i + 1;
			d->cmd.TranslateColumnNo(c);
			DBCOLUMNINFO info = d->cmd.m_pColumnInfo[c];

			if (info.wType == DBTYPE_IUNKNOWN)
			{
				QByteArray array = getBinaryData(d, i + 1);;
				DBTYPE originType = DBTYPE_IUNKNOWN;
				if (d->cmd.originDbType.count() > c)
					originType = d->cmd.originDbType[c];

				if (originType == DBTYPE_WSTR)
				{
					QString c = QString::fromUtf16((ushort*)array.data(), array.count() / 2);;
					d->fieldCache[i] = c;
				}
				else
					d->fieldCache[i] = array;
			}
			else
			{
				d->fieldCache[i] = getStringData(d, i + 1);
			}

		}
		break;
		case QVariant::Double:
		{

			DBORDINAL c = i + 1;
			d->cmd.TranslateColumnNo(c);
			DBCOLUMNINFO info = d->cmd.m_pColumnInfo[c];
			bool isNull = false;
			if (info.wType == DBTYPE_R8)
			{
				double* v = 0;
				d->getDataWithNull(i + 1, &v, isNull);
				if (isNull == true)
				{
					d->fieldCache[i] = QVariant(QVariant::Double);
				}
				else
				{
					if (v != 0)
						d->fieldCache[i] = QVariant(*v);
					else
						d->fieldCache[i] = QVariant(QVariant::Double);
				}
			}
			else if (info.wType == DBTYPE_R4)
			{
				float* v = 0;

				d->getDataWithNull(i + 1, &v, isNull);

				if (isNull == true)
					d->fieldCache[i] = QVariant(QVariant::Double);
				else
				{
					if (v != 0)
						d->fieldCache[i] = QVariant(*v);
					else
						d->fieldCache[i] = QVariant(QVariant::Double);
				}
			}
		}
		break;
		default:

			break;
		}
		d->fieldIndex = field + 1;
	}
	return d->fieldCache[field];
}
bool QSqlOLEDBResult::isNull(int field)
{
	if (!isActive() || field < 0 || field >= d->fieldInfo.count())
		return true;
	if (d->cmd.m_spRowset == 0)
		return true;
	DBORDINAL c = field + 1;
	d->cmd.TranslateColumnNo(c);
	DBSTATUS status;
	d->cmd.GetStatus(field + 1, &status);
	return status == DBSTATUS_S_ISNULL;
}
bool QSqlOLEDBResult::fetchNext()
{
	d->clearValues();
	HRESULT hr = d->cmd.MoveNext();
	if (FAILED(hr))
	{
		setLastError(qMakeError(getErrorString(d->cmd.m_spRowset, IID_IRowset), QSqlError::TransactionError));
		return false;
	}
	if (hr != S_OK)
	{
		setAt(QSql::AfterLastRow);
		return false;
	}
	setAt(at() + 1);
	return true;
}
bool QSqlOLEDBResult::fetchFirst()
{
	d->clearValues();
	HRESULT hr = d->cmd.MoveFirst();
	if (FAILED(hr))
	{
		setLastError(qMakeError(getErrorString(d->cmd.m_spRowset, IID_IRowset), QSqlError::TransactionError));
		return false;
	}
	if (hr != S_OK)
	{
		setAt(QSql::BeforeFirstRow);
		return false;
	}
	setAt(0);

	return true;
}
bool QSqlOLEDBResult::fetchLast()
{
	d->clearValues();
	HRESULT hr = d->cmd.MoveLast();
	if (FAILED(hr))
	{
		setLastError(qMakeError(getErrorString(d->cmd.m_spRowset, IID_IRowset), QSqlError::TransactionError));
		return false;
	}
	else if (hr == DB_S_ENDOFROWSET)
	{
		setAt(QSql::AfterLastRow);
		return false;
	}

	setAt(size() - 1);

	return true;
}
bool QSqlOLEDBResult::fetchPrevious()
{

	d->clearValues();
	HRESULT hr = d->cmd.MovePrev();
	if (FAILED(hr))
	{
		setLastError(qMakeError(getErrorString(d->cmd.m_spRowset, IID_IRowset), QSqlError::TransactionError));
		return false;
	}


	setAt(at() - 1);
	return true;
}
bool QSqlOLEDBResult::fetch(int i)
{
	if (i == at())
		return true;
	HRESULT hr = d->cmd.MoveFirst();
	if (FAILED(hr))
	{
		setLastError(qMakeError(getErrorString(d->cmd.m_spRowset, IID_IRowset), QSqlError::TransactionError));
		return false;
	}

	if (isForwardOnly()) {
		bool ok = true;
		while (ok && i > at())
			ok = fetchNext();
		return ok;
	}
	if (i != 0)
		hr = d->cmd.MoveNext(i - 1);
	if (hr != S_OK)
	{
		setLastError(qMakeError(getErrorString(d->cmd.m_spRowset, IID_IRowset), QSqlError::TransactionError));
		d->clearValues();
		return false;
	}
	if (FAILED(hr))
	{
		setLastError(qMakeError(getErrorString(d->cmd.m_spRowset, IID_IRowset), QSqlError::TransactionError));
		return false;
	}

	d->clearValues();
	setAt(i);
	return true;
}


void QSqlOLEDBResult::virtual_hook(int id, void* data)
{

}
QSqlOLEDBDriver::QSqlOLEDBDriver(QObject* parent)
	:QSqlDriver(parent)
{
	d = new QSqlOLEDBDriverPrivate;
}


QSqlOLEDBDriver::~QSqlOLEDBDriver()
{
	delete d;
}

bool QSqlOLEDBDriver::hasFeature(DriverFeature f) const
{
	if (f == NamedPlaceholders)
		return false;
	return true;
}

RealConnectResult QSqlOLEDBDriver::realConnect(const QString& db, const QString& user, const QString& password, const QString& host, const QString& dbProvider)
{
	RealConnectResult result;
	HRESULT hr = S_FALSE;
	CDBPropSet rgPropertySet[2] = { DBPROPSET_DBINIT , DBPROPSET_SQLSERVERDBINIT };
	long nTimeOut = 1;
	long generalTimeOut = 1;
	rgPropertySet[0].AddProperty(DBPROP_INIT_TIMEOUT, nTimeOut);
	rgPropertySet[0].AddProperty(DBPROP_INIT_DATASOURCE, host.utf16());
	rgPropertySet[0].AddProperty(DBPROP_INIT_GENERALTIMEOUT, generalTimeOut);
	rgPropertySet[0].AddProperty(DBPROP_INIT_CATALOG, db.utf16());
	if (dbProvider == "MSOLEDBSQL19")
	{
		rgPropertySet[1].AddProperty(SSPROP_INIT_ENCRYPT, "optional");
	}

	if (user.isEmpty())
	{
		rgPropertySet[0].AddProperty(DBPROP_AUTH_INTEGRATED, L"SSPI");
	}
	else
	{
		rgPropertySet[0].AddProperty(DBPROP_AUTH_USERID, user.utf16());
		rgPropertySet[0].AddProperty(DBPROP_AUTH_PASSWORD, password.utf16());
	}
	CDataSource dbHandle;
	hr = dbHandle.OpenWithServiceComponents(dbProvider.utf16(), &rgPropertySet[0], 2);
	result.spInit = dbHandle.m_spInit;
	result.res = hr;
	return result;
}

struct HostInfo
{
	QString host;
	int port = 0;
	static HostInfo parseAddress(const QString& fullAddress, int defaultPort)
	{
		HostInfo info;
		QStringList parts = fullAddress.trimmed().split(",");

		info.host = parts.value(0).trimmed();
		info.port = parts.value(1).isEmpty() ? defaultPort : parts.value(1).trimmed().toInt();

		return info;
	}
};

bool QSqlOLEDBDriver::open(const QString& db, const QString& user, const QString& password, const QString& host, int port, const QString& connOpts)
{
	if (isOpen())
		close();
	QStringList opts = QString(connOpts).split(QLatin1Char(';'));
	QString dbProvider;
	QString failover;
	
	foreach(const QString & option, opts)
	{
		QString opt = option.toLower().trimmed();
		if (opt.startsWith(QLatin1String("provider=")))
		{
			int index = opt.indexOf(QChar('='));
			dbProvider = opt.mid(index + 1);
		}
		else if (opt.startsWith(QLatin1String("failover partner=")))
		{
			int index = opt.indexOf(QChar('='));
			failover = opt.mid(index + 1);
		}
		else if (opt.startsWith(QLatin1String("big query=")))
		{
			d->m_isClientCursor = false;
		}
		
		else
		{
			failover = option;
		}
	}
	
	if (!connOpts.isEmpty() && opts.count() == 0 && dbProvider.isEmpty() && failover.isEmpty())
	{
		failover = connOpts;
	}

	QString defaultProvider = dbProvider;
	if (defaultProvider.isEmpty())
		defaultProvider = OLEDBManager::instance()->getProvider();
	QList<QString> connectionTarget;
	connectionTarget << host;
	QString last = OLEDBManager::instance()->getLastHost();
	if (!failover.isEmpty())
	{
		connectionTarget << failover;
		int idx = connectionTarget.indexOf(last);
		if (connectionTarget.contains(last))
		{
			connectionTarget.removeAll(last);
			connectionTarget.prepend(last);
		}
	}
	for (int i = 0; i < connectionTarget.count(); i++)
	{
		HostInfo info = HostInfo::parseAddress(connectionTarget[i], port);
		if (OLEDBManager::instance()->isConnect(info.host, info.port))
		{
			RealConnectResult result = realConnect(db, user, password, connectionTarget[i], defaultProvider);
			if (FAILED(result.res))
			{
				if (result.spInit != 0)
				{
					setLastError(qMakeError(getErrorString(result.spInit, IID_IDBInitialize), QSqlError::ConnectionError));
				}
				else
				{
					if (result.error.isValid())
						setLastError(result.error);
					else
						setLastError(qMakeError(getComErrorString(result.res), QSqlError::ConnectionError));
				}
				continue;
			}
			if (result.res == S_OK)
			{
				d->m_db.m_spInit = result.spInit;
				OLEDBManager::instance()->setLastHost(connectionTarget[i]);
				HRESULT hr = d->m_session.Open(d->m_db);
				if (hr == E_FAIL || d->m_session.m_spOpenRowset == 0)
				{
					setLastError(qMakeError(getErrorString(d->m_db.m_spInit, IID_IDBInitialize), QSqlError::ConnectionError));
					return false;
				}
				setOpen(true);
				setOpenError(false);
				return true;
			}
		}
		else
		{
			setLastError(qMakeError(QString(tr("SQL Server might be offline")), QSqlError::ConnectionError));
		}
	}

	return false;
}

void QSqlOLEDBDriver::close()
{
	if (isOpen())
	{
		try
		{
			setOpen(false);
			if (d->m_session.m_spOpenRowset)
				d->m_session.Close();
			if (d->m_db.m_spInit)
				d->m_db.Close();
			setOpenError(true);
		}
		catch (_com_error& e)
		{

			const TCHAR* str = e.ErrorMessage();

		}
	}
}

QSqlResult* QSqlOLEDBDriver::createResult() const
{
	return new QSqlOLEDBResult(this, d);
}

bool QSqlOLEDBDriver::beginTransaction()
{
	if (!isOpen() || d->m_session.m_spOpenRowset == 0)
		return false;
	CComPtr<ITransactionLocal> spTransactionLocal;
	HRESULT hr = d->m_session.m_spOpenRowset->QueryInterface(&spTransactionLocal);
	if (SUCCEEDED(hr))
		hr = spTransactionLocal->StartTransaction(ISOLATIONLEVEL_READCOMMITTED, 0, 0, 0);
	if (hr == S_OK)
		return true;
	setLastError(qMakeError(getErrorString(spTransactionLocal, IID_ITransaction), QSqlError::TransactionError));
	return false;
}

bool QSqlOLEDBDriver::commitTransaction()
{
	if (!isOpen())
		return false;
	if (d->m_session.m_spOpenRowset == 0)
		return true;
	CComPtr<ITransaction> spTransaction;
	HRESULT hr = d->m_session.m_spOpenRowset->QueryInterface(&spTransaction);
	if (SUCCEEDED(hr))
		hr = spTransaction->Commit(false, XACTTC_SYNC, 0);
	if (hr == S_OK)
		return true;
	setLastError(qMakeError(getErrorString(spTransaction, IID_ITransaction), QSqlError::TransactionError));
	return false;
}

bool QSqlOLEDBDriver::rollbackTransaction()
{
	if (!isOpen())
		return false;
	if (d->m_session.m_spOpenRowset == 0)
		return true;

	CComPtr<ITransaction> spTransaction;
	HRESULT hr = d->m_session.m_spOpenRowset->QueryInterface(&spTransaction);
	if (SUCCEEDED(hr))
		hr = spTransaction->Abort(0, 0, 0);
	if (hr == S_OK)
		return true;
	setLastError(qMakeError(getErrorString(spTransaction, IID_ITransaction), QSqlError::TransactionError));
	return false;
}

QStringList QSqlOLEDBDriver::tables(QSql::TableType tableType) const
{
	QStringList res;
	if (!isOpen())
		return res;
	QString sql;
	if (tableType & QSql::Tables)
	{
		QSqlQuery q(createResult());
		q.setForwardOnly(true);
		sql = QLatin1String("SELECT name FROM sys.tables");
		if (q.exec(sql))
			while (q.next())
				res.append(q.value(0).toString());
	}
	if (tableType & QSql::Views)
	{
		QSqlQuery q(createResult());
		q.setForwardOnly(true);
		sql = QLatin1String("SELECT name FROM sys.VIEWS");
		if (q.exec(sql))
			while (q.next())
				res.append(q.value(0).toString());
	}
	return res;
}

QSqlRecord QSqlOLEDBDriver::record(const QString& tablename) const
{
	if (!isOpen())
		return QSqlRecord();
	CTable<CDynamicParameterAccessorEx, CRowset> tb;

	d->m_currentTable = tablename;
	HRESULT hr = tb.Open(d->m_session, tablename.utf16());
	if (hr != S_OK)
		return QSqlRecord();
	QSqlRecord rec;
	for (int i = 0; i < tb.GetColumnCount(); i++)
	{
		DBTYPE type = tb.m_pColumnInfo[i].wType;
		if (tb.originDbType.count() > i)
			type = tb.originDbType[i];
		rec.append(qMakeFieldInfo(&tb.m_pColumnInfo[i], type));
	}
	return rec;

}

QSqlIndex QSqlOLEDBDriver::primaryIndex(const QString& table) const
{
	QSqlIndex index(table);
	if (!isOpen())
		return index;
	QSqlRecord rec = record(table);
	d->m_currentTable = table;
	QString query;
	QString tableName = table;
	int i = table.indexOf('.');
	if (i != -1)
		tableName = table.mid(i + 1);
	QString escapedTable = tableName;
	escapedTable.replace(QLatin1Char('\''), QLatin1String("''"));

	query = QString::fromUtf16(L"SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS K "
		L"INNER JOIN INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE AS C "
		L"ON K.CONSTRAINT_NAME = C.CONSTRAINT_NAME "
		L"WHERE K.TABLE_NAME = '%1' AND K.CONSTRAINT_TYPE = 'PRIMARY KEY'").arg(escapedTable);
	ATL::CCommand<CDynamicAccessor, CRowset> cmd;
	HRESULT hr = cmd.Open(d->m_session, query.utf16(), 0);
	if (hr == S_OK)
	{
		while (cmd.MoveNext() == S_OK)
		{
			const wchar_t* cuname = (wchar_t*)cmd.GetValue(L"COLUMN_NAME");
			if (cuname != 0)
			{
				QString columnName = QString::fromUtf16(cuname);
				index.setName(columnName);
				QSqlField field = rec.field(columnName);

				QString escapedColumn = columnName;
				escapedColumn.replace(QLatin1Char('\''), QLatin1String("''"));
				query = QString("SELECT COLUMNPROPERTY(OBJECT_ID('%1'), '%2', 'IsIdentity') AS 'IsIdentity'")
					.arg(escapedTable).arg(escapedColumn);

				ATL::CCommand<CDynamicAccessor, CRowset> cmd2;
				hr = cmd2.Open(d->m_session, query.utf16(), 0);
				if (hr == S_OK)
				{
					if (cmd2.MoveNext() == S_OK)
					{
						int* isOK = (int*)cmd2.GetValue(1);
						DBSTATUS status;
						cmd2.GetStatus(1, &status);
						if (status == DBSTATUS_S_OK && isOK)
							field.setAutoValue(*isOK);
					}
				}
				cmd2.Close();
				index.append(field);
			}
		}
	}
	d->primaryIndex = index;
	return index;
}

QVariant QSqlOLEDBDriver::handle() const
{
	return QVariant();
}

QString QSqlOLEDBDriver::escapeIdentifier(const QString& identifier, IdentifierType) const
{
	QString res = identifier;
	if (!identifier.isEmpty() && identifier.left(1) != QString(QLatin1Char('"')) && identifier.right(1) != QString(QLatin1Char('"'))) {
		res.replace(QLatin1Char('"'), QLatin1String("\"\""));
		res.prepend(QLatin1Char('"')).append(QLatin1Char('"'));
		res.replace(QLatin1Char('.'), QLatin1String("\".\""));
	}
	return res;
}

static QString mssqlQuoteString(const QString& input, bool trim)
{
	QString s = input;
	if (trim)
		s = s.trimmed();
	s.replace(QLatin1Char('\''), QLatin1String("''"));
	return QStringLiteral("N'") + s + QLatin1Char('\'');
}

QString QSqlOLEDBDriver::formatValue(const QSqlField& field, bool trimStrings) const
{
	if (field.isNull())
		return QStringLiteral("NULL");

	switch (field.type())
	{
	case QVariant::String:
		return mssqlQuoteString(field.value().toString(), trimStrings);

	case QVariant::Bool:
		return field.value().toBool() ? QStringLiteral("1") : QStringLiteral("0");

	case QVariant::Int:
	case QVariant::UInt:
	{
		if (field.value().type() == QVariant::Bool)
			return field.value().toBool() ? QStringLiteral("1") : QStringLiteral("0");
		QString s = field.value().toString();
		return s.isEmpty() ? QStringLiteral("NULL") : s;
	}

	case QVariant::ByteArray:
	{
		QByteArray ba = field.value().toByteArray();
		if (ba.isEmpty())
			return QStringLiteral("0x");
		return QStringLiteral("0x") + QString::fromLatin1(ba.toHex());
	}

	case QVariant::DateTime:
	{
		QDateTime dt = field.value().toDateTime();
		if (dt.isValid())
			return QLatin1Char('\'') + dt.toString(QStringLiteral("yyyy-MM-dd hh:mm:ss.zzz")) + QLatin1Char('\'');
		return QStringLiteral("NULL");
	}

	case QVariant::Date:
	{
		QDate d = field.value().toDate();
		if (d.isValid())
			return QLatin1Char('\'') + d.toString(Qt::ISODate) + QLatin1Char('\'');
		return QStringLiteral("NULL");
	}

	case QVariant::Time:
	{
		QTime t = field.value().toTime();
		if (t.isValid())
			return QLatin1Char('\'') + t.toString(QStringLiteral("hh:mm:ss.zzz")) + QLatin1Char('\'');
		return QStringLiteral("NULL");
	}

	default:
		return QSqlDriver::formatValue(field, trimStrings);
	}
}