www.pudn.com > QTADO_src.zip > QryToolConnectionEvents.cpp

// QryToolConnectionEvents.cpp: implementation of the CQryToolConnectionEvents class. 
// 
 
#include "stdafx.h" 
#include "QryToolConnectionEvents.h" 
#include "MainFrm.h" 
 
#ifdef _DEBUG 
#undef THIS_FILE 
static char THIS_FILE[]=__FILE__; 
#define new DEBUG_NEW 
#endif 
 
long CQryToolConnectionEvents::m_lRow = 0; 
////////////////////////////////////////////////////////////////////// 
// CQryToolConnectionEvents 
 
CQryToolConnectionEvents::CQryToolConnectionEvents(CChildFrame* pChildFrame) 
{ 
	m_pChildFrame = pChildFrame; 
} 
 
CQryToolConnectionEvents::~CQryToolConnectionEvents() 
{ 
	m_pChildFrame = NULL; 
} 
 
STDMETHODIMP CQryToolConnectionEvents::ExecuteComplete(  
	LONG RecordsAffected, 
	ADOError* pError, 
	EventStatusEnum* adStatus, 
	_ADOCommand* pCommand, 
	_ADORecordset* pRecordset, 
	_ADOConnection* pConnection) 
{ 
	OutputDebugString(_T("ExecuteComplete event fired.\n")); 
 
	UNUSED_ALWAYS(adStatus); 
	UNUSED_ALWAYS(pError); 
	UNUSED_ALWAYS(pCommand); 
	UNUSED_ALWAYS(pConnection); 
	 
	HRESULT hr = S_OK; 
 
	if(m_pChildFrame != NULL &&  
		AfxIsValidAddress(m_pChildFrame, sizeof(m_pChildFrame)) != NULL && 
		!m_pChildFrame->m_strSQL.IsEmpty() && !m_pChildFrame->m_bCanceled && 
		m_pChildFrame->m_bExecuting) 
	{ 
		m_pChildFrame->m_ThreadParam.m_strSQL = m_pChildFrame->m_strSQL; 
		m_pChildFrame->m_strSQL.Empty(); 
		m_pChildFrame->m_ThreadParam.m_pFrame = m_pChildFrame; 
		ASSERT(m_pChildFrame != NULL); 
		m_pChildFrame->m_ThreadParam.m_ptrRS = pRecordset; 
		if(m_pChildFrame->m_bProcText) 
		{ 
			m_pChildFrame->m_pThreadExecuteSQL = AfxBeginThread( 
				ExecuteSQLProcProc, &m_pChildFrame->m_ThreadParam, 
				m_pChildFrame->m_nThreadPriority 
				); 
		} 
		else 
		{ 
			m_pChildFrame->m_ThreadParam.m_pGridCtrl = NULL; 
			m_pChildFrame->m_ThreadParam.m_ptrGridCtrl = NULL; 
			m_pChildFrame->m_ThreadParam.m_vRowsAffected = RecordsAffected; 
			m_pChildFrame->m_pThreadExecuteSQL = AfxBeginThread( 
				ExecuteSQLProc, &m_pChildFrame->m_ThreadParam, 
				m_pChildFrame->m_nThreadPriority 
				); 
		} 
 
		ASSERT(m_pChildFrame->m_pThreadExecuteSQL != NULL); 
		m_pChildFrame->m_pThreadExecuteSQL->m_pMainWnd = m_pChildFrame; 
	} 
 
	return hr; 
} 
 
