childfrm.cpp

Interactive SQL Tool

{
	pCmdUI->Enable(m_nIndex > 0 && m_nIndex < m_nGridCount);
}

void CChildFrame::OnUpdateViewFirstResultSet(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(m_nIndex > 1);
}

void CChildFrame::OnUpdateViewLastResultSet(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(m_nIndex > 0 && m_nIndex < m_nGridCount);
}

void CChildFrame::DisplayResults(CMSFlexGrid* pGridCtrl, const int& nCurrentSet)
{
	m_pResultView->GetRichEditCtrl().SetWindowText(NULL);

	if(m_nGridCount > 1)
		HideResultSets();
	
	if(GetFocus() == m_pResultView)
	{
		pGridCtrl->SetFocus();
		m_pResultView->SetRedraw(TRUE);
	}
	CRect rect;
	m_pResultView->GetWindowRect(&rect);
	m_pResultView->m_pGridCtrl = pGridCtrl;
	pGridCtrl->MoveWindow(0, 0, rect.Width(), rect.Height());
	pGridCtrl->ShowWindow(SW_SHOW);
	pGridCtrl->Invalidate();
	pGridCtrl->UpdateWindow();
	m_pResultView->Invalidate();
	m_pResultView->UpdateWindow();
	m_strStatusText.Format(_T("Results grid #%d of %d; %d row(s); %d col(s)"),
		nCurrentSet, m_nGridCount, pGridCtrl->GetRows()-1, pGridCtrl->GetCols());
	m_wndStatusBar.SetPaneText(m_nResultSetPaneNo, m_strStatusText);
}

void CChildFrame::HideResultSets()
{
	for(int n = 0; n < m_nGridCount; n++)
	{
		POSITION pos = m_GridList.FindIndex(n);
		if(pos != NULL)
		{
			CMSFlexGrid* pGrid = (CMSFlexGrid*)m_GridList.GetAt(pos);
			if(pGrid != NULL)
				pGrid->ShowWindow(SW_HIDE);
		}
	}
}

void CChildFrame::OnUpdateSqlObjects(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(m_lConnectionState == ADODB::adStateOpen && !m_bExecuting);
}

void CChildFrame::OnUpdateSqlExecute(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(m_lConnectionState == ADODB::adStateOpen && m_pQryView != NULL
		&& m_pQryView->GetRichEditCtrl().GetTextLength() && !m_bExecuting);
}

UINT CancelSQLProc(LPVOID lpVoid)
{
	TCP* pTCP = (TCP*)lpVoid;
	ASSERT(pTCP != NULL);
	CChildFrame* pFrame = pTCP->m_pFrame;
	ASSERT(pFrame != NULL);
	try
	{
		if(pFrame->m_ptrRecordset != NULL)
		{
			if(pFrame->m_bSupports_adAsyncExecute)
			{
				if(pFrame->m_ptrRecordset->State == ADODB::adStateExecuting ||
					pFrame->m_ptrRecordset->State == ADODB::adStateExecuting+ADODB::adStateOpen ||
					pFrame->m_ptrRecordset->State == ADODB::adStateOpen ||
					pFrame->m_ptrRecordset->State == ADODB::adStateFetching)
				{
					HRESULT hr = pFrame->m_ptrRecordset->Cancel();
					if(FAILED(hr))
						_com_issue_error(hr);
				}
			}
		}
	}
	catch(const _com_error& e)
	{
		CString sMsg = pFrame->GetProviderError();
		if(!sMsg.IsEmpty())
			sMsg = pFrame->GetComError(e);

		TRACE(_T("%s\n"), (LPCTSTR)sMsg);
	}
	catch(...)
	{
		TRACE(_T("Errors occurred on <Cancel>.\n"));
	}

	pFrame->m_bCanceled = TRUE;

	if(::IsWindow(pFrame->m_hWnd))
		::PostMessage(pFrame->m_hWnd, WM_CANCEL_COMPLETE, 0L, 0L);

	return 0L;
}

