开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
GuiADODB.cpp
资源名称：clking_src.rar　[点击查看]
上传用户：zhanglf88
上传日期：2013-11-19
资源大小：6036k
文件大小：26k
源码类别：

金融证券系统

开发平台：

Visual C++

GuiADODB.cpp：源码内容
  1. //-----------------------------------------------------------------------//
  2. // This is a part of the GuiLib MFC Extention.  //
  3. // Autor  :  Francisco Campos  //
  4. // (C) 2002 Francisco Campos <www.beyondata.com> All rights reserved     //
  5. // This code is provided "as is", with absolutely no warranty expressed  //
  6. // or implied. Any use is at your own risk.  //
  7. // You must obtain the author's consent before you can include this code //
  8. // in a software library.  //
  9. // If the source code in  this file is used in any application  //
  10. // then acknowledgement must be made to the author of this program  //
  11. // fcampos@tutopia.com  //
  12. //-----------------------------------------------------------------------//
  14. #include "stdafx.h"
  15. #include "..headerguiadodb.h"
  17. //---------------------------------------------------------------------------------------
  19. CString GetError(_com_error &e)
  20. {
  21. CString MsgBug;
  22. _bstr_t Source(e.Source());
  23. _bstr_t Description(e.Description());
  24. MsgBug.Format( "Ups!!! nSource = %snDescription= %sn",(LPCSTR)Source, (LPCSTR)Description );
  25. #ifdef _DEBUG
  26. AfxMessageBox( MsgBug, MB_OK | MB_ICONERROR );
  27. #endif
  28. return MsgBug;
  29. }
  32. CString GetTypeVar(_variant_t vt)
  33. {
  34. switch(vt.vt)
  35. {
  36. case VT_EMPTY :
  37. return _T("VT_EMPTY");
  38. break;
  39. case   VT_NULL :
  40. return _T("VT_NULL");
  41. break;
  42. case VT_I2:
  43. return _T("int");
  44. break;
  45. case VT_I4 :
  46. return _T("long");
  47. break;
  48. case  VT_R4 :
  49. return _T("float");
  50. break;
  51. case VT_R8 :
  52. return _T("double");
  53. break;
  54. case VT_CY :
  55. return _T("currency");
  56. break;
  57. case VT_DATE:
  58. return _T("date");
  59. break;
  60. case  VT_BSTR :
  61. return _T("string");
  62. break;
  63. case VT_DISPATCH :
  64. return _T("dispatch");
  65. break;
  66. case  VT_ERROR :
  67. return _T("error");
  68. break;
  69. case VT_BOOL :
  70. return _T("bool");
  71. break;
  72. case VT_VARIANT :
  73. return _T("variant");
  74. break;
  75. case VT_UNKNOWN :
  76. return _T("unknown");
  77. break;
  78. case   VT_DECIMAL :
  79. return _T("decimal");
  80. break;
  81. default:
  82. return _T("");
  83. }
  84. }
  86. CGuiConnection::CGuiConnection(void)
  87. {
  88. ::CoInitialize(NULL);
  89. m_pConn.CreateInstance(__uuidof(Connection));
  91. }
  92. CGuiConnection::~CGuiConnection(void)
  93. {
  94. if (IsConnect())
  95. Close();
  96. m_pConn.Release();
  97. m_pConn = NULL;
  99. }
  101. BOOL CGuiConnection::Open(LPCTSTR ConnectionString,LPCTSTR UID,LPCTSTR PWD,long Options)
  102. {
  103.  HRESULT re;
  104.  try
  105. {
  106. re = m_pConn->Open(_bstr_t(ConnectionString), _bstr_t(UID), _bstr_t(PWD), NULL);
  107. return re == S_OK;
  108. }
  109. catch(_com_error &e)
  110. {
  111. GetError(e);
  112. return FALSE;
  113. }
  114.  
  115. }
  117. BOOL CGuiConnection::IsConnect()
  118. {
  119. return (BOOL) m_pConn->GetState() != adStateClosed;
  120. }
  124. CGuiRecordSet* CGuiConnection::Execute(LPCTSTR CommandText,long Options)
  125. {
  126. CGuiRecordSet* m_rs= new CGuiRecordSet();
  127. try{
  128. m_rs->Open(m_pConn,CommandText,adOpenUnspecified,adLockUnspecified, Options);
  129. }catch(_com_error &e)
  130. {
  131. GetError(e);
  132. return NULL;
  133. }
  134. return m_rs;
  135. }
  137. long CGuiConnection::BeginTrans()
  138. {
  139. return m_pConn->BeginTrans();
  140. }
  142. void CGuiConnection::RollbackTrans()
  143. {
  144. m_pConn->RollbackTrans();
  145. }
  147. void CGuiConnection::CommitTrans()
  148. {
  149. m_pConn->CommitTrans();
  150. }
  152. void CGuiConnection::Cancel()
  153. {
  154. m_pConn->Cancel();
  155. }
  157. void CGuiConnection::Close()
  158. {
  159. m_pConn->Close();
  160. }
  162. void CGuiConnection::SetConnectionTimeout(long ConnectionTimeout)
  163. {
  164. m_pConn->ConnectionTimeout=ConnectionTimeout;
  165. }
  167. void CGuiConnection::SetConectionString( LPCTSTR ConnectionString)
  168. {
  169. m_pConn->ConnectionString=ConnectionString;
  170. }
  172. long CGuiConnection::GetConnectionTimeout()
  173. {
  174. return m_pConn->ConnectionTimeout;
  175. }
  177. LPCTSTR CGuiConnection::GetConectionString()
  178. {
  179. return m_pConn->ConnectionString;
  180. }
  183. //***********************************************************************************************
  184. CGuiRecordSet::CGuiRecordSet(void)
  185. {
  186. ::CoInitialize(NULL);
  187. m_rs.CreateInstance(__uuidof(Recordset));
  188. m_Criteria=_T("");
  189. }
  190. CGuiRecordSet::~CGuiRecordSet(void)
  191. {
  192. Close();
  193. if (m_rs) m_rs->Release();
  194. m_rs=NULL;
  195. }
  196. void CGuiRecordSet::Attach(_RecordsetPtr m_prs ) { m_rs=m_prs; } BOOL CGuiRecordSet::Open(_ConnectionPtr ActiveConnection,LPCTSTR Source, CursorTypeEnum CursorType,ADOCG::LockTypeEnum LockType, long Options) { try
  197. {
  198. m_rs->Open(Source, _variant_t((IDispatch*)ActiveConnection, TRUE), 
  199. adOpenStatic, LockType, Options);
  200. }
  201. catch(_com_error &e)
  202. {
  203. GetError(e);
  204. return FALSE;
  205. }
  206. return TRUE; }
  209. BOOL CGuiRecordSet::FindFirst(LPCTSTR Criteria)
  210. {
  211. MoveFirst();
  212.     return Find(Criteria,0,adSearchForward,"");
  213. }
  215. void CGuiRecordSet::Move(long NumRecords , _variant_t Start) { m_rs->Move(NumRecords,vtMissing); }
  216. BOOL CGuiRecordSet::FindNext()
  217. {
  218. return Find(m_Criteria,1,adSearchForward,vtPointer);
  219. }
  222. BOOL CGuiRecordSet::Find(LPCTSTR Criteria , long SkipRecords ,   SearchDirectionEnum SearchDirection,_variant_t Start) { CString szCri=Criteria; if (!szCri.IsEmpty()) m_Criteria=Criteria; else return FALSE; try{ m_rs->Find(_bstr_t(Criteria),SkipRecords,SearchDirection,Start); if (SearchDirection ==adSearchForward) { if (!IsEof()) { vtPointer= m_rs->Bookmark; return TRUE; } }else if (SearchDirection ==adSearchBackward) { if (!IsBof()) { vtPointer= m_rs->Bookmark; return TRUE; } }else return FALSE; }catch(_com_error &e)
  223. {
  224. GetError(e);
  225. return FALSE;
  226. } return FALSE; }
  228. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,CString szCad)
  229. {
  230. _variant_t vt;
  231. if(!szCad.IsEmpty())
  232. {
  233. vt.vt = VT_BSTR;
  234. vt.bstrVal = szCad.AllocSysString();
  235. }
  237. return SetFieldValue(lpName, vt);
  238. }
  240. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,long lVal)
  241. {
  242. _variant_t vt;
  243. vt.lVal=lVal;
  244. vt.vt=VT_I4;
  245. return SetFieldValue(lpName, vt);
  246. }
  248. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,unsigned char usVal)
  249. {
  250. _variant_t vt;
  251. vt.bVal=usVal;
  252. vt.vt=VT_UI1;
  253. return SetFieldValue(lpName, vt);
  254. }
  256. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,short shVal)
  257. {
  258. _variant_t vt;
  259. vt.iVal=shVal;
  260. vt.vt=VT_I2;
  261. return SetFieldValue(lpName, vt);
  262. }
  264. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,float flVal)
  265. {
  266. _variant_t vt;
  267. vt.fltVal=flVal;
  268. vt.vt=VT_R4;
  269. return SetFieldValue(lpName, vt);
  270. }
  272. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,double dblVal)
  273. {
  274. _variant_t vt;
  275. vt.dblVal=dblVal;
  276. vt.vt=VT_R8;
  277. return SetFieldValue(lpName, vt);
  278. }
  280. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,BOOL blVal)
  281. {
  282. _variant_t vt;
  283. vt.boolVal=blVal;
  284. vt.vt=VT_BOOL;
  285. return SetFieldValue(lpName, vt);
  286. }
  288. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,COleDateTime dtVal)
  289. {
  290. _variant_t vt;
  291. vt.date=dtVal;
  292. vt.vt=VT_DATE;
  293. return SetFieldValue(lpName, vt);
  294. }
  296. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,unsigned long ulVal)
  297. {
  298. _variant_t vt;
  299. vt.vt = VT_UI4;
  300. vt.ulVal = ulVal;
  301. return SetFieldValue(lpName, vt);
  302. }
  304. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName, COleCurrency cuVal)
  305. {
  306. _variant_t vt;
  307. vt.vt = VT_CY;
  308. vt.cyVal = cuVal.m_cur;
  309. if(cuVal.m_status == COleCurrency::invalid)
  310. return FALSE;
  311. return SetFieldValue(lpName, vt);
  312. }
  314. BOOL CGuiRecordSet::SetFieldValue(LPCTSTR lpName, _variant_t vtField)
  315. {
  316. try
  317. {
  318. m_rs->Fields->GetItem(lpName)->Value = vtField; 
  319. return TRUE;
  320. }
  321. catch(_com_error &e)
  322. {
  323. GetError(e);
  324. return FALSE;
  325. }
  326. }
  329. CString CGuiRecordSet::GetCollect(LPCTSTR lpField)
  330. {
  331. try{
  332. _variant_t vt = m_rs->Fields->GetItem(lpField)->Value;
  333.  return (CString) vt.bstrVal;
  334. }
  335. catch(_com_error &e)
  336. {
  337. GetError(e);
  338. return _T("");
  339. }
  340.  
  341. }
  343. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,int& nValue)
  344. {
  345. _variant_t vt;
  346. try
  347. {
  348. vt = m_rs->Fields->GetItem(lpField)->Value;
  349. if (vt.vt==VT_I2)
  350. {
  351. nValue=vt.intVal;
  352. return TRUE;
  353. }else if (vt.vt==VT_BOOL)
  354. {
  355. nValue=vt.boolVal;
  356. return TRUE;
  357. }else return FALSE;
  358. }catch(_com_error &e)
  359. {
  360. GetError(e);
  361. return FALSE;
  362. }
  363. }
  364. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,long& lVal)
  365. {
  366. _variant_t vt;
  367. try
  368. {
  369. vt = m_rs->Fields->GetItem(lpField)->Value;
  370. if (vt.vt==VT_I4)
  371. {
  372. lVal=vt.lVal;
  373. return TRUE;
  374. }else return FALSE;
  375. }catch(_com_error &e)
  376. {
  377. GetError(e);
  378. return FALSE;
  379. }
  381. }
  382. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,double& dbVal)
  383. {
  384. _variant_t vt;
  385. try
  386. {
  387. vt = m_rs->Fields->GetItem(lpField)->Value;
  388. if (vt.vt==VT_R8)
  389. {
  390. dbVal=vt.dblVal;
  391. return TRUE;
  392. }else return FALSE;
  393. }catch(_com_error &e)
  394. {
  395. GetError(e);
  396. return FALSE;
  397. }
  398. }
  399. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,CString& strValue)
  400. {
  401. _variant_t vt;
  402. try
  403. {
  404. vt = m_rs->Fields->GetItem(lpField)->Value;
  405. if (vt.vt==VT_BSTR)
  406. {
  407. strValue=vt.bstrVal;
  408. return TRUE;
  409. }else return FALSE;
  410. }catch(_com_error &e)
  411. {
  412. GetError(e);
  413. return FALSE;
  414. }
  415. }
  418. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,COleCurrency& cyVal)
  419. {
  420. _variant_t vt;
  421. vt = m_rs->Fields->GetItem(lpField)->Value;
  423. try
  424. {
  425. if (vt.vt==VT_CY)
  426. {
  427. cyVal.m_cur=vt.cyVal;
  428. return TRUE;
  429. }else return FALSE;
  430. }catch(_com_error &e)
  431. {
  432. GetError(e);
  433. return FALSE;
  434. }
  436. }
  438. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,COleDateTime& dtVal)
  439. {
  440. _variant_t vt;
  441. try
  442. {
  443. vt = m_rs->Fields->GetItem(lpField)->Value;
  444. if (vt.vt==VT_DATE)
  445. {
  446. dtVal=vt.date;
  447. return TRUE;
  448. }else return FALSE;
  449. }catch(_com_error &e)
  450. {
  451. GetError(e);
  452. return FALSE;
  453. }
  454. }
  455. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,float& flVal)
  456. {
  457. _variant_t vt;
  458. try
  459. {
  460. vt = m_rs->Fields->GetItem(lpField)->Value;
  461. if (vt.vt==VT_R4)
  462. {
  463. flVal=vt.fltVal;
  464. return TRUE;
  465. }else return FALSE;
  466. }catch(_com_error &e)
  467. {
  468. GetError(e);
  469. return FALSE;
  470. }
  471. }
  473. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,_variant_t& vt)
  474. {
  475. try
  476. {
  477. vt = m_rs->Fields->GetItem(lpField)->Value;
  478. return TRUE;
  479. }
  480. catch(_com_error& e)
  481. {
  482. GetError(e);
  483. return FALSE;
  484. }
  485. }
  487. BOOL CGuiRecordSet::GetCollect(int nIndex,int& nValue)
  488. {
  489. _variant_t vt;
  490. _variant_t vtn;
  491. vtn.vt = VT_I2;
  492. try
  493. {
  494. vtn.iVal = nIndex;
  495. vt = m_rs->Fields->GetItem(vtn)->Value;
  496. if (vt.vt==VT_I2)
  497. {
  498. nValue=vt.intVal;
  499. return TRUE;
  500. }else return FALSE;
  501. }catch(_com_error &e)
  502. {
  503. GetError(e);
  504. return FALSE;
  505. }
  507. }
  509. BOOL CGuiRecordSet::GetCollect(int nIndex,long& lVal)
  510. {
  511. _variant_t vt;
  512. _variant_t vtn;
  513. vtn.vt = VT_I2;
  514. try
  515. {
  516. vtn.iVal = nIndex;
  517. vt = m_rs->Fields->GetItem(vtn)->Value;
  518. if (vt.vt==VT_I4)
  519. {
  520. lVal=vt.lVal;
  521. return TRUE;
  522. }else return FALSE;
  523. }catch(_com_error &e)
  524. {
  525. GetError(e);
  526. return FALSE;
  527. }
  529. }
  531. BOOL CGuiRecordSet::GetCollect(int nIndex,double& dbVal)
  532. {
  533. _variant_t vt;
  534. _variant_t vtn;
  535. vtn.vt = VT_I2;
  536. try
  537. {
  538. vtn.iVal = nIndex;
  539. vt = m_rs->Fields->GetItem(vtn)->Value;
  540. if (vt.vt==VT_R8)
  541. {
  542. dbVal=vt.dblVal;
  543. return TRUE;
  544. }else return FALSE;
  545. }catch(_com_error &e)
  546. {
  547. GetError(e);
  548. return FALSE;
  549. }
  550. }
  552. BOOL CGuiRecordSet::GetCollect(int nIndex,CString& strValue)
  553. {
  554. _variant_t vt;
  555. _variant_t vtn;
  556. vtn.vt = VT_I2;
  557. try
  558. {
  559. vtn.iVal = nIndex;
  560. vt = m_rs->Fields->GetItem(vtn)->Value;
  561. if (vt.vt==VT_BSTR)
  562. {
  563. strValue=vt.bstrVal;
  564. return TRUE;
  565. }else return FALSE;
  566. }catch(_com_error &e)
  567. {
  568. GetError(e);
  569. return FALSE;
  570. }
  571. }
  573. BOOL CGuiRecordSet::GetCollect(int nIndex,COleCurrency& cyVal)
  574. {
  575. _variant_t vt;
  576. _variant_t vtn;
  577. vtn.vt = VT_CY;
  578. try
  579. {
  580. vtn.iVal =nIndex;
  581. vt = m_rs->Fields->GetItem(vtn)->Value;
  582. if (vt.vt==VT_CY)
  583. {
  584. cyVal.m_cur=vt.cyVal;
  585. return TRUE;
  586. }else return FALSE;
  587. }catch(_com_error &e)
  588. {
  589. GetError(e);
  590. return FALSE;
  591. }
  593. }
  595. BOOL CGuiRecordSet::GetCollect(int nIndex,COleDateTime& dtVal)
  596. {
  597. _variant_t vt;
  598. _variant_t vtn;
  599. vtn.vt = VT_I2;
  600. try
  601. {
  602. vtn.iVal = nIndex;
  603. vt = m_rs->Fields->GetItem(vtn)->Value;
  604. if (vt.vt==VT_DATE)
  605. {
  606. dtVal=vt.date;
  607. return TRUE;
  608. }else return FALSE;
  609. }catch(_com_error &e)
  610. {
  611. GetError(e);
  612. return FALSE;
  613. }
  615. }
  617. BOOL CGuiRecordSet::GetFormatDate(LPCTSTR lpField,CString& m_szDate, CString Format)
  618. {
  619. COleDateTime time;
  620. if (!GetCollect(lpField,time)) return FALSE;
  621. CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
  622. m_szDate =ct.Format(Format);
  623. return TRUE;
  624. }
  626. BOOL CGuiRecordSet::GetFormatDate(int nIndex,CString& m_szDate, CString Format)
  627. {
  628. COleDateTime time;
  629. if (!GetCollect(nIndex,time)) return FALSE;
  630. CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
  631. m_szDate =ct.Format(Format);
  632. return TRUE;
  633. }
  635. BOOL CGuiRecordSet::GetCollect(int nIndex,float& flVal)
  636. {
  637. _variant_t vt;
  638. _variant_t vtn;
  639. vtn.vt = VT_I2;
  640. try
  641. {
  642. vtn.iVal = nIndex;
  643. vt = m_rs->Fields->GetItem(vtn)->Value;
  644. if (vt.vt==VT_R4)
  645. {
  646. flVal=vt.fltVal;
  647. return TRUE;
  648. }else return FALSE;
  649. }catch(_com_error &e)
  650. {
  651. GetError(e);
  652. return FALSE;
  653. }
  655. }
  659. BOOL CGuiRecordSet::GetCollect(int nIndex,_variant_t& vt)
  660. {
  662. _variant_t vtn;
  663. vtn.vt = VT_I2;
  664. try
  665. {
  666. vtn.iVal = nIndex;
  667. vt = m_rs->Fields->GetItem(vtn)->Value;
  668. return TRUE;
  669. }
  670. catch(_com_error& e)
  671. {
  672. GetError(e);
  673. return FALSE;
  674. }
  675. }
  680. BOOL CGuiRecordSet::SetFilter(LPCTSTR lpFilter)
  681. {
  682. if (!IsOpen()) return FALSE;
  683. try
  684. {
  685. m_rs->PutFilter(lpFilter);
  686. return TRUE;
  687. }
  688. catch(_com_error &e)
  689. {
  690. GetError(e);
  691. return FALSE;
  692. }
  693. }
  695. BOOL CGuiRecordSet::SetSort(LPCTSTR lpSort)
  696. {
  697. if (!IsOpen()) return FALSE;
  698. try
  699. {
  700. m_rs->PutSort(lpSort);
  701. return TRUE;
  702. }
  703. catch(_com_error &e)
  704. {
  705. GetError(e);
  706. return FALSE;
  707. }
  708. }
  711. BOOL CGuiRecordSet::IsOpen()
  712. {
  713. if(m_rs)
  714. return m_rs-> GetState() != adStateClosed;
  715. return FALSE;
  716. }
  718. void CGuiRecordSet::Close()
  719. {
  720. if(IsOpen())
  721. m_rs->Close();
  723. }
  726. void CGuiRecordSet::MoveFirst()
  727. {
  728. m_rs->MoveFirst();
  729. }
  731. void CGuiRecordSet::MoveLast()
  732. {
  733. m_rs->MoveLast();
  734. }
  736. void CGuiRecordSet::MoveNext()
  737. {
  738. m_rs->MoveNext();
  739. }
  741. void CGuiRecordSet::MovePrevious()
  742. {
  743. m_rs->MovePrevious();
  744. }
  746. void CGuiRecordSet::Cancel()
  747. {
  748.    m_rs->Cancel();
  749. }
  751. void CGuiRecordSet::CancelUpdate()
  752. {
  753.   m_rs->CancelUpdate();
  754. }
  756. BOOL CGuiRecordSet::Delete()
  757. {
  758. try{
  759. if(m_rs->Delete(adAffectCurrent)== S_OK)
  760. if(m_rs->Update() ==S_OK)
  761. return TRUE;
  762. }catch(_com_error &e)
  763. {
  764. GetError(e);
  765. return FALSE;
  766. }
  767. return FALSE;
  768. }
  770. BOOL CGuiRecordSet::IsEof()
  771. {
  772. return (BOOL)m_rs->EndOfFile;
  773. }
  774. BOOL CGuiRecordSet::IsBof()
  775. {
  776. return (BOOL)m_rs->BOF;
  777. }
  778. BOOL CGuiRecordSet::Supports( CursorOptionEnum CursorOptions )  {   return (BOOL)m_rs->Supports(CursorOptions); }
  779. void CGuiRecordSet::CancelBatch(AffectEnum AffectRecords) {   m_rs->CancelBatch(AffectRecords); } CGuiField CGuiRecordSet::GetField(LPCTSTR lpField)
  780. {
  781. FieldPtr pField = m_rs->Fields->GetItem(lpField);
  782. CGuiField Field;
  783. Field.Attach(pField);
  784. return Field;
  785. }
  786. CGuiField CGuiRecordSet::GetField(int Index) { _variant_t vtIndex;
  787. vtIndex.vt = VT_I2;
  788. vtIndex.iVal = Index;
  789. FieldPtr pField = m_rs->Fields->GetItem(vtIndex); CGuiField Field;
  790. Field.Attach(pField);
  791. return Field; } CGuiRecordSet*  CGuiRecordSet::Clone(ADOCG::LockTypeEnum LockType) { _RecordsetPtr m_rs1=m_rs->Clone(LockType); CGuiRecordSet* m_pRs= new CGuiRecordSet(); m_pRs->Attach(m_rs1); return m_pRs;  } CGuiRecordSet* CGuiRecordSet::NextRecordset(long RecordsAffected)  { _RecordsetPtr m_rs1=m_rs->NextRecordset((VARIANT*)RecordsAffected); CGuiRecordSet* m_pRs= new CGuiRecordSet(); m_pRs->Attach(m_rs1); return m_pRs;  }
  792. //***********************************************************************************************************
  793. CGuiField::CGuiField(void)
  794. {
  795. }
  796. CGuiField::~CGuiField(void)
  797. {
  798. }
  799. BOOL CGuiField::SetValue(long lVal)
  800. {
  801. _variant_t vt;
  802. vt.lVal=lVal;
  803. vt.vt=VT_I4;
  804. try
  805. {
  806. field->Value=vt;
  807. return TRUE;
  808. }catch(_com_error &e)
  809. {
  810. GetError(e);
  811. return FALSE;
  812. }
  814. }
  818. BOOL CGuiField::SetValue(float flVal)
  819. {
  820. _variant_t vt;
  821. vt.fltVal=flVal;
  822. vt.vt=VT_R4;
  823. try
  824. {
  825. field->Value=vt;
  826. return TRUE;
  827. }catch(_com_error &e)
  828. {
  829. GetError(e);
  830. return FALSE;
  831. }
  832. }
  835. BOOL CGuiField::SetValue(int nVal)
  836. {
  837. _variant_t vt;
  838. vt.intVal=nVal;
  839. vt.vt=VT_I2;
  840. try
  841. {
  842. field->Value=vt;
  843. return TRUE;
  844. }catch(_com_error &e)
  845. {
  846. GetError(e);
  847. return FALSE;
  848. }
  851. }
  853. BOOL CGuiField::SetValue(double dbVal)
  854. {
  855. _variant_t vt;
  856. vt.dblVal=dbVal;
  857. vt.vt=VT_R8;
  859. try
  860. {
  861. field->Value=vt;
  862. return TRUE;
  863. }catch(_com_error &e)
  864. {
  865. GetError(e);
  866. return FALSE;
  867. }
  869. }
  871. BOOL CGuiField::SetValue(CString szCad)
  872. {
  873. _variant_t vt;
  874. if(!szCad.IsEmpty())
  875. {
  876. vt.vt = VT_BSTR;
  877. vt.bstrVal = szCad.AllocSysString();
  878. }
  879. try
  880. {
  881. field->Value=vt;
  882. return TRUE;
  883. }catch(_com_error &e)
  884. {
  885. GetError(e);
  886. return FALSE;
  887. }
  890. }
  893. BOOL CGuiField::SetValue(bool blVal)
  894. {
  895. _variant_t vt;
  896. vt.boolVal=blVal;
  897. vt.vt=VT_BOOL;
  898. try
  899. {
  900. field->Value=vt;
  901. return TRUE;
  902. }catch(_com_error &e)
  903. {
  904. GetError(e);
  905. return FALSE;
  906. }
  907. }
  910. BOOL CGuiField::SetValue(COleDateTime dtVal)
  911. {
  912. _variant_t vt;
  913. vt.date=dtVal;
  914. vt.vt=VT_DATE;
  915. try
  916. {
  917. field->Value=vt;
  918. return TRUE;
  919. }catch(_com_error &e)
  920. {
  921. GetError(e);
  922. return FALSE;
  923. }
  925. }
  927. BOOL CGuiField::SetValue(_variant_t vt)
  928. {
  929. try
  930. {
  931. field->Value=vt;
  932. return TRUE;
  933. }catch(_com_error &e)
  934. {
  935. GetError(e);
  936. return FALSE;
  937. }
  939. }
  941. BOOL CGuiField::GetValue(int& nVal)
  942. {
  943. _variant_t vt;
  944. vt = field->Value;
  945. try
  946. {
  947. if (vt.vt==VT_I2)
  948. {
  949. nVal=vt.intVal;
  950. return TRUE;
  951. }else if (vt.vt==VT_BOOL)
  952. {
  953. nVal=vt.boolVal;
  954. return TRUE;
  955. }else return FALSE;
  956. }catch(_com_error &e)
  957. {
  958. GetError(e);
  959. return FALSE;
  960. }
  962. }
  964. BOOL CGuiField::GetValue(long& lVal)
  965. {
  966. _variant_t vt;
  967. vt = field->Value;
  968. try
  969. {
  970. if (vt.vt==VT_I4)
  971. {
  972. lVal=vt.lVal;
  973. return TRUE;
  974. }else return FALSE;
  975. }catch(_com_error &e)
  976. {
  977. GetError(e);
  978. return FALSE;
  979. }
  981. }
  983. BOOL CGuiField::GetValue(double& dbVal)
  984. {
  985. _variant_t vt;
  986. vt = field->Value;
  987. try
  988. {
  989. if (vt.vt==VT_R8)
  990. {
  991. dbVal=vt.dblVal;
  992. return TRUE;
  993. }else return FALSE;
  994. }catch(_com_error &e)
  995. {
  996. GetError(e);
  997. return FALSE;
  998. }
  999. }
  1001. BOOL CGuiField::GetValue(CString& strValue)
  1002. {
  1003. _variant_t vt;
  1004. vt =field->Value;
  1006. try
  1007. {
  1008. if (vt.vt==VT_BSTR)
  1009. {
  1010. strValue=vt.bstrVal;
  1011. return TRUE;
  1012. }else return FALSE;
  1013. }catch(_com_error &e)
  1014. {
  1015. GetError(e);
  1016. return FALSE;
  1017. }
  1018. }
  1020. BOOL CGuiField::GetValue(COleDateTime& dtVal)
  1021. {
  1022. _variant_t vt;
  1023. vt = field->Value;
  1024. try
  1025. {
  1026. if (vt.vt==VT_DATE)
  1027. {
  1028. dtVal=vt.date;
  1029. return TRUE;
  1030. }else return FALSE;
  1031. }catch(_com_error &e)
  1032. {
  1033. GetError(e);
  1034. return FALSE;
  1035. }
  1037. }
  1039. BOOL CGuiField::GetValue(float& flVal)
  1040. {
  1041. _variant_t vt;
  1042. vt = field->Value;
  1043. try
  1044. {
  1045. if (vt.vt==VT_R4)
  1046. {
  1047. flVal=vt.fltVal;
  1048. return TRUE;
  1049. }else return FALSE;
  1050. }catch(_com_error &e)
  1051. {
  1052. GetError(e);
  1053. return FALSE;
  1054. }
  1056. }
  1060. BOOL CGuiField::GetValue(_variant_t& vt)
  1061. {
  1062. try
  1063. {
  1064. _variant_t vt = field->Value;
  1065. return TRUE;
  1066. }
  1067. catch(_com_error& e)
  1068. {
  1069. GetError(e);
  1070. return FALSE;
  1071. }
  1072. }
  1075. //***********************************************************************************************************
  1077. CGuiParameter::CGuiParameter()
  1078. {
  1079. ::CoInitialize(NULL);
  1080. pParam.CreateInstance(__uuidof(Parameter));
  1081. }
  1083. CGuiParameter::~CGuiParameter()
  1084. {
  1085. pParam->Release();
  1086. pParam=NULL;
  1087. }
  1090. void CGuiParameter::SetAttributes(long Attributes)
  1091. {
  1092. pParam->PutAttributes(Attributes);
  1093. }
  1095. void CGuiParameter::SetDirection(ADOCG::ParameterDirectionEnum Direction)
  1096. {
  1097. pParam->PutDirection(Direction);
  1098. }
  1100. void CGuiParameter::SetName(LPCTSTR szName)
  1101. {
  1102. CString mszname=szName;
  1103. pParam->Name=mszname.AllocSysString();
  1105. }
  1107. void CGuiParameter::SetNumericScale(unsigned char NumericScale)
  1108. {
  1109. pParam->PutNumericScale(NumericScale);
  1110. }
  1112. void CGuiParameter::SetPrecision(unsigned char Precision)
  1113. {
  1114. pParam->PutPrecision(Precision);
  1115. }
  1117. void CGuiParameter::SetSize(long Size)
  1118. {
  1119. pParam->PutSize(Size);
  1120. }
  1122. void CGuiParameter::SetType(ADOCG::DataTypeEnum Type)
  1123. {
  1124. pParam->PutType(Type);
  1125. }
  1127. BOOL CGuiParameter::SetValue(long lVal)
  1128. {
  1129. _variant_t vt;
  1130. vt.lVal=lVal;
  1131. vt.vt=VT_I4;
  1132. try
  1133. {
  1134. pParam->Value=vt;
  1135. return TRUE;
  1136. }catch(_com_error &e)
  1137. {
  1138. GetError(e);
  1139. return FALSE;
  1140. }
  1142. }
  1146. BOOL CGuiParameter::SetValue(float flVal)
  1147. {
  1148. _variant_t vt;
  1149. vt.fltVal=flVal;
  1150. vt.vt=VT_R4;
  1151. try
  1152. {
  1153. pParam->Value=vt;
  1154. return TRUE;
  1155. }catch(_com_error &e)
  1156. {
  1157. GetError(e);
  1158. return FALSE;
  1159. }
  1160. }
  1163. BOOL CGuiParameter::SetValue(int nVal)
  1164. {
  1165. _variant_t vt;
  1166. vt.intVal=nVal;
  1167. vt.vt=VT_I2;
  1168. try
  1169. {
  1170. pParam->Value=vt;
  1171. return TRUE;
  1172. }catch(_com_error &e)
  1173. {
  1174. GetError(e);
  1175. return FALSE;
  1176. }
  1179. }
  1181. BOOL CGuiParameter::SetValue(double dbVal)
  1182. {
  1183. _variant_t vt;
  1184. vt.dblVal=dbVal;
  1185. vt.vt=VT_R8;
  1187. try
  1188. {
  1189. pParam->Value=vt;
  1190. return TRUE;
  1191. }catch(_com_error &e)
  1192. {
  1193. GetError(e);
  1194. return FALSE;
  1195. }
  1197. }
  1199. BOOL CGuiParameter::SetValue(CString szCad)
  1200. {
  1201. _variant_t vt;
  1202. if(!szCad.IsEmpty())
  1203. {
  1204. vt.vt = VT_BSTR;
  1205. vt.bstrVal = szCad.AllocSysString();
  1206. }
  1207. try
  1208. {
  1209. pParam->Value=vt;
  1210. return TRUE;
  1211. }catch(_com_error &e)
  1212. {
  1213. GetError(e);
  1214. return FALSE;
  1215. }
  1218. }
  1221. BOOL CGuiParameter::SetValue(bool blVal)
  1222. {
  1223. _variant_t vt;
  1224. vt.boolVal=blVal;
  1225. vt.vt=VT_BOOL;
  1226. try
  1227. {
  1228. pParam->Value=vt;
  1229. return TRUE;
  1230. }catch(_com_error &e)
  1231. {
  1232. GetError(e);
  1233. return FALSE;
  1234. }
  1235. }
  1238. BOOL CGuiParameter::SetValue(COleDateTime dtVal)
  1239. {
  1240. _variant_t vt;
  1241. vt.date=dtVal;
  1242. vt.vt=VT_DATE;
  1243. try
  1244. {
  1245. pParam->Value=vt;
  1246. return TRUE;
  1247. }catch(_com_error &e)
  1248. {
  1249. GetError(e);
  1250. return FALSE;
  1251. }
  1253. }
  1255. BOOL CGuiParameter::SetValue(_variant_t vt)
  1256. {
  1257. try
  1258. {
  1259. pParam->Value=vt;
  1260. return TRUE;
  1261. }catch(_com_error &e)
  1262. {
  1263. GetError(e);
  1264. return FALSE;
  1265. }
  1267. }
  1269. BOOL CGuiParameter::GetValue(int& nVal)
  1270. {
  1271. _variant_t vt;
  1272. vt = pParam->Value;
  1273. try
  1274. {
  1275. if (vt.vt==VT_I2)
  1276. {
  1277. nVal=vt.intVal;
  1278. return TRUE;
  1279. }else if (vt.vt==VT_BOOL)
  1280. {
  1281. nVal=vt.boolVal;
  1282. return TRUE;
  1283. }else return FALSE;
  1284. }catch(_com_error &e)
  1285. {
  1286. GetError(e);
  1287. return FALSE;
  1288. }
  1290. }
  1292. BOOL CGuiParameter::GetValue(long& lVal)
  1293. {
  1294. _variant_t vt;
  1295. vt = pParam->Value;
  1296. try
  1297. {
  1298. if (vt.vt==VT_I4)
  1299. {
  1300. lVal=vt.lVal;
  1301. return TRUE;
  1302. }if (vt.vt==VT_BSTR)
  1303. {
  1304. CString cad=vt.bstrVal;
  1305. lVal=atol(cad);
  1306. return TRUE;
  1307. }
  1308. else return FALSE;
  1309. }catch(_com_error &e)
  1310. {
  1311. GetError(e);
  1312. return FALSE;
  1313. }
  1315. }
  1317. BOOL CGuiParameter::SetValue(COleCurrency cyVal)
  1318. {
  1319. _variant_t vt;
  1320. vt.cyVal=cyVal.m_cur;
  1321. vt.vt=VT_CY;
  1322. try
  1323. {
  1324. pParam->Value=vt;
  1325. return TRUE;
  1326. }catch(_com_error &e)
  1327. {
  1328. GetError(e);
  1329. return FALSE;
  1330. }
  1332. }
  1334. BOOL CGuiParameter::GetValue(double& dbVal)
  1335. {
  1336. _variant_t vt;
  1337. vt = pParam->Value;
  1338. try
  1339. {
  1340. if (vt.vt==VT_R8)
  1341. {
  1342. dbVal=vt.dblVal;
  1343. return TRUE;
  1344. }else return FALSE;
  1345. }catch(_com_error &e)
  1346. {
  1347. GetError(e);
  1348. return FALSE;
  1349. }
  1350. }
  1352. BOOL CGuiParameter::GetValue(CString& strValue)
  1353. {
  1354. _variant_t vt;
  1355. vt =pParam->Value;
  1357. try
  1358. {
  1359. if (vt.vt==VT_BSTR)
  1360. {
  1361. strValue=vt.bstrVal;
  1362. return TRUE;
  1363. }else return FALSE;
  1364. }catch(_com_error &e)
  1365. {
  1366. GetError(e);
  1367. return FALSE;
  1368. }
  1369. }
  1371. BOOL CGuiParameter::GetValue(COleDateTime& dtVal)
  1372. {
  1373. _variant_t vt;
  1374. vt = pParam->Value;
  1375. try
  1376. {
  1377. if (vt.vt==VT_DATE)
  1378. {
  1379. dtVal=vt.date;
  1380. return TRUE;
  1381. }else return FALSE;
  1382. }catch(_com_error &e)
  1383. {
  1384. GetError(e);
  1385. return FALSE;
  1386. }
  1388. }
  1390. BOOL CGuiParameter::GetValue(COleCurrency& cyVal)
  1391. {
  1392. _variant_t vt;
  1393. vt = pParam->Value;
  1395. try
  1396. {
  1397. if (vt.vt==VT_CY)
  1398. {
  1399. cyVal.m_cur=vt.cyVal;
  1400. return TRUE;
  1401. }else return FALSE;
  1402. }catch(_com_error &e)
  1403. {
  1404. GetError(e);
  1405. return FALSE;
  1406. }
  1408. }
  1411. BOOL CGuiParameter::GetFormatDate(CString& m_szDate, CString Format)
  1412. {
  1413. COleDateTime time;
  1414. if (!GetValue(time)) return FALSE;
  1415. CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
  1416. m_szDate =ct.Format(Format);
  1417. return TRUE;
  1418. }
  1422. BOOL CGuiParameter::GetValue(float& flVal)
  1423. {
  1424. _variant_t vt;
  1425. vt = pParam->Value;
  1426. try
  1427. {
  1428. if (vt.vt==VT_R4)
  1429. {
  1430. flVal=vt.fltVal;
  1431. return TRUE;
  1432. }else return FALSE;
  1433. }catch(_com_error &e)
  1434. {
  1435. GetError(e);
  1436. return FALSE;
  1437. }
  1439. }
  1443. BOOL CGuiParameter::GetValue(_variant_t& vt)
  1444. {
  1445. try
  1446. {
  1447. _variant_t vt = pParam->Value;
  1448. return TRUE;
  1449. }
  1450. catch(_com_error& e)
  1451. {
  1452. GetError(e);
  1453. return FALSE;
  1454. }
  1455. }
  1458. //----------------------------------------------------------------------------------------------
  1460. CGuiCommand::CGuiCommand()
  1461. {
  1462. ::CoInitialize(NULL);
  1463. pCommand.CreateInstance(__uuidof(Command));
  1465. }
  1467. CGuiCommand::~CGuiCommand()
  1468. {
  1469. Cancel();
  1470. pCommand->Release();
  1471. pCommand=NULL;
  1472. }
  1475. void CGuiCommand::SetActiveConnection(LPCTSTR szconnec)
  1476. {
  1477. m_pCon.Open(szconnec);
  1478. ASSERT( m_pCon.IsConnect());
  1479. SetActiveConnection(&m_pCon);
  1480. }
  1482. void CGuiCommand::SetActiveConnection(CGuiConnection* pCon)
  1483. {
  1484. ASSERT(pCon->IsConnect());
  1485. pCommand->ActiveConnection=pCon->GetConecction();
  1486. }
  1488. void CGuiCommand::Cancel()
  1489. {
  1490. pCommand->Cancel();
  1491. } 
  1493. void CGuiCommand::SetCommandText(LPCTSTR lpCommand,CommandTypeEnum cmdType)
  1494. {
  1495. CString szCommand=lpCommand;
  1496. pCommand->CommandText=szCommand.AllocSysString();
  1497. pCommand->PutCommandType(cmdType);
  1498. }
  1500. void CGuiCommand::SetCommandTimeout(long CommandTimeout)
  1501. {
  1502. pCommand->PutCommandTimeout(CommandTimeout);
  1503. }
  1505. void CGuiCommand::SetPrepared(BOOL prepared)
  1506. {
  1507. pCommand->PutPrepared((BOOL) prepared);
  1508. }
  1510. long CGuiCommand::GetState()
  1511. {
  1512. return pCommand->GetState();
  1513. }
  1515. CGuiRecordSet* CGuiCommand::Execute(VARIANT* param1,VARIANT* param2,long Options)
  1516. {
  1517. try
  1518. {
  1519. _RecordsetPtr m_rs = pCommand->Execute(NULL, NULL, Options);
  1520. CGuiRecordSet* m_prs= new CGuiRecordSet();
  1521. m_prs->Attach(m_rs);
  1522. return m_prs;
  1523. }
  1524. catch(_com_error &e)
  1525. {
  1526. GetError(e);
  1527. return NULL;
  1528. }
  1530. }
  1532. CGuiParameter* CGuiCommand::CreateParameter(CString Name ,long Size ,
  1533. ADOCG::DataTypeEnum Type, 
  1534. ADOCG::ParameterDirectionEnum Direction)
  1535. {
  1536. _ParameterPtr param=pCommand->CreateParameter(Name.AllocSysString(), Type,Direction, Size);
  1538. CGuiParameter* pParam=new CGuiParameter();
  1539. pParam->Attach(param);
  1540. return pParam;
  1541. }
  1543. BOOL CGuiCommand::Append(CGuiParameter* pParam)
  1544. {
  1545. try
  1546. {
  1547. pCommand->Parameters->Append(pParam->GetParameter());
  1548. return TRUE;
  1549. }
  1550. catch(_com_error& e)
  1551. {
  1552. GetError(e);
  1553. return FALSE;
  1554. }
  1556. }