UINT ExecuteSQLProc(LPVOID lpVoid) 
{ 
	ThreadParam* pTP = (ThreadParam*)lpVoid; 
	CChildFrame* pChildFrame = pTP->m_pFrame; 
	ASSERT(pChildFrame != NULL); 
	ASSERT(pTP != NULL); 
	ASSERT(!pTP->m_strSQL.IsEmpty()); 
	HRESULT hr = S_OK; 
	bool bCaughtException = false; 
	try 
	{ 
		hr = CQryToolConnectionEvents::PopulateGrid(pTP); 
		if(FAILED(hr)) 
			_com_issue_error(hr); 
	} 
	catch(const _com_error& e) 
	{ 
		if(!pChildFrame->m_bCanceled) 
		{ 
			bCaughtException = true; 
 
			if(pChildFrame->m_strMessages.length()) 
				pChildFrame->m_strMessages += _T("\n\n"); 
			CString sBuff = pChildFrame->GetProviderError(); 
			if(!sBuff.IsEmpty()) 
				pChildFrame->m_strMessages += sBuff; 
			else 
				pChildFrame->m_strMessages += pChildFrame->GetComError(e); 
		} 
	} 
	catch(CMemoryException* e) 
	{ 
		if(!pChildFrame->m_bCanceled) 
		{ 
			bCaughtException = true; 
 
			if(pChildFrame->m_strMessages.length()) 
				pChildFrame->m_strMessages += _T("\n\n"); 
			pChildFrame->m_strMessages += _T("Out-of-Memory."); 
		} 
 
		if(e) 
			e->Delete(); 
	} 
	catch(COleException* e) 
	{ 
		if(!pChildFrame->m_bCanceled) 
		{ 
			bCaughtException = true; 
 
			if(e) 
			{ 
				TCHAR szMsg[255]; 
				e->GetErrorMessage(szMsg, 255); 
				 
				if(pChildFrame->m_strMessages.length()) 
					pChildFrame->m_strMessages += _T("\n\n"); 
				pChildFrame->m_strMessages += szMsg; 
			} 
		} 
 
		if(e) 
			e->Delete(); 
	} 
	catch(COleDispatchException* e) 
	{ 
		if(!pChildFrame->m_bCanceled) 
		{ 
			bCaughtException = true; 
 
			if(e) 
			{ 
				if(pChildFrame->m_strMessages.length()) 
					pChildFrame->m_strMessages += _T("\n\n"); 
				pChildFrame->m_strMessages += e->m_strDescription; 
			} 
		} 
 
		if(e) 
			e->Delete(); 
	} 
	catch(LPCTSTR e) 
	{ 
		if(!pChildFrame->m_bCanceled) 
		{ 
			bCaughtException = true; 
		 
			if(pChildFrame->m_strMessages.length()) 
				pChildFrame->m_strMessages += _T("\n\n"); 
			pChildFrame->m_strMessages += e; 
		} 
	} 
	catch(...) 
	{ 
		if(!pChildFrame->m_bCanceled) 
		{ 
			bCaughtException = true; 
 
			if(pChildFrame->m_strMessages.length()) 
				pChildFrame->m_strMessages += _T("\n\n"); 
			pChildFrame->m_strMessages += _T("Errors occurred."); 
		} 
	} 
 
	try 
	{ 
		if(pChildFrame->m_bIsTSQLSupported && !pChildFrame->m_bCanceled) 
		{ 
			pChildFrame->m_strSQL.Empty(); 
			if(pTP->m_strSQL.FindNoCase(_T("USE ")) != -1) 
			{ 
				if(!pChildFrame->SelectDataBaseEx()) 
					TRACE(_T("Error selecting database context.\n")); 
			} 
		} 
 
		if(pChildFrame->m_bCanceled) 
		{ 
			if(CQryToolConnectionEvents::m_lRow > 1) 
				CQryToolConnectionEvents::m_lRow = --CQryToolConnectionEvents::m_lRow; 
			if(pTP->m_pGridCtrl != NULL) 
				::SendMessage( 
					pChildFrame->m_hWnd, WM_SET_GRID_ROWS, 
					CQryToolConnectionEvents::m_lRow, pChildFrame->m_bCanceled 
					); 
		} 
 
		if(pTP->m_ptrGridCtrl != NULL) 
		{ 
			pTP->m_ptrGridCtrl.Release(); 
			pTP->m_ptrGridCtrl = NULL; 
		} 
	} 
	catch(...) 
	{ 
		TRACE(_T("Errors occurred.\n")); 
	} 
 
	try 
	{ 
		::PostMessage( 
			pChildFrame->m_hWnd, WM_EXECUTION_COMPLETE, bCaughtException, -1 
			); 
	} 
	catch(...) 
	{ 
		TRACE(_T("Errors occurred.\n")); 
	} 
 
	return 0; 
} 
 