LONG CChildFrame::OnCancelComplete(UINT wParam, LONG lParam)
{
	UNUSED_ALWAYS(wParam);
	UNUSED_ALWAYS(lParam);

	if(::IsWindow(m_hWnd))
	{
		if(!m_strSQL.IsEmpty())
		{
			if(m_bProcText)
				OnExecProcComplete(0, -1);
			else
				OnExecutionComplete(0, -1);
		}

		CloseAfterCancelIfNecessary();
	}
		
	return 0L;
}

void CChildFrame::CloseAfterCancelIfNecessary()
{
	if(m_bCloseMainFrameAfterCancel)
	{
		m_bCloseMainFrameAfterCancel = FALSE;
		CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
		if(pFrame != NULL)
			pFrame->SendMessage(WM_CLOSE);
	}
	else if(m_bDisconnectAllAfterCancel)
	{
		m_bDisconnectAllAfterCancel = FALSE;
		CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
		if(pFrame != NULL)
			pFrame->OnFileDisconnectAll();
	}
	else if(m_bCloseAfterCancel)
	{
		m_bCloseAfterCancel = FALSE;
		SendMessage(WM_CLOSE);
	}
}

void CChildFrame::CancelQuery()
{
	if(!m_bExecuting)
		CloseAfterCancelIfNecessary();
	else if(!m_bCanceling && !m_bExecuteCompleteHandled)
	{
		m_bCanceling = TRUE;
		m_strPaneTextZero = _T("Attempting to cancel query batch...");
		m_wndStatusBar.SetPaneText(0, m_strPaneTextZero);
		m_TCP.m_pFrame = this;
		m_pThreadCancelSQL = AfxBeginThread(CancelSQLProc, &m_TCP);
		ASSERT(m_pThreadCancelSQL != NULL);
		m_pThreadCancelSQL->m_pMainWnd = this;
	}
}

void CChildFrame::OnSqlCancel() 
{
	m_bCloseAfterCancel = FALSE;
	CancelQuery();
}

void CChildFrame::OnUpdateSqlCancel(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(m_lConnectionState == ADODB::adStateOpen && m_bExecuting
		&& !m_bCanceling);
}

void CChildFrame::OnUpdateCombo(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(m_lConnectionState == ADODB::adStateOpen && 
		m_bIsTSQLSupported && !m_bExecuting);
}

BOOL CChildFrame::SelectDatabase()
{
	BOOL bRet = TRUE;
	
	try
	{
		ADODB::PropertiesPtr ptrProperties = m_ptrConnection->GetProperties();
		HRESULT hr = ptrProperties->Refresh();
		if(FAILED(hr))
			_com_issue_error(hr);
		ADODB::PropertyPtr ptrProperty = ptrProperties->GetItem("Current Catalog");
		_bstr_t bstrDBName = (_bstr_t)ptrProperty->GetValue();
		m_ptrConnection->DefaultDatabase = bstrDBName;
		m_comboBox.SelectString(-1, (m_strDBName = (LPCTSTR)bstrDBName));
	}
	catch(const _com_error& e)
	{
		CString sMsg = GetProviderError();
		if(!sMsg.IsEmpty())
			TRACE(_T("%s\n"), (LPCTSTR)sMsg);
		else
		{
			sMsg = GetComError(e);
			TRACE(_T("%s\n"), (LPCTSTR)sMsg);
		}

		bRet = FALSE;
	}

	return bRet;
}

void CChildFrame::SetExecutionTime()
{
	DWORD dwDiff = ::GetTickCount() - m_dwStart;
	COleDateTimeSpan span(0, 0, 0, dwDiff/1000);
	CString sBuff;
	sBuff.Format(_T("Exec time: %02d:%02d:%02d"),
			span.GetHours(), span.GetMinutes(), span.GetSeconds());
	m_strExecutionTime = sBuff;
	m_wndStatusBar.SetPaneText(1, m_strExecutionTime);
}

