Category

Development Platform
Home > SourceCode/Document > Database system > SQL Server > View Code
MainFrm.cpp
Package: ISQL_src.zip　[view]
Upload User: jsxglz
Upload Date: 2007-01-03
Package Size: 117k
Code Size: 43k
Category:

SQL Server

Development Platform:

Visual C++

MainFrm.cpp：Code Content
  1. // MainFrm.cpp : implementation of the CMainFrame class
  2. //
  4. #include "stdafx.h"
  5. #include "InteractiveSQL.h"
  6. #include "MainFrm.h"
  7. #include "SelectTables.h"
  8. #include "ProceduresDlg.h"
  9. #include "MySheet.h"
  10. #include "catsets.h"
  11. #include "DrvInfo.h"
  12. #include "ConfigureDlg.h"
  13. #include "QueryOptionsDlg.h"
  14. #include "ExecuteSQLProc.h"
  15.  
  16. #ifdef _DEBUG
  17. #define new DEBUG_NEW
  18. #undef THIS_FILE
  19. static char THIS_FILE[] = __FILE__;
  20. #endif
  22. extern CInteractiveSQLApp theApp;
  23. const CString g_szODBCJTDriver = "ODBCJT32.DLL";
  25. const char* g_szNoData = "<No Data>";
  26. const char* g_szRefresh = "<Refresh>";
  28. // Configure
  29. extern const char* g_szConfigure;
  30. extern const char* g_szLoginTimeOut;
  31. extern const char* g_szQueryTimeOut;
  33. // Query options
  34. extern const char* g_szQueryOptions;
  35. extern const char* g_szThreadPriority;
  36. extern const char* g_szTimeCritical;
  37. extern const char* g_szHighest;
  38. extern const char* g_szAboveNormal;
  39. extern const char* g_szNormal;
  40. extern const char* g_szBelowNormal;
  41. extern const char* g_szLowest;
  43. // For SQLCancel
  44. extern const char* g_szFunctionSequenceError;
  46. // IsTextDataSrc
  47. const char* g_szText = "Text";
  48. /////////////////////////////////////////////////////////////////////////////
  49. // CMainFrame
  51. IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)
  53. BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
  54. //{{AFX_MSG_MAP(CMainFrame)
  55. ON_WM_CREATE()
  56. ON_COMMAND(ID_SQL_LOGON, OnSqlLogon)
  57. ON_COMMAND(ID_SQL_EXECUTE, OnSqlExecute)
  58. ON_UPDATE_COMMAND_UI(ID_SQL_EXECUTE, OnUpdateSqlExecute)
  59. ON_COMMAND(ID_SQL_LOGOFF, OnSqlLogoff)
  60. ON_UPDATE_COMMAND_UI(ID_SQL_LOGOFF, OnUpdateSqlLogoff)
  61. ON_UPDATE_COMMAND_UI(ID_SQL_LOGON, OnUpdateSqlLogon)
  62. ON_WM_SIZE()
  63. ON_COMMAND(ID_SQL_SELECT_TABLES, OnSqlSelectTables)
  64. ON_UPDATE_COMMAND_UI(ID_SQL_SELECT_TABLES, OnUpdateSqlSelectTables)
  65. ON_CBN_SELCHANGE(IDW_COMBO, OnSelChangeDatabase)
  66. ON_COMMAND(ID_SQL_SELECT_PROCEDURES, OnSqlSelectProcedures)
  67. ON_UPDATE_COMMAND_UI(ID_SQL_SELECT_PROCEDURES, OnUpdateSqlSelectProcedures)
  68. ON_COMMAND(ID_SQL_OBJECTS, OnSqlObjects)
  69. ON_COMMAND(ID_VIEW_PREV_RESULT_SET, OnViewPrevResultSet)
  70. ON_UPDATE_COMMAND_UI(ID_VIEW_PREV_RESULT_SET, OnUpdateViewPrevResultSet)
  71. ON_COMMAND(ID_VIEW_NEXT_RESULT_SET, OnViewNextResultSet)
  72. ON_UPDATE_COMMAND_UI(ID_VIEW_NEXT_RESULT_SET, OnUpdateViewNextResultSet)
  73. ON_COMMAND(ID_VIEW_FIRST_RESULT_SET, OnViewFirstResultSet)
  74. ON_UPDATE_COMMAND_UI(ID_VIEW_FIRST_RESULT_SET, OnUpdateViewFirstResultSet)
  75. ON_COMMAND(ID_VIEW_LAST_RESULT_SET, OnViewLastResultSet)
  76. ON_UPDATE_COMMAND_UI(ID_VIEW_LAST_RESULT_SET, OnUpdateViewLastResultSet)
  77. ON_UPDATE_COMMAND_UI(ID_SQL_OBJECTS, OnUpdateSqlObjects)
  78. ON_COMMAND(ID_HELP_ODBC_INFO, OnHelpOdbcInfo)
  79. ON_UPDATE_COMMAND_UI(ID_HELP_ODBC_INFO, OnUpdateHelpOdbcInfo)
  80. ON_COMMAND(ID_SQL_CANCEL, OnSqlCancel)
  81. ON_UPDATE_COMMAND_UI(ID_SQL_CANCEL, OnUpdateSqlCancel)
  82. ON_COMMAND(ID_SERVER_CONFIGURE, OnServerConfigure)
  83. ON_COMMAND(ID_QUERY_OPTIONS, OnQueryOptions)
  84. ON_UPDATE_COMMAND_UI(IDW_COMBO, OnUpdateCombo)
  85. ON_COMMAND(ID_QUERY_NEW, OnQueryNew)
  86. ON_UPDATE_COMMAND_UI(ID_QUERY_NEW, OnUpdateQueryNew)
  87. ON_WM_CLOSE()
  88. //}}AFX_MSG_MAP
  89. ON_UPDATE_COMMAND_UI(ID_INDICATOR_RESULT_SET, OnUpdateIndicatorResultSetInfo)
  90. ON_MESSAGE(WM_EXECUTION_COMPLETE, OnExecutionComplete)
  91. END_MESSAGE_MAP()
  93. static UINT indicators[] =
  94. {
  95. ID_SEPARATOR,
  96. ID_INDICATOR_EXECUTION_TIME,
  97. ID_SERVER_NAME_INDICATOR,
  98. ID_INDICATOR_RESULT_SET,
  99. ID_INDICATOR_CAPS,
  100. ID_INDICATOR_NUM,
  101. ID_INDICATOR_SCRL,
  102. };
  104. /////////////////////////////////////////////////////////////////////////////
  105. // CMainFrame construction/destruction
  107. CMainFrame::CMainFrame()
  108. {
  109. m_bOKToSize = false;
  110. m_nExecutionTimePaneNo = 1;
  111. m_nResultSetPaneNo = 2;
  112. m_nServerPaneNo = 3;
  113. m_nID = 2000;
  114. m_nIndex = 0;
  116. m_strStatusText = "CDatabase::m_hdbc == <NULL>";
  117. m_strODBCDSN = "DSN: <NULL>";
  118. m_strExecutionTime = "Execution Time: <n/a>";
  120. m_strMSSQLServer = _T("Microsoft SQL Server");
  121. m_strSQLAnyWhere =_T("Sybase SQL Anywhere");
  122. m_strSybaseOpenServer = _T("SQL Server");
  123. m_strOracle = _T("Oracle");
  125. m_bIsJetDriver = FALSE;
  126. m_bIsTSQLSupported = FALSE;
  127. m_bIsMultiSetSupported = FALSE;
  128. m_bExecuting = FALSE;
  129. m_bSQLCancelSupported = FALSE;
  130. m_bCanceled = FALSE;
  132. m_nLoginTimeOut = AfxGetApp()->GetProfileInt(g_szConfigure, g_szLoginTimeOut, 0);
  133. m_nQueryTimeOut = AfxGetApp()->GetProfileInt(g_szConfigure, g_szQueryTimeOut, 0);
  134. m_nThreadPriority = GetThreadPriority(AfxGetApp()->GetProfileString(g_szQueryOptions,
  135. g_szThreadPriority));
  137. m_pSet = NULL;
  138. }
  140. CMainFrame::~CMainFrame()
  141. {
  142. ClearGridList();
  144. if(m_font.m_hObject)
  145. {
  146. m_font.Detach();
  147. m_font.m_hObject = NULL;
  148. }
  150. if(m_pSet)
  151. {
  152. delete m_pSet;
  153. m_pSet = NULL;
  154. }
  155. }
  157. int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
  158. {
  159. if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
  160. return -1;
  162. if(!m_wndToolBar.Create(this) ||
  163. !m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
  164. {
  165. TRACE0("Failed to create toolbarn");
  166. return -1;      // fail to create
  167. }
  169. if (!m_wndStatusBar.Create(this) ||
  170. !m_wndStatusBar.SetIndicators(indicators,
  171.   sizeof(indicators)/sizeof(UINT)))
  172. {
  173. TRACE0("Failed to create status barn");
  174. return -1;      // fail to create
  175. }
  177. CRect rect;
  178. UINT nIndex = m_wndToolBar.GetToolBarCtrl().CommandToIndex(IDW_COMBO);
  179. m_wndToolBar.SetButtonInfo(nIndex, IDW_COMBO, TBBS_SEPARATOR, 150);
  180. m_wndToolBar.GetToolBarCtrl().GetItemRect(nIndex, &rect);
  181. rect.top = 2;
  182. rect.bottom = rect.top + 250 /*drop height*/;
  183. if(!m_comboBox.Create(CBS_DROPDOWNLIST | CBS_SORT | WS_VISIBLE |
  184. WS_TABSTOP | WS_VSCROLL, rect, &m_wndToolBar, IDW_COMBO))
  185. {
  186. TRACE("Failed to create combo-boxn");
  187. return FALSE;
  188. }
  190. LOGFONT logFont;
  191. memset(&logFont, 0, sizeof(logFont));
  192. logFont.lfHeight = -11;
  193. logFont.lfWeight = 400;
  194. lstrcpy(logFont.lfFaceName, "MS Sans Serif");
  196. if(!m_font.CreateFontIndirect(&logFont))
  197. TRACE("Could Not create font for Combon");
  198. else
  199. m_comboBox.SetFont(&m_font);
  201. m_comboBox.EnableWindow(FALSE);
  203. // TODO: Remove this if you don't want tool tips or a resizeable toolbar
  204. m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
  205. CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
  207. // TODO: Delete these three lines if you don't want the toolbar to
  208. // be dockable
  209. m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
  210. EnableDocking(CBRS_ALIGN_ANY);
  211. DockControlBar(&m_wndToolBar);
  213. m_wndToolBar.ModifyStyle(0, TBSTYLE_FLAT);
  215. return 0;
  216. }
  218. BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
  219. {
  220. // TODO: Modify the Window class or styles here by modifying
  221. //  the CREATESTRUCT cs
  223. cs.style = WS_OVERLAPPED | WS_CAPTION | FWS_ADDTOTITLE
  224. | WS_THICKFRAME | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_MAXIMIZE;
  226. return CFrameWnd::PreCreateWindow(cs);
  227. }
  229. /////////////////////////////////////////////////////////////////////////////
  230. // CMainFrame diagnostics
  232. #ifdef _DEBUG
  233. void CMainFrame::AssertValid() const
  234. {
  235. CFrameWnd::AssertValid();
  236. }
  238. void CMainFrame::Dump(CDumpContext& dc) const
  239. {
  240. CFrameWnd::Dump(dc);
  241. }
  243. #endif //_DEBUG
  245. /////////////////////////////////////////////////////////////////////////////
  246. // CMainFrame message handlers
  248. BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext) 
  249. {
  250. if(!m_wndSplitter.CreateStatic(this, 2, 1))
  251. {
  252. TRACE0("Failed to CreateStaticSplittern");
  253. return FALSE;
  254. }
  255.  
  256. if(!m_wndSplitter.CreateView(0, 0,
  257. RUNTIME_CLASS(CSQLView), CSize(0, 0), pContext))
  258. {
  259. TRACE0("Failed to create third panen");
  260. return FALSE;
  261. }
  263. // CResultView must be the last in the creation process.
  264. // There can be only one CRichEditDoc per CRichEditView
  265. if(!m_wndSplitter.CreateView(1, 0,
  266. RUNTIME_CLASS(CResultView), CSize(0, 0), pContext))
  267. {
  268. TRACE0("Failed to create first panen");
  269. return FALSE;
  270. }
  272. CSQLView* pSQLView = GetSQLView();
  273. if(pSQLView)
  274. pSQLView->SetFocus();
  276. m_bOKToSize = true;
  278. return TRUE;
  279. }
  281. void CMainFrame::OnSqlLogon() 
  282. {
  283. CWaitCursor wait;
  285. if(!m_database.IsOpen())
  286. ConnectDataSource();
  287. else
  288. {
  289. if(!CloneProcess(false))
  290. {
  291. ::MessageBeep(MB_ICONEXCLAMATION);
  292. AfxMessageBox("Error cloning <this> process.");
  293. }
  294. }
  295. }
  297. void CMainFrame::ConnectDataSource()
  298. {
  299. CWaitCursor wait;
  301. CString sMsg;
  303. try
  304. {
  305. m_dwStart = ::GetTickCount();
  306. m_database.SetLoginTimeout(m_nLoginTimeOut);
  307. BOOL bOpen = FALSE;
  308. if(theApp.m_strConnectString.IsEmpty())
  309. bOpen = m_database.Open(NULL, FALSE, FALSE, "ODBC;", FALSE);
  310. else
  311. {
  312. m_wndStatusBar.SetPaneText(0, "Establishing connection...");
  313. bOpen = m_database.OpenEx(theApp.m_strConnectString, CDatabase::noOdbcDialog);
  314. }
  315. if(bOpen)
  316. {
  317. UCHAR buffer[200];
  318. SWORD cbData;
  319. ::SQLGetInfo(m_database.m_hdbc, SQL_SERVER_NAME, (PTR)buffer, 200, &cbData);
  320. m_strServerName = buffer;
  322. ::SQLGetInfo(m_database.m_hdbc, SQL_DBMS_NAME, (PTR)buffer, 200, &cbData);
  323. m_strDBMS = buffer;
  325. ::SQLGetInfo(m_database.m_hdbc, SQL_DATA_SOURCE_NAME, (PTR)buffer, 200, &cbData);
  326. m_strODBCDSN = buffer;
  328. if(m_strServerName.IsEmpty())
  329. m_strServerName = m_strDBMS;
  331. m_bIsJetDriver = IsODBCJetDriver();
  332. if(m_bIsJetDriver)
  333. m_strServerName = m_database.GetDatabaseName();
  335. m_bIsTSQLSupported = (!m_strDBMS.CompareNoCase(m_strSQLAnyWhere) ||
  336. !m_strDBMS.CompareNoCase(m_strSybaseOpenServer) ||
  337. !m_strDBMS.CompareNoCase(m_strMSSQLServer));
  339. m_pSet = new CRecordsetEx(&m_database);
  341. if(m_bIsTSQLSupported)
  342. {
  343. if(!FillCombo())
  344. TRACE("Error filling combo.n");
  345. }
  346. else
  347. {
  348. m_comboBox.AddString("<Not supported>");
  349. m_comboBox.SetCurSel(0);
  350. m_comboBox.EnableWindow(FALSE);
  351. }
  353. m_bIsMultiSetSupported = IsMultiResultSetsSupported();
  354. m_bSQLCancelSupported = IsSQLCancelSupported();
  356. sMsg.Format("Connected to <%s>. %s", m_strServerName,
  357. m_bIsTSQLSupported ? CString("Database context changed to <"
  358. + (m_strDBName.IsEmpty() ? "Unknown" : m_strDBName) + ">.")
  359. : (const char*)CString(""));
  361. m_strStatusText.Format("DSN: %s", (const char*)m_strODBCDSN);
  363. SetExecutionTime();
  364. }
  365. }
  366. catch(CDBException* e)
  367. {
  368.    if(e)
  369.    {
  370.    if(!e->m_strError.IsEmpty())
  371.    sMsg.Format("%s%s", (LPCTSTR)e->m_strError, (LPCTSTR)e->m_strStateNativeOrigin);
  372.    else
  373.    sMsg = e->m_strStateNativeOrigin;
  375.    m_strStatusText.Format("CDBException::m_nRetCode == %d", e->m_nRetCode);
  377.    e->Delete();
  378.    }
  380.    TRACE("%sn", (LPCTSTR)sMsg);
  382. }
  383. catch(CMemoryException* e)
  384. {
  385. m_strStatusText = "Out-of-memory.";
  386. sMsg = m_strStatusText;
  388. if(e)
  389. e->Delete();
  390. }
  392. if(!sMsg.IsEmpty())
  393. OnExceptionClear(sMsg);
  395. if(!theApp.m_strConnectString.IsEmpty())
  396. {
  397. m_wndStatusBar.SetPaneText(0, "");
  398. theApp.m_strConnectString.Empty();
  399. }
  400. }
  402. void CMainFrame::OnSqlLogoff() 
  403. {
  404. CWaitCursor wait;
  406. if(m_database.IsOpen())
  407. {
  408. m_wndStatusBar.SetPaneText(m_nResultSetPaneNo, "Please wait...");
  410. m_database.Close();
  412. OnExceptionClear(CString(""));
  414. m_comboBox.ResetContent();
  415. m_comboBox.EnableWindow(FALSE);
  417. m_strDBName.Empty();
  418. m_strServerName.Empty();
  420. m_strStatusText = "CDatabase::m_hdbc == <NULL>";
  421. m_strODBCDSN = "DSN: <NULL>";
  422. m_strExecutionTime = "Execution Time: <n/a>";
  423. m_nID = 2000;
  424. m_nIndex = 0;
  426. if(m_pSet)
  427. {
  428. delete m_pSet;
  429. m_pSet = NULL;
  430. }
  431. }
  432. }
  434. void CMainFrame::OnSqlExecute() 
  435. {
  436. m_dwStart = ::GetTickCount();
  437. m_strExecutionTime = "Execution Time: <Working...>";
  438. m_wndStatusBar.SetPaneText(m_nExecutionTimePaneNo, m_strExecutionTime);
  440. m_strStatusText = "Executing...";
  441. m_wndStatusBar.SetPaneText(m_nResultSetPaneNo, m_strStatusText);
  443. OnExceptionClear(CString(""));
  445. CStringEx sSQL = GetSQLView()->GetRichEditCtrl().GetSelText();
  446. if(sSQL.IsEmpty())
  447. GetSQLView()->GetRichEditCtrl().GetWindowText(sSQL);
  449. BOOL bProcText = FALSE;
  450. if(m_bIsTSQLSupported)
  451. {
  452. const char* lpszBuff = "sp_helptext ";
  453. int nPos = sSQL.FindNoCase(lpszBuff);
  454. if(nPos != -1)
  455. {
  456. bProcText = TRUE;
  457. CString sObjName = sSQL.Mid(nPos + strlen(lpszBuff));
  458. nPos = sObjName.FindOneOf("nrt ");
  459. if(nPos != -1)
  460. sObjName = sObjName.Left(nPos);
  461. CString sText;
  462. if(!m_strDBMS.CompareNoCase(m_strSQLAnyWhere) ||
  463. !m_strDBMS.CompareNoCase(m_strSybaseOpenServer))
  464. {
  465. if(!IsObjectExists(sObjName))
  466. sText.Format("Object '%s' does not exist in the database.",
  467. (const char*)sObjName);
  468. }
  469. if(sText.IsEmpty())
  470. sText = GetProcedureText(sSQL, sObjName);
  471. if(!sText.IsEmpty())
  472. DisplayProcedureText(sText);
  474. SetExecutionTime();
  475. }
  476. }
  478. if(!bProcText)
  479. if(!ExecuteSQLEx(sSQL))
  480. TRACE("Error executing SQL: %sn", (LPCTSTR)sSQL);
  481. }
  483. BOOL CMainFrame::ExecuteSQLEx(const CStringEx& sSQL)
  484. {
  485. m_ThreadParam.m_strSQL = sSQL;
  486. m_ThreadParam.m_pView = GetResultView();
  487. m_ThreadParam.m_pFrame = this;
  488. m_bExecuting = TRUE;
  489. CWinThread* pThread = AfxBeginThread(ExecuteSQLProc, &m_ThreadParam, m_nThreadPriority);
  490. ASSERT(pThread);
  492. return pThread ? 1 : 0;
  493. }
  495. CSQLView* CMainFrame::GetSQLView()
  496. {
  497. return static_cast<CSQLView*>(m_wndSplitter.GetPane(0, 0));
  498. }
  500. CResultView* CMainFrame::GetResultView()
  501. {
  502. CResultView* pResultView = NULL;
  504. if(m_wndSplitter.m_hWnd != NULL)
  505. pResultView = static_cast<CResultView*>(m_wndSplitter.GetPane(1, 0));
  507. return pResultView;
  508. }
  510. void CMainFrame::OnSize(UINT nType, int cx, int cy) 
  511. {
  512. if(m_bOKToSize)
  513. {
  514. CRect rect;
  515. GetClientRect(&rect);
  516. m_wndSplitter.SetRowInfo(0, rect.Height()/2, 0);
  517. }
  519. CFrameWnd::OnSize(nType, cx, cy);
  520. }
  522. void CMainFrame::OnSqlSelectTables() 
  523. {
  524. CWaitCursor wait;
  526. CSelectTables dlg;
  527. if(dlg.DoModal() == IDOK)
  528. {
  529. m_dwStart = ::GetTickCount();
  530. m_strExecutionTime = "Execution Time: <Working...>";
  531. m_wndStatusBar.SetPaneText(m_nExecutionTimePaneNo, m_strExecutionTime);
  533. m_strStatusText = "Executing...";
  534. m_wndStatusBar.SetPaneText(m_nResultSetPaneNo, m_strStatusText); 
  536. OnExceptionClear(CString(""));
  538. CString sBuff;
  539. GetSQLView()->GetRichEditCtrl().GetWindowText(sBuff);
  540. int nStart = sBuff.GetLength();
  541. sBuff += dlg.m_strSQL;
  542. if(m_bIsJetDriver && dlg.m_bTextOnly && dlg.m_strType.Find("VIEW") != -1)
  543. sBuff += " -- CDaoQueryDef::GetSQL()";
  544. int nEnd = sBuff.GetLength();
  545. CSQLView* pSQLView = GetSQLView();
  546. ASSERT(pSQLView);
  547. pSQLView->GetRichEditCtrl().SetWindowText(sBuff);
  548. pSQLView->GetRichEditCtrl().SetSel(nStart+2, nEnd);
  549. pSQLView->SetFocus();
  551. if(dlg.m_bTextOnly && dlg.m_strType.Find("VIEW") != -1 &&
  552. (m_bIsTSQLSupported || m_bIsJetDriver ||
  553. !m_strDBMS.CompareNoCase(m_strOracle)))
  554. {
  555. CString sText;
  556. if(!m_bIsJetDriver)
  557. sText = GetProcedureText(dlg.m_strSQL, dlg.m_strObjName);
  558. else
  559. sText = GetQueryDef(m_database.GetDatabaseName(), dlg.m_strSQL.Mid(2));
  561. if(!sText.IsEmpty())
  562. DisplayProcedureText(sText);
  564. SetExecutionTime();
  565. }
  566. else
  567. {
  568. if(!ExecuteSQLEx(dlg.m_strSQL))
  569. TRACE("Error executing sql.n");
  570. }
  571. }
  572. }
  574. void CMainFrame::OnUpdateSqlSelectTables(CCmdUI* pCmdUI) 
  575. {
  576. pCmdUI->Enable(m_database.IsOpen() && !m_bExecuting);
  577. }
  579. void CMainFrame::OnExceptionClear(const CString& sMsg)
  580. {
  581. ClearGridList();
  582. CResultView* pResultView = GetResultView();
  583. ASSERT(pResultView);
  584. pResultView->m_strObjName.Empty();
  585. pResultView->GetRichEditCtrl().SetWindowText(sMsg);
  586. pResultView->SetWrapToWindow();
  587. pResultView->GetRichEditCtrl().SetSel(1, 1); // Scroll up!
  588. pResultView->GetRichEditCtrl().UpdateWindow();
  589. m_nID = 2000;
  590. m_nIndex = 0;
  591. SetResultSetInfo();
  592. }
  594. BOOL CMainFrame::FillCombo()
  595. {
  596. BOOL bRet = FALSE;
  598. CString sMsg;
  600. m_comboBox.ResetContent();
  602. try
  603. {
  604. CString sBuff = "SELECT name FROM master..sysdatabases ORDER BY name";
  605. CRecordsetEx set(&m_database);
  606. bRet = set.ExecDirect(sBuff);
  607. if(bRet)
  608. {
  609. if(set.IsBOF())
  610. {
  611. m_comboBox.AddString(g_szNoData);
  612. m_comboBox.SetCurSel(0);
  613. m_comboBox.EnableWindow(FALSE);
  614. }
  615. else
  616. {
  617. while(!set.IsEOF())
  618. {
  619. set.GetFieldValue((short)0, sBuff);
  620. m_comboBox.AddString(sBuff);
  621. set.MoveNext();
  622. }
  623. m_comboBox.InsertString(m_comboBox.GetCount(), g_szRefresh);
  624. m_comboBox.EnableWindow();
  625. }
  627. if(!SelectDatabase())
  628. TRACE("Error selecting database context.n");
  629. }
  630. }
  631. catch(CDBException* e)
  632. {
  633. sMsg.Format("CDBException::m_nRetCode == %d", e->m_nRetCode);
  635. if(e)
  636. e->Delete();
  637. }
  638. catch(CMemoryException* e)
  639. {
  640. sMsg = "Out-of-memory.";
  642. if(e)
  643. e->Delete();
  644. }
  646. if(!bRet)
  647. {
  648. m_comboBox.AddString(sMsg);
  649. m_comboBox.SetCurSel(0);
  650. m_comboBox.EnableWindow(FALSE);
  651. }
  653. return bRet;
  654. }
  656. void CMainFrame::OnSelChangeDatabase()
  657. {
  658. CWaitCursor wait;
  660. CString sBuff, sDBName, sMsg;
  661. m_comboBox.GetWindowText(sDBName);
  662. if(!sDBName.CompareNoCase(g_szNoData))
  663. ;
  664. else if(!sDBName.CompareNoCase(g_szRefresh))
  665. {
  666. m_dwStart = ::GetTickCount();
  667. m_strExecutionTime = "Execution Time: <Working...>";
  668. m_wndStatusBar.SetPaneText(m_nExecutionTimePaneNo, m_strExecutionTime);
  670. if(!FillCombo())
  671. TRACE("Error filling combo.n");
  673. SetExecutionTime();
  674. }
  675. else
  676. {
  677. if(sDBName != m_strDBName)
  678. {
  679. m_dwStart = ::GetTickCount();
  680. m_strExecutionTime = "Execution Time: <Working...>";
  681. m_wndStatusBar.SetPaneText(m_nExecutionTimePaneNo, m_strExecutionTime);
  683. OnExceptionClear(CString(""));
  685. try
  686. {
  687. sBuff = "use " + sDBName;
  688. m_database.ExecuteSQL(sBuff);
  689. m_strDBName = sDBName;
  690. sMsg.Format("Database context changed to <%s>.", (const char*)m_strDBName);
  691. m_comboBox.SelectString(-1, m_strDBName);
  692. m_strStatusText.Format("DSN: %s", (const char*)m_strODBCDSN);
  693. }
  694. catch(CDBException* e)
  695. {
  696.    if(e)
  697.    {
  698. if(!e->m_strError.IsEmpty())
  699. sMsg.Format("%s%s", (LPCTSTR)e->m_strError, (LPCTSTR)e->m_strStateNativeOrigin);
  700. else
  701. sMsg = e->m_strStateNativeOrigin;
  703. m_comboBox.SelectString(-1, m_strDBName);
  705. m_strStatusText.Format("CDBException::m_nRetCode == %d", e->m_nRetCode);
  707. e->Delete();
  708. }
  709. }
  711. OnExceptionClear(sMsg);
  713. SetExecutionTime();
  714. }
  715. }
  716. }
  718. void CMainFrame::OnSqlSelectProcedures() 
  719. {
  720. CWaitCursor wait;
  722. CProceduresDlg dlg;
  723. if(dlg.DoModal() == IDOK)
  724. {
  725. m_dwStart = ::GetTickCount();
  726. m_strExecutionTime = "Execution Time: <Working...>";
  727. m_wndStatusBar.SetPaneText(m_nExecutionTimePaneNo, m_strExecutionTime);
  729. m_strStatusText = "Executing...";
  730. m_wndStatusBar.SetPaneText(m_nResultSetPaneNo, m_strStatusText); 
  732. OnExceptionClear(CString(""));
  734. CStringEx sBuff;
  735. CRichEditCtrl& edit = GetSQLView()->GetRichEditCtrl();
  736. edit.GetWindowText(sBuff);
  737. sBuff += "rnrn";
  738. int nStart = sBuff.GetLength();
  740. CString sSQL;
  741. if(!m_strDBMS.CompareNoCase(m_strSybaseOpenServer) ||
  742.    !m_strDBMS.CompareNoCase(m_strMSSQLServer) ||
  743.    !m_strDBMS.CompareNoCase(m_strSQLAnyWhere))
  744. sSQL = "sp_helptext " + dlg.m_strProcedureName;
  746. if(!m_strDBMS.CompareNoCase(m_strOracle))
  747. {
  748. sSQL = "select TEXT from ALL_SOURCE where type = 'PROCEDURE' and NAME = '";
  749. sSQL += dlg.m_strProcedureName + "'" ;
  750. }
  752. if(m_bIsJetDriver)
  753. sSQL = dlg.m_strProcedureName;
  755. sBuff += sSQL;
  757. if(m_bIsJetDriver)
  758. sBuff += " -- CDaoQueryDef::GetSQL()";
  760. int nEnd = sBuff.GetLength();
  761. edit.SetWindowText(sBuff);
  762. edit.SetSel(nStart, nEnd);
  764. CString sText;
  765. if(m_bIsJetDriver)
  766. sText = GetQueryDef(m_database.GetDatabaseName(), sSQL);
  767. else
  768. sText = GetProcedureText(sSQL, dlg.m_strProcedureName);
  770. if(!sText.IsEmpty())
  771. DisplayProcedureText(sText);
  773. GetSQLView()->SetFocus();
  775. SetExecutionTime();
  776. }
  777. }
  779. void CMainFrame::OnUpdateSqlSelectProcedures(CCmdUI* pCmdUI) 
  780. {
  781. pCmdUI->Enable(m_database.IsOpen() && !m_bExecuting);
  782. }
  784. void CMainFrame::OnSqlObjects() 
  785. {
  786. CRect rect;
  787. UINT nIndex = m_wndToolBar.GetToolBarCtrl().CommandToIndex(ID_SQL_OBJECTS);
  788. m_wndToolBar.GetToolBarCtrl().GetItemRect(nIndex, &rect);
  789. rect.top = rect.bottom;
  790. m_wndToolBar.ClientToScreen(&rect.TopLeft());
  792. CMenu menu;
  793. if(menu.CreatePopupMenu())
  794. {
  795. DWORD dwFlags = MF_ENABLED | MF_STRING;
  796. menu.AppendMenu(dwFlags, ID_SQL_SELECT_TABLES, _T("&Tables...tF8"));
  797. menu.AppendMenu(dwFlags, ID_SQL_SELECT_PROCEDURES, _T("&Procedures...tF9"));
  798. menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON, rect.left, rect.top+4, this);
  799. }
  800. }
  802. CString CMainFrame::GetProcedureText(CString& sSQL, const CString& sObjName)
  803. {
  804. CString sText;
  805. if(!m_strDBMS.CompareNoCase(m_strSQLAnyWhere))
  806. {
  807. sSQL.Format("SELECT text FROM syscomments where id = object_id('%s') ",
  808. (const char*)sObjName);
  809. sSQL += "order by number, colid2, colid";
  810. }
  812. try
  813. {
  814. m_database.SetQueryTimeout(m_nQueryTimeOut);
  815. CRecordsetEx set(&m_database);
  816. if(set.ExecDirect(sSQL))
  817. {
  818. CString sBuff;
  819. if(!set.IsBOF() && set.GetODBCFieldCount())
  820. {
  821. while(!set.IsEOF())
  822. {
  823. set.GetFieldValue((short)0, sBuff);
  824. sText += sBuff;
  825. set.MoveNext();
  826. }
  827. }
  829. // while <::SQLMoreResults> loop. Also, reset the cursor state
  830. // Microsoft SQL Server, SybaseSQLAnywhere, and Oracle will bail
  831. // here.
  832. while(set.FlushResultSet())
  833. {
  834. // Clean up the old column info and build  new one
  835. set.AllocAndCacheFieldInfo();
  836. if(!set.IsBOF() && set.GetODBCFieldCount())
  837. {
  838. sText += "nn";
  840. set.MoveNext();
  842. while(!set.IsEOF())
  843. {
  844. set.GetFieldValue((short)0, sBuff);
  845. sText += sBuff;
  846. set.MoveNext();
  847. }
  848. }
  849. }
  851. GetResultView()->m_strObjName = sObjName;
  852. }
  853. }
  854. catch(CDBException* e)
  855. {
  856.    if(e)
  857.    {
  858. CString sMsg;
  859. if(!e->m_strError.IsEmpty())
  860. sMsg.Format("%s%s", (LPCTSTR)e->m_strError, (LPCTSTR)e->m_strStateNativeOrigin);
  861. else
  862. sMsg = e->m_strStateNativeOrigin;
  864. m_strStatusText.Format("CDBException::m_nRetCode == %d", e->m_nRetCode);
  865. OnExceptionClear(sMsg);
  867. e->Delete();
  868.    }
  869. }
  870. catch(CMemoryException* e)
  871. {
  872. m_strStatusText = "Out-of-memory";
  873. OnExceptionClear(m_strStatusText);
  875. if(e)
  876. e->Delete();
  877. }
  879. return sText;
  880. }
  882. CString CMainFrame::GetQueryDef(const CString& sDBName, const CString& sSQL)
  883. {
  884. CString sText;
  886. try
  887. {
  888. CDaoDatabase db;
  889. db.Open(sDBName);
  890. CDaoQueryDef qDef(&db);
  891. qDef.Open(sSQL);
  892. sText = qDef.GetSQL();
  894. GetResultView()->m_strObjName = sSQL;
  895. }
  896. catch(CDaoException* e)
  897. {
  898. if(e)
  899. {
  900. CString sMsg;
  901. if(e->m_pErrorInfo)
  902. {
  903. sMsg.Format("%s (%d)", (LPCTSTR)e->m_pErrorInfo->m_strDescription,
  904. e->m_pErrorInfo->m_lErrorCode);
  905. }
  906. else
  907. {
  908. sMsg.Format(
  909. _T("ERROR:CDaoExceptionnn")
  910. _T("SCODE_CODE      =%dn")
  911. _T("SCODE_FACILITY  =%dn")
  912. _T("SCODE_SEVERITY  =%dn")
  913. _T("ResultFromScode =%dn"),
  914. SCODE_CODE      (e->m_scode),
  915. SCODE_FACILITY  (e->m_scode),
  916. SCODE_SEVERITY  (e->m_scode),
  917. ResultFromScode (e->m_scode));
  918. }
  920. m_strStatusText.Format("CDaoException::m_lErrorCode == %d",
  921. e->m_pErrorInfo->m_lErrorCode);
  922. OnExceptionClear(sMsg);
  924. e->Delete();
  925. }
  926. }
  927. catch(CMemoryException* e)
  928. {
  929. m_strStatusText = "Out-of-memory";
  930. OnExceptionClear(m_strStatusText);
  932. if(e)
  933. e->Delete();
  934. }
  936. return sText;
  937. }
  939. void CMainFrame::DisplayProcedureText(const CString& sText)
  940. {
  941. ClearGridList();
  942. CResultView* pResultView = GetResultView();
  943. ASSERT(pResultView);
  944. pResultView->GetRichEditCtrl().SetWindowText(sText);
  945. pResultView->SetWrapNone();
  946. pResultView->GetRichEditCtrl().SetSel(1, 1); // Scroll up!
  947. pResultView->GetRichEditCtrl().UpdateWindow();
  948. m_strStatusText.Format("# of lines of text: %d",
  949. pResultView->GetRichEditCtrl().GetLineCount());
  950. }
  952. BOOL CMainFrame::IsObjectExists(const CString& sObjName)
  953. {
  954. bool bExists = false;
  956. try
  957. {
  958. CString sBuff;
  959. CRecordsetEx set(&m_database);
  960. sBuff.Format("select object_id('%s')", (const char*)sObjName);
  961. if(set.ExecDirect(sBuff))
  962. {
  963. set.GetFieldValue((short)0, sBuff);
  964. if(!sBuff.IsEmpty())
  965. bExists = true;
  966. }
  967. }
  968. catch(CDBException* e)
  969. {
  970.    if(e)
  971.    {
  972. CString sMsg;
  973. if(!e->m_strError.IsEmpty())
  974. sMsg.Format("%s%s", (LPCTSTR)e->m_strError, (LPCTSTR)e->m_strStateNativeOrigin);
  975. else
  976. sMsg = e->m_strStateNativeOrigin;
  978. TRACE("sMsg: %sn", (const char*)sMsg);
  980. e->Delete();
  981.    }
  982. }
  983. catch(CMemoryException* e)
  984. {
  985. TRACE("Out-of-memory.");
  987. if(e)
  988. e->Delete();
  989. }
  991. return bExists;
  992. }
  994. void CMainFrame::ClearGridList()
  995. {
  996. for(POSITION pos = m_GridList.GetHeadPosition(); pos != NULL;)
  997. {
  998. CMSFlexGrid* pGridCtrl =  (CMSFlexGrid*)m_GridList.GetNext(pos);
  999. if(pGridCtrl)
  1000. {
  1001. delete pGridCtrl;
  1002. pGridCtrl = NULL;
  1003. }
  1004. }
  1006. if(!m_GridList.IsEmpty())
  1007. m_GridList.RemoveAll();
  1009. CResultView* pResultView = GetResultView();
  1010. if(pResultView)
  1011. pResultView->m_pGridCtrl = NULL;
  1012. }
  1014. void CMainFrame::SetResultSetInfo()
  1015. {
  1016. HGDIOBJ hOldFont = NULL;
  1017. HFONT hFont = (HFONT)m_wndStatusBar.SendMessage(WM_GETFONT);
  1018. CClientDC dc(NULL);
  1019. if(hFont != NULL) 
  1020. hOldFont = dc.SelectObject(hFont);
  1022. // Result set info
  1023. UINT nID, nStyle;
  1024. int nWidth;
  1025. m_wndStatusBar.GetPaneInfo(m_nResultSetPaneNo, nID, nStyle, nWidth);
  1026. CSize size = dc.GetTextExtent(m_strStatusText);
  1027. m_wndStatusBar.SetPaneInfo(m_nResultSetPaneNo, nID, nStyle, size.cx);
  1028. if(m_strStatusText.IsEmpty())
  1029. m_strStatusText.Format("DSN: %s", (const char*)m_strODBCDSN);
  1030. m_wndStatusBar.SetPaneText(m_nResultSetPaneNo, m_strStatusText);
  1032. // Server info
  1033. if(m_strServerName.IsEmpty())
  1034. m_strServerName = "Server Name: <NULL>";
  1035. m_wndStatusBar.GetPaneInfo(m_nServerPaneNo, nID, nStyle, nWidth);
  1036. size = dc.GetTextExtent(m_strServerName);
  1037. m_wndStatusBar.SetPaneInfo(m_nServerPaneNo, nID, nStyle, size.cx);
  1038. m_wndStatusBar.SetPaneText(m_nServerPaneNo, m_strServerName);
  1040. // Execution time info
  1041. m_wndStatusBar.GetPaneInfo(m_nExecutionTimePaneNo, nID, nStyle, nWidth);
  1042. size = dc.GetTextExtent(m_strExecutionTime);
  1043. m_wndStatusBar.SetPaneInfo(m_nExecutionTimePaneNo, nID, nStyle, size.cx);
  1044. m_wndStatusBar.SetPaneText(m_nExecutionTimePaneNo, m_strExecutionTime);
  1045. }
  1047. void CMainFrame::OnUpdateIndicatorResultSetInfo(CCmdUI* pCmdUI)
  1048. {
  1049. SetResultSetInfo();
  1050. pCmdUI->Enable(TRUE);
  1051. }
  1053. void CMainFrame::OnViewPrevResultSet() 
  1054. {
  1055. POSITION pos = m_GridList.FindIndex(m_nIndex-2);
  1056. DisplayResults((CMSFlexGrid*)m_GridList.GetAt(pos), --m_nIndex);
  1057. }
  1059. void CMainFrame::OnViewNextResultSet() 
  1060. {
  1061. POSITION pos = m_GridList.FindIndex(m_nIndex);
  1062. DisplayResults((CMSFlexGrid*)m_GridList.GetAt(pos), ++m_nIndex);
  1063. }
  1065. void CMainFrame::OnViewFirstResultSet() 
  1066. {
  1067. m_nIndex = 0;
  1068. POSITION pos = m_GridList.FindIndex(m_nIndex);
  1069. DisplayResults((CMSFlexGrid*)m_GridList.GetAt(pos), ++m_nIndex);
  1070. }
  1072. void CMainFrame::OnViewLastResultSet() 
  1073. {
  1074. m_nIndex = m_GridList.GetCount();
  1075. POSITION pos = m_GridList.FindIndex(--m_nIndex);
  1076. DisplayResults((CMSFlexGrid*)m_GridList.GetAt(pos), ++m_nIndex);
  1077. }
  1079. void CMainFrame::OnUpdateViewPrevResultSet(CCmdUI* pCmdUI) 
  1080. {
  1081. pCmdUI->Enable(m_nIndex > 1 && !m_bExecuting);
  1082. }
  1084. void CMainFrame::OnUpdateViewNextResultSet(CCmdUI* pCmdUI) 
  1085. {
  1086. pCmdUI->Enable((m_GridList.GetCount() > m_nIndex) && !m_bExecuting);
  1087. }
  1089. void CMainFrame::OnUpdateViewFirstResultSet(CCmdUI* pCmdUI) 
  1090. {
  1091. OnUpdateViewPrevResultSet(pCmdUI);
  1092. }
  1094. void CMainFrame::OnUpdateViewLastResultSet(CCmdUI* pCmdUI) 
  1095. {
  1096. OnUpdateViewNextResultSet(pCmdUI);
  1097. }
  1099. void CMainFrame::DisplayResults(CMSFlexGrid* pGridCtrl, const int& nCurrentSet)
  1100. {
  1101. if(m_GridList.GetCount() > 1)
  1102. HideResultSets();
  1104. CResultView* pResultView = GetResultView();
  1105. ASSERT(pResultView);
  1106. CRect rect;
  1107. pResultView->GetWindowRect(&rect);
  1108. pGridCtrl->MoveWindow(0, 0, rect.Width(), rect.Height());
  1109. pGridCtrl->ShowWindow(SW_SHOW);
  1110. pGridCtrl->UpdateWindow();
  1111. pResultView->m_pGridCtrl = pGridCtrl;
  1112. pResultView->UpdateWindow();
  1113. m_strStatusText.Format("Result set %d of %d; %d Row(s); %d Column(s)", nCurrentSet,
  1114. m_GridList.GetCount(), pGridCtrl->GetRows()-1, pGridCtrl->GetCols());
  1115. if(GetFocus() == pResultView)
  1116. pGridCtrl->SetFocus();
  1117. }
  1119. void CMainFrame::HideResultSets()
  1120. {
  1121. int nResultSet = m_GridList.GetCount();
  1122. for(int n = 0; n < nResultSet; n++)
  1123. ((CMSFlexGrid*)m_GridList.GetAt(m_GridList.FindIndex(n)))->ShowWindow(SW_HIDE);
  1124. }
  1126. void CMainFrame::OnUpdateSqlObjects(CCmdUI* pCmdUI) 
  1127. {
  1128. pCmdUI->Enable(m_database.IsOpen() && !m_bExecuting);
  1129. }
  1131. void CMainFrame::OnUpdateSqlLogon(CCmdUI* pCmdUI) 
  1132. {
  1133. pCmdUI->Enable(TRUE);
  1134. }
  1136. void CMainFrame::OnUpdateSqlLogoff(CCmdUI* pCmdUI) 
  1137. {
  1138. pCmdUI->Enable(m_database.IsOpen() && !m_bExecuting);
  1139. }
  1141. void CMainFrame::OnUpdateSqlExecute(CCmdUI* pCmdUI) 
  1142. {
  1143. pCmdUI->Enable(m_database.IsOpen() && 
  1144. GetSQLView()->GetRichEditCtrl().GetTextLength() &&
  1145. !m_bExecuting);
  1146. }
  1148. void CMainFrame::OnHelpOdbcInfo()
  1149. {
  1150. CWaitCursor wait;
  1152. // Create our property sheet
  1153. CMyPropertySheet sheet(_T("ODBC Driver Info"));
  1155. // Create all our property pages
  1156. CDriverInfo    DriverInfoPage(&m_database);
  1157. CFunctions     FunctionsPage(&m_database);
  1158. CSupportedSQL  SupportedSQLPage(&m_database);
  1159. CDataTypes     DataTypesPage(&m_database);
  1160. CIdentifiers   IdentifiersPage(&m_database);
  1161. CLimits        LimitsPage(&m_database);
  1162. CMisc1         Misc1Page(&m_database);
  1163. CMisc2         Misc2Page(&m_database);
  1165. // Add the pages to our sheet
  1166. sheet.AddPage(&DriverInfoPage);
  1167. sheet.AddPage(&FunctionsPage);
  1168. sheet.AddPage(&SupportedSQLPage);
  1169. sheet.AddPage(&DataTypesPage);
  1170. sheet.AddPage(&IdentifiersPage);
  1171. sheet.AddPage(&LimitsPage);
  1172. sheet.AddPage(&Misc1Page);
  1173. sheet.AddPage(&Misc2Page);
  1175. sheet.DoModal();
  1176. }
  1178. void CMainFrame::OnUpdateHelpOdbcInfo(CCmdUI* pCmdUI) 
  1179. {
  1180. pCmdUI->Enable(m_database.IsOpen() && !m_bExecuting);
  1181. }
  1183. BOOL CMainFrame::IsODBCJetDriver()
  1184. {
  1185. UCHAR buffer[200];
  1186. SWORD cbData;
  1187. ::SQLGetInfo(m_database.m_hdbc, SQL_DRIVER_NAME, (PTR)buffer, 200, &cbData);
  1188. CString sBuff = buffer;
  1190. return !sBuff.CompareNoCase(g_szODBCJTDriver);
  1191. }
  1193. BOOL CMainFrame::IsMultiResultSetsSupported()
  1194. {
  1195. UCHAR buffer[200];
  1196. SWORD cbData;
  1197. ::SQLGetInfo(m_database.m_hdbc, SQL_MULT_RESULT_SETS, (PTR)buffer, 200, &cbData);
  1199. return (CString(buffer) == _T("Y"));
  1200. }
  1202. void CMainFrame::OnSqlCancel() 
  1203. {
  1204. if(m_pSet->m_hstmt)
  1205. {
  1206. m_strStatusText = "Canceling...";
  1207. m_wndStatusBar.SetPaneText(m_nResultSetPaneNo, m_strStatusText);
  1208. if(m_pSet->IsOpen())
  1209. m_pSet->Cancel();
  1210. m_bCanceled = TRUE;
  1211. ::MessageBeep(MB_ICONEXCLAMATION);
  1212. OnExceptionClear(CString("Query canceled by user."));
  1213. m_strStatusText = "Canceled";
  1215. LONG lIdle = 0;
  1216. while(AfxGetApp()->OnIdle(lIdle++));
  1217. }
  1218. }
  1220. void CMainFrame::OnUpdateSqlCancel(CCmdUI* pCmdUI) 
  1221. {
  1222. pCmdUI->Enable(m_database.IsOpen() && m_bExecuting && m_bSQLCancelSupported);
  1223. }
  1225. void CMainFrame::OnServerConfigure() 
  1226. {
  1227. CConfigureDlg dlg;
  1228. if(dlg.DoModal() == IDOK)
  1229. {
  1230. m_nLoginTimeOut = dlg.m_nLoginTimeOut;
  1231. m_nQueryTimeOut = dlg.m_nQueryTimeOut;
  1232. }
  1233. }
  1235. void CMainFrame::OnQueryOptions() 
  1236. {
  1237. CQueryOptionsDlg dlg;
  1238. if(dlg.DoModal() == IDOK)
  1239. m_nThreadPriority = GetThreadPriority(dlg.m_strThreadPriority);
  1240. }
  1242. int CMainFrame::GetThreadPriority(const CString& sPriority)
  1243. {
  1244. int nThreadPriority;
  1245. if(!sPriority.CompareNoCase(g_szTimeCritical))
  1246. nThreadPriority = THREAD_PRIORITY_TIME_CRITICAL;
  1247. else if(!sPriority.CompareNoCase(g_szHighest))
  1248. nThreadPriority = THREAD_PRIORITY_HIGHEST;
  1249. else if(!sPriority.CompareNoCase(g_szAboveNormal))
  1250. nThreadPriority = THREAD_PRIORITY_ABOVE_NORMAL;
  1251. else if(!sPriority.CompareNoCase(g_szNormal))
  1252. nThreadPriority = THREAD_PRIORITY_NORMAL;
  1253. else if(!sPriority.CompareNoCase(g_szBelowNormal))
  1254. nThreadPriority = THREAD_PRIORITY_BELOW_NORMAL;
  1255. else if(!sPriority.CompareNoCase(g_szLowest))
  1256. nThreadPriority = THREAD_PRIORITY_LOWEST;
  1257. else
  1258. nThreadPriority = THREAD_PRIORITY_NORMAL;
  1260. return nThreadPriority;
  1261. }
  1263. CMSFlexGrid* CMainFrame::GetGrid()
  1264. {
  1265. CResultView* pResultView = GetResultView();
  1266. ASSERT(pResultView);
  1267. CRect rect;
  1268. pResultView->GetWindowRect(&rect);
  1269. pResultView->ScreenToClient(rect);
  1270. CMSFlexGrid* pGridCtrl = new CMSFlexGrid();
  1271. ASSERT(pGridCtrl);
  1272. if(!pGridCtrl->Create(NULL, NULL, WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL,
  1273. rect, pResultView, m_nID++))
  1274. TRACE("Failed to create GridCtrl.n");
  1275. else
  1276. {
  1277. m_GridList.AddTail(pGridCtrl);
  1278. pGridCtrl->SetCols(0);
  1279. pGridCtrl->SetRows(1);
  1280. pGridCtrl->MoveWindow(rect);
  1281. pGridCtrl->SetBackColorBkg((unsigned long)RGB(255, 255, 255));
  1282. pGridCtrl->SetBorderStyle((unsigned long)0);
  1283. pGridCtrl->SetAllowUserResizing((long)1);
  1284. pGridCtrl->SetFocusRect((long)0);
  1285. pGridCtrl->SetHighLight((long)1);
  1286. pGridCtrl->ShowWindow(SW_HIDE);
  1287. }
  1289. return pGridCtrl;
  1290. }
  1292. void CMainFrame::SetGridHeaderInfo(CMSFlexGrid* pGrid, CRecordsetEx* pSet)
  1293. {
  1294. ASSERT(pGrid);
  1295. ASSERT(pSet);
  1297. CStringEx sBuff;
  1298. CODBCFieldInfo fieldInfo;
  1299. int nPrecision;
  1300. int nFieldLength;
  1301. int nArbitraryFactor = 110;
  1302. int nCols = pSet->GetODBCFieldCount();
  1303. UINT nMaxWidth = 32767;
  1304. pGrid->SetCols(nCols);
  1305. for(int n = 0; n < nCols; n++)
  1306. {
  1307. pSet->GetODBCFieldInfo(n, fieldInfo);
  1308. sBuff.Format("%s", (LPCTSTR)fieldInfo.m_strName);
  1309. nFieldLength = fieldInfo.m_strName.GetLength();
  1311. if(fieldInfo.m_nPrecision < (UDWORD)nFieldLength)
  1312. nPrecision = nFieldLength;
  1313. else if(fieldInfo.m_nPrecision > nMaxWidth)
  1314. nPrecision = nMaxWidth;
  1315. else
  1316. nPrecision = fieldInfo.m_nPrecision;
  1318. pGrid->SetColWidth(n, (nPrecision+fieldInfo.m_nScale)*nArbitraryFactor);
  1319. pGrid->SetTextMatrix(0, n, fieldInfo.m_strName);
  1320. }
  1321. }
  1323. void CMainFrame::OnUpdateCombo(CCmdUI* pCmdUI) 
  1324. {
  1325. pCmdUI->Enable(m_database.IsOpen() && m_bIsTSQLSupported && !m_bExecuting);
  1326. }
  1328. BOOL CMainFrame::SelectDatabase()
  1329. {
  1330. bool bRet = true;
  1332. if(m_pSet->IsOpen())
  1333. m_pSet->Close();
  1334. if(!m_pSet->ExecDirect(CString("select db_name() dbname")))
  1335. bRet = false;
  1336. else
  1337. {
  1338. if(!m_pSet->IsBOF())
  1339. {
  1340. m_pSet->GetFieldValue((short)0, m_strDBName);
  1341. m_comboBox.SelectString(-1, m_strDBName);
  1342. }
  1343. }
  1344. if(m_pSet->IsOpen())
  1345. m_pSet->Close();
  1347. return bRet;
  1348. }
  1350. LONG CMainFrame::OnExecutionComplete(UINT wParam, LONG lParam)
  1351. {
  1352. BOOL bCaughtException = wParam;
  1354. if(!bCaughtException && !m_bCanceled)
  1355. {
  1356. try
  1357. {
  1358. CString sBuff;
  1359. std::string sRow;
  1360. int nCols = m_pSet->GetODBCFieldCount();
  1361. int nTotalCols = 0;
  1362. long lRow = 0;
  1363. COleVariant vRow(lRow);
  1364. if(nCols)
  1365. {
  1366. nTotalCols += nCols;
  1367. CMSFlexGrid* pGridCtrl = GetGrid();
  1368. ASSERT(pGridCtrl);
  1369. SetGridHeaderInfo(pGridCtrl, m_pSet);
  1370. if(!m_bCanceled && !m_pSet->IsBOF())
  1371. {
  1372. while(!m_bCanceled && !m_pSet->IsEOF())
  1373. {
  1374. for(int n = 0; n < nCols; n++)
  1375. {
  1376. m_pSet->GetFieldValue(n, sBuff);
  1377. sRow += (const char*)sBuff;
  1378. sRow += "t";
  1379. }
  1381. pGridCtrl->AddItem(sRow.c_str(), (vRow = ++lRow));
  1382. sRow.erase();
  1384. m_pSet->MoveNext();
  1386. m_wndToolBar.Pump();
  1387. }
  1388. }
  1389. }
  1391. // while <::SQLMoreResults> loop. Also reset the cursor state
  1392. while(!m_bCanceled && m_pSet->FlushResultSet())
  1393. {   
  1394. // Clean up the old column info and build new one
  1395. m_pSet->AllocAndCacheFieldInfo();
  1396. nCols = m_pSet->GetODBCFieldCount();
  1397. lRow = 0;
  1398. if(nCols)
  1399. {
  1400. nTotalCols += nCols;
  1401. CMSFlexGrid* pGridCtrl = GetGrid();
  1402. ASSERT(pGridCtrl);
  1403. SetGridHeaderInfo(pGridCtrl, m_pSet);
  1404. if(!m_bCanceled && !m_pSet->IsBOF())
  1405. {
  1406. m_pSet->MoveNext();
  1408. while(!m_bCanceled && !m_pSet->IsEOF())
  1409. {     
  1410. for(int n = 0; n < nCols; n++)
  1411. {
  1412. m_pSet->GetFieldValue(n, sBuff);
  1413. sRow += (const char*)sBuff; 
  1414. sRow += "t";
  1415. }
  1417. pGridCtrl->AddItem(sRow.c_str(), (vRow = ++lRow));
  1418. sRow.erase();
  1420. m_pSet->MoveNext();
  1422. m_wndToolBar.Pump();
  1423. }
  1424. }
  1425. }
  1426. }
  1428. if(!m_bCanceled)
  1429. {
  1430. if(nTotalCols)
  1431. {
  1432. POSITION pos = m_GridList.FindIndex(m_nIndex);
  1433. DisplayResults((CMSFlexGrid*)m_GridList.GetAt(pos), ++m_nIndex);
  1434. }
  1435. else
  1436. {
  1437. if(m_bIsTSQLSupported)
  1438. m_strStatusText = GetRowCount("select @@rowcount") + " Row(s) affected";
  1439. else if(!m_strDBMS.CompareNoCase(m_strOracle))
  1440. m_strStatusText = GetRowCount("select SQL%ROWCOUNT from DUAL") + " Row(s) affected";
  1441. else
  1442. ;
  1443. OnExceptionClear("The command(s) completed successfully.");
  1444. }
  1445. }
  1446. }
  1447. catch(CDBException* e)
  1448. {
  1449.    bCaughtException = TRUE;
  1450.    
  1451.    if(e)
  1452.    {
  1453.    CString sMsg;
  1454.    if(e->m_strStateNativeOrigin.Find(g_szFunctionSequenceError) != -1)
  1455.    {
  1456.    m_bCanceled = TRUE;
  1457.    sMsg = "Query canceled by user.";
  1458.    m_strStatusText = "Canceled";
  1459.    }
  1460.    else
  1461.    {
  1462.    if(!e->m_strError.IsEmpty())
  1463.    sMsg.Format("%s%s", (LPCTSTR)e->m_strError, (LPCTSTR)e->m_strStateNativeOrigin);
  1464.    else
  1465.    sMsg = e->m_strStateNativeOrigin;
  1467.    m_strStatusText.Format("CDBException::m_nRetCode == %d", e->m_nRetCode);
  1468.    }
  1469.        
  1470.    OnExceptionClear(sMsg);
  1471.    
  1472.    e->Delete();
  1473.    }
  1474. }
  1475. catch(CMemoryException* e)
  1476. {
  1477. bCaughtException = TRUE;
  1479. m_strStatusText = "Out-of-memory";
  1480. OnExceptionClear(m_strStatusText);
  1482. if(e)
  1483. e->Delete();
  1484. }
  1485. catch(COleException* e)
  1486. {
  1487. bCaughtException = TRUE;
  1489. if(e)
  1490. {
  1491. TCHAR szMsg[255];
  1492. e->GetErrorMessage(szMsg, 255);
  1493. m_strStatusText = szMsg;
  1494. OnExceptionClear(m_strStatusText);
  1496. e->Delete();
  1497. }
  1498. }
  1499. catch(COleDispatchException* e)
  1500. {
  1501. if(e)
  1502. {
  1503. bCaughtException = TRUE;
  1505. m_strStatusText = e->m_strDescription;
  1506. OnExceptionClear(m_strStatusText);
  1508. e->Delete();
  1509. }
  1510. }
  1511. catch(...)
  1512. {
  1513. bCaughtException = TRUE;
  1515. if(!m_bCanceled)
  1516. {
  1517. m_strStatusText = "<Unknown error>";
  1518. OnExceptionClear(m_strStatusText);
  1519. }
  1520. }
  1521. }
  1523. if(m_bIsTSQLSupported && !m_bCanceled && !bCaughtException)
  1524. {
  1525. if(m_ThreadParam.m_strSQL.FindNoCase(_T("USE ")) != -1)
  1526. {
  1527. if(!SelectDatabase())
  1528. TRACE("Error selecting database context.n");
  1529. }
  1530. }
  1532. if(!m_bCanceled && m_pSet->IsOpen())
  1533. {
  1534. m_pSet->Close();
  1535. m_pSet->m_hstmt = NULL;
  1536. }
  1538. m_bExecuting = FALSE;
  1539. m_bCanceled = FALSE;
  1541. SetExecutionTime();
  1543. LONG lIdle = 0;
  1544. while(AfxGetApp()->OnIdle(lIdle++));
  1546. return 0L;
  1547. }
  1549. BOOL CMainFrame::IsSQLCancelSupported()
  1550. {
  1551. UWORD  bSQLCancelSupported;
  1552. ::SQLGetFunctions(m_database.m_hdbc, SQL_API_SQLCANCEL, &bSQLCancelSupported);
  1554. return bSQLCancelSupported;
  1555. }
  1557. BOOL CMainFrame::IsTextDataSource()
  1558. {
  1559. UCHAR buffer[200];
  1560. SWORD cbData;
  1561. ::SQLGetInfo(m_database.m_hdbc, SQL_DBMS_NAME, (PTR)buffer, 200, &cbData);
  1562. CString sBuff = buffer;
  1564. return !sBuff.CompareNoCase(g_szText);
  1565. }
  1567. CString CMainFrame::GetRowCount(const CString& sSQL)
  1568. {
  1569. CString sBuff;
  1571. if(m_pSet->IsOpen())
  1572. m_pSet->Close();
  1573. if(m_pSet->ExecDirect(sSQL))
  1574. {
  1575. if(!m_pSet->IsBOF())
  1576. m_pSet->GetFieldValue((short)0, sBuff);
  1577. }
  1578. if(m_pSet->IsOpen())
  1579. m_pSet->Close();
  1581. return sBuff;
  1582. }
  1584. void CMainFrame::SetExecutionTime()
  1585. {
  1586. DWORD dwDiff = ::GetTickCount() - m_dwStart;
  1587. COleDateTimeSpan span(0, 0, 0, dwDiff/1000);
  1588. m_strExecutionTime.Format("Execution Time: %02d:%02d:%02d.%03d",
  1589. span.GetHours(), span.GetMinutes(), span.GetSeconds(), dwDiff%1000);
  1590. }
  1592. BOOL CMainFrame::CloneProcess(const bool& bNewQuery)
  1593. {
  1594. STARTUPINFO si;
  1595. PROCESS_INFORMATION pi;
  1596. memset(&si, 0, sizeof(si));
  1597. si.cb = sizeof(si);
  1598. CString strCommandLine = CString(""") + theApp.m_pszExeName + CString("" ");
  1599. if(bNewQuery)
  1600. strCommandLine += m_database.GetConnect();
  1601. TRACE("%sn", (const char*)strCommandLine);
  1602. return ::CreateProcess(
  1603. NULL,
  1604. const_cast<LPTSTR>((LPCTSTR)strCommandLine),
  1605. NULL,
  1606. NULL,
  1607. FALSE,
  1608. 0,
  1609. NULL,
  1610. NULL,
  1611. &si,
  1612. &pi
  1613. );
  1614. }
  1616. void CMainFrame::OnQueryNew() 
  1617. {
  1618. if(!CloneProcess())
  1619. {
  1620. ::MessageBeep(MB_ICONEXCLAMATION);
  1621. AfxMessageBox("Error cloning <this> process.");
  1622. }
  1623. }
  1625. void CMainFrame::OnUpdateQueryNew(CCmdUI* pCmdUI) 
  1626. {
  1627. pCmdUI->Enable(m_database.IsOpen());
  1628. }
  1630. /////////////////////////////////////////////////////////////////////////////
  1631. // Helpers for saving/restoring window state
  1633. static TCHAR BASED_CODE szSection[] = _T("Settings");
  1634. static TCHAR BASED_CODE szWindowPos[] = _T("WindowPos");
  1635. static TCHAR szFormat[] = _T("%u,%u,%d,%d,%d,%d,%d,%d,%d,%d");
  1637. static BOOL PASCAL ReadWindowPlacement(LPWINDOWPLACEMENT pwp)
  1638. {
  1639. CWinApp* pApp = AfxGetApp();
  1641. CString strBuffer = pApp->GetProfileString(szSection, szWindowPos);
  1643. if(strBuffer.IsEmpty())
  1644. return FALSE;
  1646. WINDOWPLACEMENT wp;
  1647. int nRead = _stscanf(strBuffer, szFormat,
  1648. &wp.flags, &wp.showCmd,
  1649. &wp.ptMinPosition.x, &wp.ptMinPosition.y,
  1650. &wp.ptMaxPosition.x, &wp.ptMaxPosition.y,
  1651. &wp.rcNormalPosition.left, &wp.rcNormalPosition.top,
  1652. &wp.rcNormalPosition.right, &wp.rcNormalPosition.bottom);
  1654. if(nRead != 10)
  1655. return FALSE;
  1657. wp.length = sizeof(wp);
  1658. *pwp = wp;
  1660. return TRUE;
  1661. }
  1663. static void PASCAL WriteWindowPlacement(LPWINDOWPLACEMENT pwp)
  1664. {
  1665. TCHAR szBuffer[sizeof("-32767")*8 + sizeof("65535")*2];
  1667. wsprintf(szBuffer, szFormat,
  1668. pwp->flags, pwp->showCmd,
  1669. pwp->ptMinPosition.x, pwp->ptMinPosition.y,
  1670. pwp->ptMaxPosition.x, pwp->ptMaxPosition.y,
  1671. pwp->rcNormalPosition.left, pwp->rcNormalPosition.top,
  1672. pwp->rcNormalPosition.right, pwp->rcNormalPosition.bottom);
  1674. AfxGetApp()->WriteProfileString(szSection, szWindowPos, szBuffer);
  1675. }
  1677. /////////////////////////////////////////////////////////////////////////////
  1679. void CMainFrame::InitialShowWindow(UINT nCmdShow)
  1680. {
  1681. WINDOWPLACEMENT wp;
  1682. if(!ReadWindowPlacement(&wp))
  1683. CenterWindow();
  1684. else
  1685. {
  1686. if(nCmdShow != SW_SHOWNORMAL)
  1687. wp.showCmd = nCmdShow;
  1688. else
  1689. nCmdShow = wp.showCmd;
  1691. SetWindowPlacement(&wp);
  1692. }
  1694. ShowWindow(nCmdShow);
  1695. UpdateWindow();
  1696. }
  1698. void CMainFrame::OnClose() 
  1699. {
  1700. bool bOKToClose = true;
  1701. if(m_bExecuting)
  1702. {
  1703. ::MessageBeep(MB_ICONEXCLAMATION);
  1704. CString sMsg = "A query execution is in progress. Are you sure you wish to cancel?";
  1705. if(AfxMessageBox(sMsg, MB_YESNO) == IDNO)
  1706. bOKToClose = false;
  1707. else
  1708. {
  1709. if(m_pSet->m_hstmt)
  1710. {
  1711. m_strStatusText = "Canceling...";
  1712. m_wndStatusBar.SetPaneText(m_nResultSetPaneNo, m_strStatusText);
  1713. if(m_pSet->IsOpen())
  1714. m_pSet->Cancel();
  1715. m_bCanceled = TRUE;
  1716. m_bExecuting = FALSE;
  1717. m_strStatusText = "Canceled";
  1718. OnExceptionClear(CString("Query canceled."));
  1719. SetExecutionTime();
  1720. m_wndStatusBar.SetPaneText(m_nExecutionTimePaneNo, m_strExecutionTime);
  1721. }
  1722. }
  1723. }
  1725. if(bOKToClose)
  1726. {
  1727. WINDOWPLACEMENT wp;
  1728. wp.length = sizeof(wp);
  1729. if(GetWindowPlacement(&wp))
  1730. {
  1731. wp.flags = 0;
  1733. if(IsZoomed())
  1734. wp.flags |= WPF_RESTORETOMAXIMIZED;
  1736. if(wp.showCmd == SW_SHOWMINIMIZED)
  1737. ;
  1738. else
  1739. WriteWindowPlacement(&wp);
  1740. }
  1742. CFrameWnd::OnClose();
  1743. }
  1744. }