HRESULT CQryToolConnectionEvents::PopulateGrid(ThreadParam* pTP) 
{ 
	CChildFrame* pChildFrame = pTP->m_pFrame; 
	ASSERT(pChildFrame != NULL); 
	ADODB::_RecordsetPtr ptrRS = pTP->m_ptrRS; 
	long lState = ADODB::adStateClosed; 
	long nTotalCols = 0; 
	long nCols = 0; 
	long lRow = 0; 
	long lType = ADODB::adEmpty; 
	ADODB::FieldsPtr ptrFields = NULL; 
	ADODB::FieldPtr ptrField = NULL; 
	long lMaxRows =  700; 
	_variant_t vCol((long)-1); 
	_variant_t vRowsAffected = pTP->m_vRowsAffected; 
	_bstr_t bstrBuff; 
	CString sBuff; 
	HRESULT hr = S_OK; 
	do 
	{ 
		hr = ptrRS->get_State(&lState); 
		if(FAILED(hr)) 
			_com_issue_error(hr); 
		if(lState == ADODB::adStateClosed) 
		{ 
			if((long)vRowsAffected != -1 && !pChildFrame->m_bExecuteCompleteHandled) 
			{ 
				sBuff.Format(_T("(%d row(s) affected)"), (long)vRowsAffected); 
				if(pChildFrame->m_strMessages.length()) 
					pChildFrame->m_strMessages += _T("\n\n"); 
				pChildFrame->m_strMessages += sBuff; 
			} 
		} 
		else if(lState == ADODB::adStateOpen && 
			lState != ADODB::adStateClosed) 
		{ 
			ptrFields = ptrRS->Fields; 
			nCols = ptrFields->Count;  
			lRow = 0; 
			if(!pChildFrame->m_bCanceled && nCols) 
			{ 
				nTotalCols += nCols; 
				if(::SendMessage(pChildFrame->m_hWnd, WM_GET_GRID_CTRL, 
					nCols, 0L) == -1) 
					throw _T("Failed to create grid control."); 
				if(!pChildFrame->m_bCanceled) 
					CQryToolConnectionEvents::SetGridHeaderInfo( 
						pTP->m_ptrGridCtrl, ptrFields, nCols 
						); 
				if(!pChildFrame->m_bCanceled && ptrRS->State == ADODB::adStateOpen && 
					!ptrRS->adoBOF) 
				{ 
					if(::SendMessage(pChildFrame->m_hWnd, WM_SET_GRID_ROWS, 
						lMaxRows, 0L) == -1) 
						throw _T("Unable to Allocate Memory for FlexGrid."); 
					 
					if(pChildFrame->m_bCanceled) 
						CQryToolConnectionEvents::m_lRow = lRow+1; 
					 
					while(!pChildFrame->m_bCanceled && !ptrRS->adoEOF) 
					{ 
						if(lRow >= lMaxRows-1) 
						{ 
							lMaxRows += 700; 
							if(!pChildFrame->m_bCanceled) 
								if(::SendMessage(pChildFrame->m_hWnd, WM_SET_GRID_ROWS, 
									lMaxRows, 0L) == -1) 
									throw _T("Unable to Allocate Memory for FlexGrid."); 
							 
							pTP->m_pGridCtrl->Invalidate(); 
							pTP->m_pGridCtrl->UpdateWindow(); 
						} 
 
						++lRow; 
						for(long n = 0; n < nCols; n++) 
						{ 
							try 
							{ 
								if(!pChildFrame->m_bCanceled) 
								{ 
									hr = ptrFields->get_Item((vCol = n), &ptrField); 
									if(FAILED(hr)) 
									{ 
										if(::SendMessage(pChildFrame->m_hWnd, WM_SET_GRID_ROWS, 
											lRow+1, 0L) == -1) 
											TRACE(_T("Unable to Allocate Memory for FlexGrid.\n")); 
										_com_issue_error(hr); 
									} 
									lType = ptrField->Type; 
									if(lType == ADODB::adLongVarBinary || 
									   lType == ADODB::adVarBinary || 
									   lType == ADODB::adBinary) 
									   bstrBuff = L"/"; 
									else 
										bstrBuff = (_bstr_t)ptrField->Value; 
								} 
							} 
							catch(...) 
							{ 
								// If we get here, probably it is because of 
								// type mismatch 
								if(!pChildFrame->m_bCanceled) 
								{ 
									VARIANT _result; 
									VariantInit(&_result); 
									hr = ptrField->get_Value(&_result); 
									if(FAILED(hr)) 
									{ 
										if(::SendMessage(pChildFrame->m_hWnd, WM_SET_GRID_ROWS, 
											lRow+1, 0L) == -1) 
											TRACE(_T("Unable to Allocate Memory for FlexGrid\n")); 
										_com_issue_error(hr); 
									} 
									bstrBuff = (LPCTSTR)CHelpers::CrackStrVariant(_result); 
								} 
							} 
							 
							hr = pTP->m_ptrGridCtrl->put_TextMatrix(lRow, n, bstrBuff); 
							if(FAILED(hr)) 
							{ 
								if(::SendMessage(pChildFrame->m_hWnd, WM_SET_GRID_ROWS, 
									lRow+1, 0L) == -1) 
									TRACE(_T("Unable to Allocate Memory for FlexGrid\n")); 
								throw _T("Subscript out of range."); 
							} 
						} 
 
						if(!pChildFrame->m_bCanceled) 
						{ 
							hr = ptrRS->raw_MoveNext(); 
							if(FAILED(hr)) 
							{ 
								if(::SendMessage(pChildFrame->m_hWnd, WM_SET_GRID_ROWS, 
									lRow+1, 0L) == -1) 
									TRACE(_T("Unable to Allocate Memory for FlexGrid\n")); 
								if(!pChildFrame->m_bCanceled && !pChildFrame->m_bExecuteCompleteHandled) 
								{ 
									sBuff.Format( 
										_T("[%d row(s) affected (application specific)]"), 
										lRow 
										); 
									if(pChildFrame->m_strMessages.length()) 
										pChildFrame->m_strMessages += _T("\n\n"); 
									pChildFrame->m_strMessages += sBuff; 
								} 
								_com_issue_error(hr); 
							} 
						} 
					} 
 
					if(::SendMessage(pChildFrame->m_hWnd, WM_SET_GRID_ROWS, 
						lRow+1, 0L) == -1) 
						throw _T("Unable to Allocate Memory for FlexGrid."); 
				} 
 
				if(pChildFrame->m_bCanceled) 
					CQryToolConnectionEvents::m_lRow = lRow+1; 
				else 
				{ 
					if(!pChildFrame->m_bExecuteCompleteHandled) 
					{ 
						sBuff.Format( 
							_T("[%d row(s) affected (application specific)]"), 
							lRow 
							); 
						if(pChildFrame->m_strMessages.length()) 
							pChildFrame->m_strMessages += _T("\n\n"); 
						pChildFrame->m_strMessages += sBuff; 
					} 
				} 
			} 
		} 
 
		if(!pChildFrame->m_bIsMultiSetSupported) 
			break; 
	} 
	while(!pChildFrame->m_bCanceled && 
		(ptrRS = ptrRS->NextRecordset(&vRowsAffected)) != NULL); 
	 
	pChildFrame->CloseRecordset(); 
 
	return hr; 
} 
 