bool CChildFrame::SetProperties(LPCTSTR lpszInitialCatalog)
{
	bool bRet = true;

	try
	{
		ADODB::PropertyPtr ptrProperty = NULL;
		ADODB::PropertiesPtr ptrProperties = m_ptrConnection->GetProperties();
		HRESULT hr = ptrProperties->Refresh();
		if(FAILED(hr))
			_com_issue_error(hr);
		
		try
		{
			ptrProperty = ptrProperties->GetItem("Provider Name");
			m_strProviderName = (LPCTSTR)(_bstr_t)ptrProperty->GetValue();
		}
		catch(...)
		{
		}

		try
		{
			ptrProperty = ptrProperties->GetItem("Data Source");
			m_strDataSource = (LPCTSTR)(_bstr_t)ptrProperty->GetValue();
		}
		catch(...)
		{
		}
		
		try
		{
			if(m_strDataSource.IsEmpty())
			{
				ptrProperty = ptrProperties->GetItem("Current Catalog");
				m_strDataSource = (LPCTSTR)(_bstr_t)ptrProperty->GetValue();
			}
		}
		catch(...)
		{
		}

		try
		{
			ptrProperty = ptrProperties->GetItem("Multiple Results");
			m_bIsMultiSetSupported = (bool)ptrProperty->GetValue();
		}
		catch(...)
		{
		}
				
		try
		{
			ptrProperty = ptrProperties->GetItem("DBMS Name");
			m_strDBMS = CHelpers::CrackStrVariant(ptrProperty->GetValue());
		}
		catch(...)
		{
		}

		m_bIsJetDriver = !m_strDBMS.CompareNoCase(g_szMSJet);
		try
		{
			if(!m_strProviderName.CompareNoCase(g_szMSOLEDBProviderForODBCDrivers))
			{
				ptrProperty = ptrProperties->GetItem("Driver Name");
				CString sDriverName = (LPCTSTR)(_bstr_t)ptrProperty->GetValue();
				if(!sDriverName.CompareNoCase(g_szODBCJTDriver))
					m_bIsJetDriver = TRUE;
			}
		}
		catch(...)
		{
		}

		if(m_bIsJetDriver || !m_strProviderName.CompareNoCase(g_szMSADIPP) ||
			!m_strProviderName.CompareNoCase(g_szMSOLEDBProForIP))
			m_bSupports_adAsyncExecute = FALSE;
		
		m_bIsTSQLSupported = (!m_strDBMS.CompareNoCase(g_szSQLAnyWhere) ||
			!m_strDBMS.CompareNoCase(g_szASAnyWhere) ||
			!m_strDBMS.CompareNoCase(g_szSybaseOpenServer) ||
			!m_strDBMS.CompareNoCase(g_szMicrosoftSQLServer) ||
			!m_strDBMS.CompareNoCase(g_szMSSQLServer));
		if(m_bIsTSQLSupported)
		{
			CString sInitialCatalog = lpszInitialCatalog; 
			if(sInitialCatalog.CompareNoCase(g_szNoData) != 0 &&
				lpszInitialCatalog != NULL)
				if(!PutInitialCatalog(lpszInitialCatalog))
					TRACE(_T("Error putting initial catalog.\n"));
			if(!FillCombo())
				TRACE(_T("Error filling combo.\n"));
		}
		else
		{
			m_comboBox.AddString(_T("<Not supported>"));
			m_comboBox.SetCurSel(0);
		}
	}
	catch(const _com_error& e)
	{
		bRet = false;

		CString sMsg = GetProviderError();
		if(sMsg.IsEmpty())
			sMsg = GetComError(e);

		TRACE(_T("%s\n"), (LPCTSTR)sMsg);
	}

	return bRet;
}

void CChildFrame::OnDumpProviderPropertiesEx() 
{
	CDumpProviderProperties dlg;
	dlg.DoModal();
}

void CChildFrame::OnUpdateDumpProviderPropertiesEx(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(m_lConnectionState == ADODB::adStateOpen && !m_bExecuting);
}