void CQryToolConnectionEvents::SetGridHeaderInfo(const MSFlexGridLib::IMSFlexGridPtr& 
	ptrGridCtrl, const ADODB::FieldsPtr& ptrFields, const long& lCols) 
{ 
	if(lCols) 
	{ 
		ASSERT(ptrGridCtrl != NULL); 
		ASSERT(ptrFields != NULL); 
		long lColWidth = 0L; 
		long nDefinedSize = 0L; 
		long lFieldNameLength = 0L; 
		int nArbitraryFactor = 110; 
		long nMaxWidth = 50; 
		ADODB::FieldPtr ptrField = NULL; 
		long lType = ADODB::adEmpty; 
		_variant_t vCol((long)-1); 
		for(long n = 0; n < lCols; n++) 
		{ 
			HRESULT hr = ptrFields->get_Item((vCol = n), &ptrField); 
			if(FAILED(hr)) 
				_com_issue_error(hr); 
 
			nDefinedSize = ptrField->DefinedSize; 
			lFieldNameLength = ptrField->Name.length(); 
			lType = ptrField->Type; 
			if(lType == ADODB::adLongVarBinary || 
				lType == ADODB::adVarBinary || 
				lType == ADODB::adBinary) 
			{ 
				if(8 < lFieldNameLength) 
					lColWidth = lFieldNameLength; 
				else 
					lColWidth = 8; 
			} 
			else 
			{ 
				if(nDefinedSize < lFieldNameLength) 
					lColWidth = lFieldNameLength; 
				else if(nDefinedSize > nMaxWidth) 
					lColWidth = nMaxWidth; 
				else 
					lColWidth = nDefinedSize; 
			} 
 
			hr = ptrGridCtrl->put_ColAlignment(n, MSFlexGridLib::flexAlignLeftCenter); 
			if(FAILED(hr)) 
				_com_issue_error(hr); 
			hr = ptrGridCtrl->put_ColWidth(n, (lColWidth+5)*nArbitraryFactor); 
			if(FAILED(hr)) 
				_com_issue_error(hr); 
			hr = ptrGridCtrl->put_TextMatrix(0, n, ptrField->Name); 
			if(FAILED(hr)) 
				_com_issue_error(hr); 
		} 
	} 
} 
 
UINT ExecuteSQLProcProc(LPVOID lpVoid) 
{ 
	ThreadParam* pTP = (ThreadParam*)lpVoid; 
	ASSERT(pTP != NULL); 
	CChildFrame* pChildFrame = pTP->m_pFrame; 
	ASSERT(pChildFrame != NULL); 
	HRESULT hr = S_OK; 
	bool bCaughtException = false; 
	ADODB::_RecordsetPtr ptrRS = pTP->m_ptrRS; 
	CString sMsg; 
	try 
	{ 
		long lState = ADODB::adStateClosed; 
		hr = ptrRS->get_State(&lState); 
		if(FAILED(hr)) 
			_com_issue_error(hr); 
		if(lState != ADODB::adStateClosed) 
		{ 
			while(!pChildFrame->m_bCanceled && ptrRS != NULL && !ptrRS->adoBOF) 
			{ 
				while(!pChildFrame->m_bCanceled && !ptrRS->adoEOF) 
				{ 
					if(!pChildFrame->m_bCanceled) 
						pChildFrame->m_strProcText += (LPCTSTR)(_bstr_t)ptrRS->Fields-> 
							GetItem(_variant_t((long)0))->Value; 
 
					if(!pChildFrame->m_bCanceled) 
						ptrRS->MoveNext(); 
				} 
 
				if(!pChildFrame->m_bCanceled) 
					pChildFrame->m_strProcText += _T("\n\n"); 
 
				if(!pChildFrame->m_bCanceled && pChildFrame->m_bIsMultiSetSupported) 
					ptrRS = ptrRS->NextRecordset(NULL); 
			} 
 
			if(!pChildFrame->m_bCanceled && !pChildFrame->m_strProcText.length()) 
				pChildFrame->m_strProcText = _T("NULL"); 
		} 
	} 
	catch(const _com_error& e) 
	{ 
		if(!pChildFrame->m_bCanceled) 
		{ 
			bCaughtException = true; 
 
			if(pChildFrame->m_strMessages.length()) 
				pChildFrame->m_strMessages += _T("\n\n"); 
			CString sBuff = pChildFrame->GetProviderError(); 
			if(!sBuff.IsEmpty()) 
				pChildFrame->m_strMessages += sBuff; 
			else 
				pChildFrame->m_strMessages += pChildFrame->GetComError(e); 
		} 
	} 
	catch(CMemoryException* e) 
	{ 
		if(!pChildFrame->m_bCanceled) 
		{ 
			bCaughtException = true; 
 
			if(pChildFrame->m_strMessages.length()) 
				pChildFrame->m_strMessages += _T("\n\n"); 
			pChildFrame->m_strMessages += _T("Out-of-Memory."); 
		} 
 
		if(e) 
			e->Delete(); 
	} 
	catch(...) 
	{ 
		if(!pChildFrame->m_bCanceled) 
		{ 
			bCaughtException = true; 
 
			if(pChildFrame->m_strMessages.length()) 
				pChildFrame->m_strMessages += _T("\n\n"); 
			pChildFrame->m_strMessages += _T("Errors occurred."); 
		} 
	} 
 
	pChildFrame->CloseRecordset(); 
	 
	try 
	{ 
		if(pChildFrame->m_bIsTSQLSupported && !pChildFrame->m_bCanceled) 
		{ 
			pChildFrame->m_strSQL.Empty(); 
			if(pTP->m_strSQL.FindNoCase(_T("USE ")) != -1) 
			{ 
				if(!pChildFrame->SelectDataBaseEx()) 
					TRACE(_T("Error selecting database context.\n")); 
			} 
		} 
	} 
	catch(...) 
	{ 
		TRACE(_T("Errors occurred.\n")); 
	} 
 
	try 
	{ 
		::PostMessage( 
			pChildFrame->m_hWnd, WM_EXEC_PROC_COMPLETE, bCaughtException, 0L 
			); 
	} 
	catch(...) 
	{ 
		TRACE(_T("Errors occurred.\n")); 
	} 
 
	return 0; 
}