CString CChildFrame::GetProviderError()
{
	CString sErrors;
	if(m_ptrConnection != NULL)
	{
		ADODB::ErrorsPtr ptrErrors = m_ptrConnection->Errors;
		long lCount = ptrErrors->Count;
		ADODB::ErrorPtr ptrError = NULL;
		CString sError;
		for(long n = 0; n < lCount; n++)
		{
			ptrError = ptrErrors->GetItem(n);
			sError.Format(
				_T("%s\nState: %s, Native: %d, Source: %s"),
				(LPCTSTR)ptrError->Description,
				(LPCTSTR)ptrError->SQLState,
				ptrError->NativeError,
				(LPCTSTR)ptrError->Source
				);
			sErrors += sError + "\n\n";
		}
	}

	if(!sErrors.IsEmpty())
		sErrors = sErrors.Left(sErrors.GetLength()-2);

	return sErrors;
}

CString CChildFrame::GetComError(const _com_error& e)
{
	CString sMsg;
	sMsg.Format(
		_T("HRESULT: 0x%08lx; Error: %s"),
		e.Error(),
		e.ErrorMessage()
		);
	
	if(e.ErrorInfo())
	{
		sMsg += "\nSource: " + CString((LPCTSTR)e.Source()) +
			"; Description: " + CString((LPCTSTR)e.Description());
	}

	return sMsg;
}

void CChildFrame::OnUpdateFileMruFile1(CCmdUI* pCmdUI) 
{
	theApp.OnUpdateFileMruFile1(pCmdUI);
}

int CChildFrame::GetThreadPriority(const CString& sPriority)
{
	int nThreadPriority = THREAD_PRIORITY_LOWEST;
	if(!sPriority.CompareNoCase(g_szTimeCritical))
		nThreadPriority = THREAD_PRIORITY_TIME_CRITICAL;
	else if(!sPriority.CompareNoCase(g_szHighest))
		nThreadPriority = THREAD_PRIORITY_HIGHEST;
	else if(!sPriority.CompareNoCase(g_szAboveNormal))
		nThreadPriority = THREAD_PRIORITY_ABOVE_NORMAL;
	else if(!sPriority.CompareNoCase(g_szNormal))
		nThreadPriority = THREAD_PRIORITY_NORMAL;
	else if(!sPriority.CompareNoCase(g_szBelowNormal))
		nThreadPriority = THREAD_PRIORITY_BELOW_NORMAL;
	else if(!sPriority.CompareNoCase(g_szLowest))
		nThreadPriority = THREAD_PRIORITY_LOWEST;
	else
		nThreadPriority = THREAD_PRIORITY_LOWEST;

	return nThreadPriority;
}

void CChildFrame::SetCommandTimeOut(const int& lCmdTimeOut)
{
	if(m_lConnectionState == ADODB::adStateOpen)
	{
		try
		{
			m_ptrConnection->CommandTimeout = lCmdTimeOut;
			m_nQueryTimeOut = lCmdTimeOut;
		}
		catch(const _com_error& e)
		{
			CString sMsg = GetProviderError();
			if(sMsg.IsEmpty())
				sMsg = GetComError(e);
			TRACE(_T("%s\n"), (LPCTSTR)sMsg);
		}
		catch(...)
		{
			TRACE(_T("Errors occurred.\n"));
		}
	}
}

void CChildFrame::SetCacheSize(const int& nCacheSize)
{
	if(m_ptrRecordset != NULL)
	{
		try
		{
			if(!m_bExecuting)
			{
				m_ptrRecordset->CacheSize = nCacheSize;
				m_nCacheSize = nCacheSize;
			}
		}
		catch(const _com_error& e)
		{
			CString sMsg = GetProviderError();
			if(sMsg.IsEmpty())
				sMsg = GetComError(e);
			TRACE(_T("%s\n"), (LPCTSTR)sMsg);
		}
		catch(...)
		{
			TRACE(_T("Errors occurred.\n"));
		}
	}
}

void CChildFrame::SetThreadPriority(const CString& sThreadPriority)
{
	m_nThreadPriority = GetThreadPriority(sThreadPriority);	
}

LONG CChildFrame::OnExecProcComplete(UINT wParam, LONG lParam)
{
	UNUSED_ALWAYS(lParam);
	OnExecutionComplete(wParam, lParam);
	m_bProcText = FALSE;

	return 0L;
}

LONG CChildFrame::OnExecutionComplete(UINT wParam, LONG lParam)
{
	UNUSED_ALWAYS(lParam);

	if(::IsWindow(m_hWnd) && !m_bExecuteCompleteHandled)
	{
		m_bExecuteCompleteHandled = TRUE;
		m_strSQL.Empty();

		CloseRecordset();

		if(m_bProcText)
		{
			if(m_strProcText.length())
			{
				if(m_strStatusText.CompareNoCase(g_szMessages) != 0)
				{
					m_pResultView->GetRichEditCtrl().SetWindowText(m_strProcText.c_str());
					m_pResultView->GetRichEditCtrl().SetSel(0, 0); // Scroll up!
					m_strStatusText.Format(
						_T("# of lines of text: %d"),
						m_pResultView->GetRichEditCtrl().GetLineCount()
						);
					m_pResultView->Invalidate();
					m_pResultView->UpdateWindow();
				}
			}
		}
		else
		{
			if(m_nGridCount)
			{
				SetResultSetInfo();
				m_ThreadParam.m_pGridCtrl->SetRedraw(TRUE);
				m_ThreadParam.m_pGridCtrl->Invalidate();
				m_ThreadParam.m_pGridCtrl->UpdateWindow();
				m_pResultView->SetRedraw(TRUE);
				m_pResultView->Invalidate();
				m_pResultView->UpdateWindow();
				if(m_strStatusText.CompareNoCase(g_szMessages) != 0)
					m_ThreadParam.m_pGridCtrl->ShowWindow(SW_SHOW);
			}
		}

		if(m_bCanceled)
		{
			m_strPaneTextZero = "Query batch canceled";
			if(m_strMessages.length())
				m_strMessages += _T("\n\n");
			m_strMessages += _T("Query canceled by user.");
		}
		else if(wParam)
			m_strPaneTextZero = "Query batch completed with errors";
		else
		{
			m_strPaneTextZero = "Query batch completed";
			if(m_bProcText)
			{
				if(!m_strProcText.length() && !m_strMessages.length())
					m_strMessages = _T("The command(s) completed successfully.");
			}
			else
			{
				if(!m_nGridCount && !m_strMessages.length())
					m_strMessages = _T("The command(s) completed successfully.");
			}
		}
		
		m_wndStatusBar.SetPaneText(0, m_strPaneTextZero);
				
		if(m_bProcText)
		{
			if(!m_strProcText.length() && m_strStatusText.CompareNoCase(g_szMessages) != 0)
				OnViewMessages();
		}
		else
		{
			if(!m_nGridCount && m_strStatusText.CompareNoCase(g_szMessages) != 0)
				OnViewMessages();
		}

		SetExecutionTime();

		if(m_nTimerID != 0)
		{
			KillTimer(m_nTimerID);
			m_nTimerID = 0;
		}

		m_bExecuting = FALSE;
		m_bCanceling = FALSE;
		m_bCanceled = FALSE;
		
		bool bOkUI = true;
		if(m_bCloseMainFrameAfterCancel)
			bOkUI = false;
		if(m_bDisconnectAllAfterCancel)
			bOkUI = false;
		if(m_bCloseAfterCancel)
			bOkUI = false;
		if(bOkUI)
		{
			LONG lIdle = 0;
			while(AfxGetApp()->OnIdle(lIdle++));
		}
	}

	return 0L;
}

LONG CChildFrame::OnGetGridCtrl(UINT wParam, LONG lParam)
{
	LRESULT lResult = 0L;
	
	if(::IsWindow(m_hWnd))
	{