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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网格计算 > 查看源码
GuiADODB.cpp
资源名称：fmailstable.rar　[点击查看]
上传用户：maryhy001
上传日期：2007-05-02
资源大小：2317k
文件大小：28k
源码类别：

网格计算

开发平台：

Visual C++

GuiADODB.cpp：源码内容
  1. /****************************************************************************
  2.  * *  
  3.  * GuiToolKit   *
  4.  *  (MFC extension) *  
  5.  * Created by Francisco Campos G. www.beyondata.com fcampos@beyondata.com *
  6.  *--------------------------------------------------------------------------*    
  7.  * *
  8.  * This program is free software;so you are free to use it any of your *
  9.  * applications (Freeware, Shareware, Commercial),but leave this header *
  10.  * intact. *
  11.  * *
  12.  * These files are provided "as is" without warranty of any kind. *
  13.  * *
  14.  *        GuiToolKit is forever FREE CODE !!!!! *
  15.  * *
  16.  *--------------------------------------------------------------------------*
  17.  * Created by: Francisco Campos G. *
  18.  * Bug Fixes and improvements : (Add your name) *
  19.  * -Francisco Campos *
  20.  * *
  21.  ****************************************************************************/
  24. #include "stdafx.h"
  25. #include "guiadodb.h"
  27. CGuiDBObject::CGuiDBObject(){}
  29. CGuiDBObject::~CGuiDBObject(){}
  31. CString CGuiDBObject::GetError(_com_error &e)
  32. {
  33. CString MsgBug;
  34. _bstr_t Source(e.Source());
  35. _bstr_t Description(e.Description());
  36. MsgBug.Format( "Ups!!! nSource = %snDescription= %sn",(LPCSTR)Source, (LPCSTR)Description );
  37. #ifdef _DEBUG
  38. AfxMessageBox( MsgBug, MB_OK | MB_ICONERROR );
  39. #endif
  40. return MsgBug;
  41. }
  43. CString CGuiDBObject::GetTypeVar(_variant_t vt)
  44. {
  45. switch(vt.vt)
  46. {
  47. case VT_EMPTY :
  48. return _T("VT_EMPTY");
  49. break;
  50. case   VT_NULL :
  51. return _T("VT_NULL");
  52. break;
  53. case VT_I2:
  54. return _T("int");
  55. break;
  56. case VT_I4 :
  57. return _T("long");
  58. break;
  59. case  VT_R4 :
  60. return _T("float");
  61. break;
  62. case VT_R8 :
  63. return _T("double");
  64. break;
  65. case VT_CY :
  66. return _T("currency");
  67. break;
  68. case VT_DATE:
  69. return _T("date");
  70. break;
  71. case  VT_BSTR :
  72. return _T("string");
  73. break;
  74. case VT_DISPATCH :
  75. return _T("dispatch");
  76. break;
  77. case  VT_ERROR :
  78. return _T("error");
  79. break;
  80. case VT_BOOL :
  81. return _T("bool");
  82. break;
  83. case VT_VARIANT :
  84. return _T("variant");
  85. break;
  86. case VT_UNKNOWN :
  87. return _T("unknown");
  88. break;
  89. case   VT_DECIMAL :
  90. return _T("decimal");
  91. break;
  92. default:
  93. return _T("");
  94. }
  95. }
  96. //---------------------------------------------------------------------------------------
  98. CGuiConnection::CGuiConnection(void)
  99. {
  100. ::CoInitialize(NULL);
  101. m_pConn.CreateInstance(__uuidof(Connection));
  103. }
  104. CGuiConnection::~CGuiConnection(void)
  105. {
  106. if (IsConnect())
  107. Close();
  108. //m_pConn.Release();
  109. m_pConn = NULL;
  111. }
  113. BOOL CGuiConnection::Open(LPCTSTR ConnectionString,LPCTSTR UID,LPCTSTR PWD,long Options)
  114. {
  115.  HRESULT re;
  116.  try
  117. {
  118. re = m_pConn->Open(_bstr_t(ConnectionString), _bstr_t(UID), _bstr_t(PWD), NULL);
  119. return re == S_OK;
  120. }
  121. catch(_com_error &e)
  122. {
  123. GetError(e);
  124. return FALSE;
  125. }
  126.  
  127. }
  129. BOOL CGuiConnection::IsConnect()
  130. {
  131. return (BOOL) m_pConn->GetState() != adStateClosed;
  132. }
  136. CGuiRecordSet* CGuiConnection::Execute(LPCTSTR CommandText,long Options)
  137. {
  138. CGuiRecordSet* m_rs= new CGuiRecordSet();
  139. try{
  140. m_rs->Open(m_pConn,CommandText,adOpenUnspecified,adLockUnspecified, Options);
  141. }catch(_com_error &e)
  142. {
  143. GetError(e);
  144. return NULL;
  145. }
  146. return m_rs;
  147. }
  149. long CGuiConnection::BeginTrans()
  150. {
  151. return m_pConn->BeginTrans();
  152. }
  154. void CGuiConnection::RollbackTrans()
  155. {
  156. m_pConn->RollbackTrans();
  157. }
  159. void CGuiConnection::CommitTrans()
  160. {
  161. m_pConn->CommitTrans();
  162. }
  164. void CGuiConnection::Cancel()
  165. {
  166. m_pConn->Cancel();
  167. }
  169. void CGuiConnection::Close()
  170. {
  171. m_pConn->Close();
  172. }
  174. void CGuiConnection::SetConnectionTimeout(long ConnectionTimeout)
  175. {
  176. m_pConn->ConnectionTimeout=ConnectionTimeout;
  177. }
  179. void CGuiConnection::SetConectionString( LPCTSTR ConnectionString)
  180. {
  181. m_pConn->ConnectionString=ConnectionString;
  182. }
  184. long CGuiConnection::GetConnectionTimeout()
  185. {
  186. return m_pConn->ConnectionTimeout;
  187. }
  189. LPCTSTR CGuiConnection::GetConectionString()
  190. {
  191. return m_pConn->ConnectionString;
  192. }
  195. //***********************************************************************************************
  196. CGuiRecordSet::CGuiRecordSet(void)
  197. {
  198. ::CoInitialize(NULL);
  199. m_rs.CreateInstance(__uuidof(Recordset));
  200. m_Criteria=_T("");
  201. }
  202. CGuiRecordSet::~CGuiRecordSet(void)
  203. {
  204. Close();
  205. //if (m_rs) m_rs->Release();
  206. m_rs=NULL;
  207. }
  208. 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
  209. {
  210. m_rs->Open(Source, _variant_t((IDispatch*)ActiveConnection, TRUE), 
  211. adOpenStatic, LockType, Options);
  212. }
  213. catch(_com_error &e)
  214. {
  215. GetError(e);
  216. return FALSE;
  217. }
  218. return TRUE; }
  221. BOOL CGuiRecordSet::FindFirst(LPCTSTR Criteria)
  222. {
  223. MoveFirst();
  224.     return Find(Criteria,0,adSearchForward,"");
  225. }
  227. void CGuiRecordSet::Move(long NumRecords , _variant_t Start) { m_rs->Move(NumRecords,vtMissing); }
  228. BOOL CGuiRecordSet::FindNext()
  229. {
  230. return Find(m_Criteria,1,adSearchForward,vtPointer);
  231. }
  234. 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)
  235. {
  236. GetError(e);
  237. return FALSE;
  238. } return FALSE; }
  240. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,CString szCad)
  241. {
  242. _variant_t vt;
  243. if(!szCad.IsEmpty())
  244. {
  245. vt.vt = VT_BSTR;
  246. vt.bstrVal = szCad.AllocSysString();
  247. }
  249. return SetFieldValue(lpName, vt);
  250. }
  252. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,long lVal)
  253. {
  254. _variant_t vt;
  255. vt.lVal=lVal;
  256. vt.vt=VT_I4;
  257. return SetFieldValue(lpName, vt);
  258. }
  260. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,unsigned char usVal)
  261. {
  262. _variant_t vt;
  263. vt.bVal=usVal;
  264. vt.vt=VT_UI1;
  265. return SetFieldValue(lpName, vt);
  266. }
  268. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,short shVal)
  269. {
  270. _variant_t vt;
  271. vt.iVal=shVal;
  272. vt.vt=VT_I2;
  273. return SetFieldValue(lpName, vt);
  274. }
  276. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,float flVal)
  277. {
  278. _variant_t vt;
  279. vt.fltVal=flVal;
  280. vt.vt=VT_R4;
  281. return SetFieldValue(lpName, vt);
  282. }
  284. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,double dblVal)
  285. {
  286. _variant_t vt;
  287. vt.dblVal=dblVal;
  288. vt.vt=VT_R8;
  289. return SetFieldValue(lpName, vt);
  290. }
  292. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,BOOL blVal)
  293. {
  294. _variant_t vt;
  295. vt.boolVal=blVal;
  296. vt.vt=VT_BOOL;
  297. return SetFieldValue(lpName, vt);
  298. }
  300. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,COleDateTime dtVal)
  301. {
  302. _variant_t vt;
  303. vt.date=dtVal;
  304. vt.vt=VT_DATE;
  305. return SetFieldValue(lpName, vt);
  306. }
  308. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,unsigned long ulVal)
  309. {
  310. _variant_t vt;
  311. vt.vt = VT_UI4;
  312. vt.ulVal = ulVal;
  313. return SetFieldValue(lpName, vt);
  314. }
  316. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName, COleCurrency cuVal)
  317. {
  318. _variant_t vt;
  319. vt.vt = VT_CY;
  320. vt.cyVal = cuVal.m_cur;
  321. if(cuVal.m_status == COleCurrency::invalid)
  322. return FALSE;
  323. return SetFieldValue(lpName, vt);
  324. }
  326. BOOL CGuiRecordSet::SetFieldValue(LPCTSTR lpName, _variant_t vtField)
  327. {
  328. try
  329. {
  330. m_rs->Fields->GetItem(lpName)->Value = vtField; 
  331. return TRUE;
  332. }
  333. catch(_com_error &e)
  334. {
  335. GetError(e);
  336. return FALSE;
  337. }
  338. }
  341. CString CGuiRecordSet::GetCollect(LPCTSTR lpField)
  342. {
  343. try{
  344. _variant_t vt = m_rs->Fields->GetItem(lpField)->Value;
  345.  return (CString) vt.bstrVal;
  346. }
  347. catch(_com_error &e)
  348. {
  349. GetError(e);
  350. return _T("");
  351. }
  352.  
  353. }
  355. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,int& nValue)
  356. {
  357. _variant_t vt;
  358. try
  359. {
  360. vt = m_rs->Fields->GetItem(lpField)->Value;
  361. if (vt.vt==VT_I2)
  362. {
  363. nValue=vt.intVal;
  364. return TRUE;
  365. }else if (vt.vt==VT_BOOL)
  366. {
  367. nValue=vt.boolVal;
  368. return TRUE;
  369. }else return FALSE;
  370. }catch(_com_error &e)
  371. {
  372. GetError(e);
  373. return FALSE;
  374. }
  375. }
  376. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,long& lVal)
  377. {
  378. _variant_t vt;
  379. try
  380. {
  381. vt = m_rs->Fields->GetItem(lpField)->Value;
  382. if (vt.vt==VT_I4)
  383. {
  384. lVal=vt.lVal;
  385. return TRUE;
  386. }else return FALSE;
  387. }catch(_com_error &e)
  388. {
  389. GetError(e);
  390. return FALSE;
  391. }
  393. }
  394. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,double& dbVal)
  395. {
  396. _variant_t vt;
  397. try
  398. {
  399. vt = m_rs->Fields->GetItem(lpField)->Value;
  400. if (vt.vt==VT_R8)
  401. {
  402. dbVal=vt.dblVal;
  403. return TRUE;
  404. }else return FALSE;
  405. }catch(_com_error &e)
  406. {
  407. GetError(e);
  408. return FALSE;
  409. }
  410. }
  411. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,CString& strValue)
  412. {
  413. _variant_t vt;
  414. try
  415. {
  416. vt = m_rs->Fields->GetItem(lpField)->Value;
  417. if (vt.vt==VT_BSTR)
  418. {
  419. strValue=vt.bstrVal;
  420. return TRUE;
  421. }else return FALSE;
  422. }catch(_com_error &e)
  423. {
  424. GetError(e);
  425. return FALSE;
  426. }
  427. }
  430. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,COleCurrency& cyVal)
  431. {
  432. _variant_t vt;
  433. vt = m_rs->Fields->GetItem(lpField)->Value;
  435. try
  436. {
  437. if (vt.vt==VT_CY)
  438. {
  439. cyVal.m_cur=vt.cyVal;
  440. return TRUE;
  441. }else return FALSE;
  442. }catch(_com_error &e)
  443. {
  444. GetError(e);
  445. return FALSE;
  446. }
  448. }
  450. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,COleDateTime& dtVal)
  451. {
  452. _variant_t vt;
  453. try
  454. {
  455. vt = m_rs->Fields->GetItem(lpField)->Value;
  456. if (vt.vt==VT_DATE)
  457. {
  458. dtVal=vt.date;
  459. return TRUE;
  460. }else return FALSE;
  461. }catch(_com_error &e)
  462. {
  463. GetError(e);
  464. return FALSE;
  465. }
  466. }
  467. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,float& flVal)
  468. {
  469. _variant_t vt;
  470. try
  471. {
  472. vt = m_rs->Fields->GetItem(lpField)->Value;
  473. if (vt.vt==VT_R4)
  474. {
  475. flVal=vt.fltVal;
  476. return TRUE;
  477. }else return FALSE;
  478. }catch(_com_error &e)
  479. {
  480. GetError(e);
  481. return FALSE;
  482. }
  483. }
  485. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,_variant_t& vt)
  486. {
  487. try
  488. {
  489. vt = m_rs->Fields->GetItem(lpField)->Value;
  490. return TRUE;
  491. }
  492. catch(_com_error& e)
  493. {
  494. GetError(e);
  495. return FALSE;
  496. }
  497. }
  499. BOOL CGuiRecordSet::GetCollect(int nIndex,int& nValue)
  500. {
  501. _variant_t vt;
  502. _variant_t vtn;
  503. vtn.vt = VT_I2;
  504. try
  505. {
  506. vtn.iVal = nIndex;
  507. vt = m_rs->Fields->GetItem(vtn)->Value;
  508. if (vt.vt==VT_I2)
  509. {
  510. nValue=vt.intVal;
  511. return TRUE;
  512. }else return FALSE;
  513. }catch(_com_error &e)
  514. {
  515. GetError(e);
  516. return FALSE;
  517. }
  519. }
  521. BOOL CGuiRecordSet::GetCollect(int nIndex,long& lVal)
  522. {
  523. _variant_t vt;
  524. _variant_t vtn;
  525. vtn.vt = VT_I2;
  526. try
  527. {
  528. vtn.iVal = nIndex;
  529. vt = m_rs->Fields->GetItem(vtn)->Value;
  530. if (vt.vt==VT_I4)
  531. {
  532. lVal=vt.lVal;
  533. return TRUE;
  534. }else return FALSE;
  535. }catch(_com_error &e)
  536. {
  537. GetError(e);
  538. return FALSE;
  539. }
  541. }
  543. BOOL CGuiRecordSet::GetCollect(int nIndex,double& dbVal)
  544. {
  545. _variant_t vt;
  546. _variant_t vtn;
  547. vtn.vt = VT_I2;
  548. try
  549. {
  550. vtn.iVal = nIndex;
  551. vt = m_rs->Fields->GetItem(vtn)->Value;
  552. if (vt.vt==VT_R8)
  553. {
  554. dbVal=vt.dblVal;
  555. return TRUE;
  556. }else return FALSE;
  557. }catch(_com_error &e)
  558. {
  559. GetError(e);
  560. return FALSE;
  561. }
  562. }
  564. BOOL CGuiRecordSet::GetCollect(int nIndex,CString& strValue)
  565. {
  566. _variant_t vt;
  567. _variant_t vtn;
  568. vtn.vt = VT_I2;
  569. try
  570. {
  571. vtn.iVal = nIndex;
  572. vt = m_rs->Fields->GetItem(vtn)->Value;
  573. if (vt.vt==VT_BSTR)
  574. {
  575. strValue=vt.bstrVal;
  576. return TRUE;
  577. }else return FALSE;
  578. }catch(_com_error &e)
  579. {
  580. GetError(e);
  581. return FALSE;
  582. }
  583. }
  585. BOOL CGuiRecordSet::GetCollect(int nIndex,COleCurrency& cyVal)
  586. {
  587. _variant_t vt;
  588. _variant_t vtn;
  589. vtn.vt = VT_CY;
  590. try
  591. {
  592. vtn.iVal =nIndex;
  593. vt = m_rs->Fields->GetItem(vtn)->Value;
  594. if (vt.vt==VT_CY)
  595. {
  596. cyVal.m_cur=vt.cyVal;
  597. return TRUE;
  598. }else return FALSE;
  599. }catch(_com_error &e)
  600. {
  601. GetError(e);
  602. return FALSE;
  603. }
  605. }
  607. BOOL CGuiRecordSet::GetCollect(int nIndex,COleDateTime& dtVal)
  608. {
  609. _variant_t vt;
  610. _variant_t vtn;
  611. vtn.vt = VT_I2;
  612. try
  613. {
  614. vtn.iVal = nIndex;
  615. vt = m_rs->Fields->GetItem(vtn)->Value;
  616. if (vt.vt==VT_DATE)
  617. {
  618. dtVal=vt.date;
  619. return TRUE;
  620. }else return FALSE;
  621. }catch(_com_error &e)
  622. {
  623. GetError(e);
  624. return FALSE;
  625. }
  627. }
  629. BOOL CGuiRecordSet::GetFormatDate(LPCTSTR lpField,CString& m_szDate, CString Format)
  630. {
  631. COleDateTime time;
  632. if (!GetCollect(lpField,time)) return FALSE;
  633. CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
  634. m_szDate =ct.Format(Format);
  635. return TRUE;
  636. }
  638. BOOL CGuiRecordSet::GetFormatDate(int nIndex,CString& m_szDate, CString Format)
  639. {
  640. COleDateTime time;
  641. if (!GetCollect(nIndex,time)) return FALSE;
  642. CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
  643. m_szDate =ct.Format(Format);
  644. return TRUE;
  645. }
  647. BOOL CGuiRecordSet::GetCollect(int nIndex,float& flVal)
  648. {
  649. _variant_t vt;
  650. _variant_t vtn;
  651. vtn.vt = VT_I2;
  652. try
  653. {
  654. vtn.iVal = nIndex;
  655. vt = m_rs->Fields->GetItem(vtn)->Value;
  656. if (vt.vt==VT_R4)
  657. {
  658. flVal=vt.fltVal;
  659. return TRUE;
  660. }else return FALSE;
  661. }catch(_com_error &e)
  662. {
  663. GetError(e);
  664. return FALSE;
  665. }
  667. }
  671. BOOL CGuiRecordSet::GetCollect(int nIndex,_variant_t& vt)
  672. {
  674. _variant_t vtn;
  675. vtn.vt = VT_I2;
  676. try
  677. {
  678. vtn.iVal = nIndex;
  679. vt = m_rs->Fields->GetItem(vtn)->Value;
  680. return TRUE;
  681. }
  682. catch(_com_error& e)
  683. {
  684. GetError(e);
  685. return FALSE;
  686. }
  687. }
  692. BOOL CGuiRecordSet::SetFilter(LPCTSTR lpFilter)
  693. {
  694. if (!IsOpen()) return FALSE;
  695. try
  696. {
  697. m_rs->PutFilter(lpFilter);
  698. return TRUE;
  699. }
  700. catch(_com_error &e)
  701. {
  702. GetError(e);
  703. return FALSE;
  704. }
  705. }
  707. BOOL CGuiRecordSet::SetSort(LPCTSTR lpSort)
  708. {
  709. if (!IsOpen()) return FALSE;
  710. try
  711. {
  712. m_rs->PutSort(lpSort);
  713. return TRUE;
  714. }
  715. catch(_com_error &e)
  716. {
  717. GetError(e);
  718. return FALSE;
  719. }
  720. }
  723. BOOL CGuiRecordSet::IsOpen()
  724. {
  725. if(m_rs)
  726. return m_rs-> GetState() != adStateClosed;
  727. return FALSE;
  728. }
  730. void CGuiRecordSet::Close()
  731. {
  732. if(IsOpen())
  733. m_rs->Close();
  735. }
  738. void CGuiRecordSet::MoveFirst()
  739. {
  740. m_rs->MoveFirst();
  741. }
  743. void CGuiRecordSet::MoveLast()
  744. {
  745. m_rs->MoveLast();
  746. }
  748. void CGuiRecordSet::MoveNext()
  749. {
  750. m_rs->MoveNext();
  751. }
  753. void CGuiRecordSet::MovePrevious()
  754. {
  755. m_rs->MovePrevious();
  756. }
  758. void CGuiRecordSet::Cancel()
  759. {
  760.    m_rs->Cancel();
  761. }
  763. void CGuiRecordSet::CancelUpdate()
  764. {
  765.   m_rs->CancelUpdate();
  766. }
  768. BOOL CGuiRecordSet::Delete()
  769. {
  770. try{
  771. if(m_rs->Delete(adAffectCurrent)== S_OK)
  772. if(m_rs->Update() ==S_OK)
  773. return TRUE;
  774. }catch(_com_error &e)
  775. {
  776. GetError(e);
  777. return FALSE;
  778. }
  779. return FALSE;
  780. }
  782. BOOL CGuiRecordSet::IsEof()
  783. {
  784. return (BOOL)m_rs->EndOfFile;
  785. }
  786. BOOL CGuiRecordSet::IsBof()
  787. {
  788. return (BOOL)m_rs->BOF;
  789. }
  790. BOOL CGuiRecordSet::Supports( CursorOptionEnum CursorOptions )  {   return (BOOL)m_rs->Supports(CursorOptions); }
  791. void CGuiRecordSet::CancelBatch(AffectEnum AffectRecords) {   m_rs->CancelBatch(AffectRecords); } CGuiField CGuiRecordSet::GetField(LPCTSTR lpField)
  792. {
  793. FieldPtr pField = m_rs->Fields->GetItem(lpField);
  794. CGuiField Field;
  795. Field.Attach(pField);
  796. return Field;
  797. }
  798. CGuiField CGuiRecordSet::GetField(int Index) { _variant_t vtIndex;
  799. vtIndex.vt = VT_I2;
  800. vtIndex.iVal = Index;
  801. FieldPtr pField = m_rs->Fields->GetItem(vtIndex); CGuiField Field;
  802. Field.Attach(pField);
  803. 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;  }
  804. //added by devia lee at 2004/07/06
  806. //load recordset from xml file.
  807. BOOL CGuiRecordSet::LoadFromXMLFile(LPCTSTR lpXMLFile)
  808. {
  809. CString sFileName = lpXMLFile;
  810. sFileName.TrimLeft(); sFileName.TrimRight();
  812. if( NULL == this->m_rs || sFileName.IsEmpty()) return FALSE;
  814. if(this->IsOpen()) this->Close();
  816. try
  817. {
  818. HRESULT hr = this->m_rs->Open(sFileName.GetBuffer(0), "Provider=MSPersist;", 
  819. adOpenUnspecified, adLockReadOnly, adCmdFile);
  821. return !FAILED(hr) ? TRUE : FALSE;
  822. }
  823. catch(_com_error e)
  824. {
  825. GetError(e);
  826. return FALSE;
  827. }
  828. }
  830. //save recordset into xml file.
  831. BOOL CGuiRecordSet::SaveToXMLFile(LPCTSTR lpXMLFile)
  832. {
  833. CString sFileName = lpXMLFile;
  834. sFileName.TrimLeft(); sFileName.TrimRight();
  836. if(sFileName.IsEmpty() || NULL == this->m_rs || !this->IsOpen())
  837. {
  838. return FALSE;
  839. }
  840. try
  841. {
  842. _variant_t V(sFileName.GetBuffer(0));
  843. HRESULT hr = this->m_rs->Save(V, adPersistXML);
  844. if(FAILED(hr)) return FALSE; else return TRUE;
  845. }
  846. catch(_com_error e)
  847. {
  848. GetError(e);
  849. return FALSE;
  850. }
  851. }
  853. //***********************************************************************************************************
  854. CGuiField::CGuiField(void)
  855. {
  856. }
  857. CGuiField::~CGuiField(void)
  858. {
  859. }
  860. BOOL CGuiField::SetValue(long lVal)
  861. {
  862. _variant_t vt;
  863. vt.lVal=lVal;
  864. vt.vt=VT_I4;
  865. try
  866. {
  867. field->Value=vt;
  868. return TRUE;
  869. }catch(_com_error &e)
  870. {
  871. GetError(e);
  872. return FALSE;
  873. }
  875. }
  879. BOOL CGuiField::SetValue(float flVal)
  880. {
  881. _variant_t vt;
  882. vt.fltVal=flVal;
  883. vt.vt=VT_R4;
  884. try
  885. {
  886. field->Value=vt;
  887. return TRUE;
  888. }catch(_com_error &e)
  889. {
  890. GetError(e);
  891. return FALSE;
  892. }
  893. }
  896. BOOL CGuiField::SetValue(int nVal)
  897. {
  898. _variant_t vt;
  899. vt.intVal=nVal;
  900. vt.vt=VT_I2;
  901. try
  902. {
  903. field->Value=vt;
  904. return TRUE;
  905. }catch(_com_error &e)
  906. {
  907. GetError(e);
  908. return FALSE;
  909. }
  912. }
  914. BOOL CGuiField::SetValue(double dbVal)
  915. {
  916. _variant_t vt;
  917. vt.dblVal=dbVal;
  918. vt.vt=VT_R8;
  920. try
  921. {
  922. field->Value=vt;
  923. return TRUE;
  924. }catch(_com_error &e)
  925. {
  926. GetError(e);
  927. return FALSE;
  928. }
  930. }
  932. BOOL CGuiField::SetValue(CString szCad)
  933. {
  934. _variant_t vt;
  935. if(!szCad.IsEmpty())
  936. {
  937. vt.vt = VT_BSTR;
  938. vt.bstrVal = szCad.AllocSysString();
  939. }
  940. try
  941. {
  942. field->Value=vt;
  943. return TRUE;
  944. }catch(_com_error &e)
  945. {
  946. GetError(e);
  947. return FALSE;
  948. }
  951. }
  954. BOOL CGuiField::SetValue(bool blVal)
  955. {
  956. _variant_t vt;
  957. vt.boolVal=blVal;
  958. vt.vt=VT_BOOL;
  959. try
  960. {
  961. field->Value=vt;
  962. return TRUE;
  963. }catch(_com_error &e)
  964. {
  965. GetError(e);
  966. return FALSE;
  967. }
  968. }
  971. BOOL CGuiField::SetValue(COleDateTime dtVal)
  972. {
  973. _variant_t vt;
  974. vt.date=dtVal;
  975. vt.vt=VT_DATE;
  976. try
  977. {
  978. field->Value=vt;
  979. return TRUE;
  980. }catch(_com_error &e)
  981. {
  982. GetError(e);
  983. return FALSE;
  984. }
  986. }
  988. BOOL CGuiField::SetValue(_variant_t vt)
  989. {
  990. try
  991. {
  992. field->Value=vt;
  993. return TRUE;
  994. }catch(_com_error &e)
  995. {
  996. GetError(e);
  997. return FALSE;
  998. }
  1000. }
  1002. BOOL CGuiField::GetValue(int& nVal)
  1003. {
  1004. _variant_t vt;
  1005. vt = field->Value;
  1006. try
  1007. {
  1008. if (vt.vt==VT_I2)
  1009. {
  1010. nVal=vt.intVal;
  1011. return TRUE;
  1012. }else if (vt.vt==VT_BOOL)
  1013. {
  1014. nVal=vt.boolVal;
  1015. return TRUE;
  1016. }else return FALSE;
  1017. }catch(_com_error &e)
  1018. {
  1019. GetError(e);
  1020. return FALSE;
  1021. }
  1023. }
  1025. BOOL CGuiField::GetValue(long& lVal)
  1026. {
  1027. _variant_t vt;
  1028. vt = field->Value;
  1029. try
  1030. {
  1031. if (vt.vt==VT_I4)
  1032. {
  1033. lVal=vt.lVal;
  1034. return TRUE;
  1035. }else return FALSE;
  1036. }catch(_com_error &e)
  1037. {
  1038. GetError(e);
  1039. return FALSE;
  1040. }
  1042. }
  1044. BOOL CGuiField::GetValue(double& dbVal)
  1045. {
  1046. _variant_t vt;
  1047. vt = field->Value;
  1048. try
  1049. {
  1050. if (vt.vt==VT_R8)
  1051. {
  1052. dbVal=vt.dblVal;
  1053. return TRUE;
  1054. }else return FALSE;
  1055. }catch(_com_error &e)
  1056. {
  1057. GetError(e);
  1058. return FALSE;
  1059. }
  1060. }
  1062. BOOL CGuiField::GetValue(CString& strValue)
  1063. {
  1064. _variant_t vt;
  1065. vt =field->Value;
  1067. try
  1068. {
  1069. if (vt.vt==VT_BSTR)
  1070. {
  1071. strValue=vt.bstrVal;
  1072. return TRUE;
  1073. }else return FALSE;
  1074. }catch(_com_error &e)
  1075. {
  1076. GetError(e);
  1077. return FALSE;
  1078. }
  1079. }
  1081. BOOL CGuiField::GetValue(COleDateTime& dtVal)
  1082. {
  1083. _variant_t vt;
  1084. vt = field->Value;
  1085. try
  1086. {
  1087. if (vt.vt==VT_DATE)
  1088. {
  1089. dtVal=vt.date;
  1090. return TRUE;
  1091. }else return FALSE;
  1092. }catch(_com_error &e)
  1093. {
  1094. GetError(e);
  1095. return FALSE;
  1096. }
  1098. }
  1100. BOOL CGuiField::GetValue(float& flVal)
  1101. {
  1102. _variant_t vt;
  1103. vt = field->Value;
  1104. try
  1105. {
  1106. if (vt.vt==VT_R4)
  1107. {
  1108. flVal=vt.fltVal;
  1109. return TRUE;
  1110. }else return FALSE;
  1111. }catch(_com_error &e)
  1112. {
  1113. GetError(e);
  1114. return FALSE;
  1115. }
  1117. }
  1121. BOOL CGuiField::GetValue(_variant_t& vt)
  1122. {
  1123. try
  1124. {
  1125. _variant_t vt = field->Value;
  1126. return TRUE;
  1127. }
  1128. catch(_com_error& e)
  1129. {
  1130. GetError(e);
  1131. return FALSE;
  1132. }
  1133. }
  1136. //***********************************************************************************************************
  1138. CGuiParameter::CGuiParameter()
  1139. {
  1140. ::CoInitialize(NULL);
  1141. pParam.CreateInstance(__uuidof(Parameter));
  1142. }
  1144. CGuiParameter::~CGuiParameter()
  1145. {
  1146. //pParam->Release();
  1147. pParam=NULL;
  1148. }
  1151. void CGuiParameter::SetAttributes(long Attributes)
  1152. {
  1153. pParam->PutAttributes(Attributes);
  1154. }
  1156. void CGuiParameter::SetDirection(ADOCG::ParameterDirectionEnum Direction)
  1157. {
  1158. pParam->PutDirection(Direction);
  1159. }
  1161. void CGuiParameter::SetName(LPCTSTR szName)
  1162. {
  1163. CString mszname=szName;
  1164. pParam->Name=mszname.AllocSysString();
  1166. }
  1168. void CGuiParameter::SetNumericScale(unsigned char NumericScale)
  1169. {
  1170. pParam->PutNumericScale(NumericScale);
  1171. }
  1173. void CGuiParameter::SetPrecision(unsigned char Precision)
  1174. {
  1175. pParam->PutPrecision(Precision);
  1176. }
  1178. void CGuiParameter::SetSize(long Size)
  1179. {
  1180. pParam->PutSize(Size);
  1181. }
  1183. void CGuiParameter::SetType(ADOCG::DataTypeEnum Type)
  1184. {
  1185. pParam->PutType(Type);
  1186. }
  1188. BOOL CGuiParameter::SetValue(long lVal)
  1189. {
  1190. _variant_t vt;
  1191. vt.lVal=lVal;
  1192. vt.vt=VT_I4;
  1193. try
  1194. {
  1195. pParam->Value=vt;
  1196. return TRUE;
  1197. }catch(_com_error &e)
  1198. {
  1199. GetError(e);
  1200. return FALSE;
  1201. }
  1203. }
  1207. BOOL CGuiParameter::SetValue(float flVal)
  1208. {
  1209. _variant_t vt;
  1210. vt.fltVal=flVal;
  1211. vt.vt=VT_R4;
  1212. try
  1213. {
  1214. pParam->Value=vt;
  1215. return TRUE;
  1216. }catch(_com_error &e)
  1217. {
  1218. GetError(e);
  1219. return FALSE;
  1220. }
  1221. }
  1224. BOOL CGuiParameter::SetValue(int nVal)
  1225. {
  1226. _variant_t vt;
  1227. vt.intVal=nVal;
  1228. vt.vt=VT_I2;
  1229. try
  1230. {
  1231. pParam->Value=vt;
  1232. return TRUE;
  1233. }catch(_com_error &e)
  1234. {
  1235. GetError(e);
  1236. return FALSE;
  1237. }
  1240. }
  1242. BOOL CGuiParameter::SetValue(double dbVal)
  1243. {
  1244. _variant_t vt;
  1245. vt.dblVal=dbVal;
  1246. vt.vt=VT_R8;
  1248. try
  1249. {
  1250. pParam->Value=vt;
  1251. return TRUE;
  1252. }catch(_com_error &e)
  1253. {
  1254. GetError(e);
  1255. return FALSE;
  1256. }
  1258. }
  1260. BOOL CGuiParameter::SetValue(CString szCad)
  1261. {
  1262. _variant_t vt;
  1263. if(!szCad.IsEmpty())
  1264. {
  1265. vt.vt = VT_BSTR;
  1266. vt.bstrVal = szCad.AllocSysString();
  1267. }
  1268. try
  1269. {
  1270. pParam->Value=vt;
  1271. return TRUE;
  1272. }catch(_com_error &e)
  1273. {
  1274. GetError(e);
  1275. return FALSE;
  1276. }
  1279. }
  1282. BOOL CGuiParameter::SetValue(bool blVal)
  1283. {
  1284. _variant_t vt;
  1285. vt.boolVal=blVal;
  1286. vt.vt=VT_BOOL;
  1287. try
  1288. {
  1289. pParam->Value=vt;
  1290. return TRUE;
  1291. }catch(_com_error &e)
  1292. {
  1293. GetError(e);
  1294. return FALSE;
  1295. }
  1296. }
  1299. BOOL CGuiParameter::SetValue(COleDateTime dtVal)
  1300. {
  1301. _variant_t vt;
  1302. vt.date=dtVal;
  1303. vt.vt=VT_DATE;
  1304. try
  1305. {
  1306. pParam->Value=vt;
  1307. return TRUE;
  1308. }catch(_com_error &e)
  1309. {
  1310. GetError(e);
  1311. return FALSE;
  1312. }
  1314. }
  1316. BOOL CGuiParameter::SetValue(_variant_t vt)
  1317. {
  1318. try
  1319. {
  1320. pParam->Value=vt;
  1321. return TRUE;
  1322. }catch(_com_error &e)
  1323. {
  1324. GetError(e);
  1325. return FALSE;
  1326. }
  1328. }
  1330. BOOL CGuiParameter::GetValue(int& nVal)
  1331. {
  1332. _variant_t vt;
  1333. vt = pParam->Value;
  1334. try
  1335. {
  1336. if (vt.vt==VT_I2)
  1337. {
  1338. nVal=vt.intVal;
  1339. return TRUE;
  1340. }else if (vt.vt==VT_BOOL)
  1341. {
  1342. nVal=vt.boolVal;
  1343. return TRUE;
  1344. }else return FALSE;
  1345. }catch(_com_error &e)
  1346. {
  1347. GetError(e);
  1348. return FALSE;
  1349. }
  1351. }
  1353. BOOL CGuiParameter::GetValue(long& lVal)
  1354. {
  1355. _variant_t vt;
  1356. vt = pParam->Value;
  1357. try
  1358. {
  1359. if (vt.vt==VT_I4)
  1360. {
  1361. lVal=vt.lVal;
  1362. return TRUE;
  1363. }if (vt.vt==VT_BSTR)
  1364. {
  1365. CString cad=vt.bstrVal;
  1366. lVal=atol(cad);
  1367. return TRUE;
  1368. }
  1369. else return FALSE;
  1370. }catch(_com_error &e)
  1371. {
  1372. GetError(e);
  1373. return FALSE;
  1374. }
  1376. }
  1378. BOOL CGuiParameter::SetValue(COleCurrency cyVal)
  1379. {
  1380. _variant_t vt;
  1381. vt.cyVal=cyVal.m_cur;
  1382. vt.vt=VT_CY;
  1383. try
  1384. {
  1385. pParam->Value=vt;
  1386. return TRUE;
  1387. }catch(_com_error &e)
  1388. {
  1389. GetError(e);
  1390. return FALSE;
  1391. }
  1393. }
  1395. BOOL CGuiParameter::GetValue(double& dbVal)
  1396. {
  1397. _variant_t vt;
  1398. vt = pParam->Value;
  1399. try
  1400. {
  1401. if (vt.vt==VT_R8)
  1402. {
  1403. dbVal=vt.dblVal;
  1404. return TRUE;
  1405. }else return FALSE;
  1406. }catch(_com_error &e)
  1407. {
  1408. GetError(e);
  1409. return FALSE;
  1410. }
  1411. }
  1413. BOOL CGuiParameter::GetValue(CString& strValue)
  1414. {
  1415. _variant_t vt;
  1416. vt =pParam->Value;
  1418. try
  1419. {
  1420. if (vt.vt==VT_BSTR)
  1421. {
  1422. strValue=vt.bstrVal;
  1423. return TRUE;
  1424. }else return FALSE;
  1425. }catch(_com_error &e)
  1426. {
  1427. GetError(e);
  1428. return FALSE;
  1429. }
  1430. }
  1432. BOOL CGuiParameter::GetValue(COleDateTime& dtVal)
  1433. {
  1434. _variant_t vt;
  1435. vt = pParam->Value;
  1436. try
  1437. {
  1438. if (vt.vt==VT_DATE)
  1439. {
  1440. dtVal=vt.date;
  1441. return TRUE;
  1442. }else return FALSE;
  1443. }catch(_com_error &e)
  1444. {
  1445. GetError(e);
  1446. return FALSE;
  1447. }
  1449. }
  1451. BOOL CGuiParameter::GetValue(COleCurrency& cyVal)
  1452. {
  1453. _variant_t vt;
  1454. vt = pParam->Value;
  1456. try
  1457. {
  1458. if (vt.vt==VT_CY)
  1459. {
  1460. cyVal.m_cur=vt.cyVal;
  1461. return TRUE;
  1462. }else return FALSE;
  1463. }catch(_com_error &e)
  1464. {
  1465. GetError(e);
  1466. return FALSE;
  1467. }
  1469. }
  1472. BOOL CGuiParameter::GetFormatDate(CString& m_szDate, CString Format)
  1473. {
  1474. COleDateTime time;
  1475. if (!GetValue(time)) return FALSE;
  1476. CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
  1477. m_szDate =ct.Format(Format);
  1478. return TRUE;
  1479. }
  1483. BOOL CGuiParameter::GetValue(float& flVal)
  1484. {
  1485. _variant_t vt;
  1486. vt = pParam->Value;
  1487. try
  1488. {
  1489. if (vt.vt==VT_R4)
  1490. {
  1491. flVal=vt.fltVal;
  1492. return TRUE;
  1493. }else return FALSE;
  1494. }catch(_com_error &e)
  1495. {
  1496. GetError(e);
  1497. return FALSE;
  1498. }
  1500. }
  1504. BOOL CGuiParameter::GetValue(_variant_t& vt)
  1505. {
  1506. try
  1507. {
  1508. _variant_t vt = pParam->Value;
  1509. return TRUE;
  1510. }
  1511. catch(_com_error& e)
  1512. {
  1513. GetError(e);
  1514. return FALSE;
  1515. }
  1516. }
  1519. //----------------------------------------------------------------------------------------------
  1521. CGuiCommand::CGuiCommand()
  1522. {
  1523. ::CoInitialize(NULL);
  1524. pCommand.CreateInstance(__uuidof(Command));
  1526. }
  1528. CGuiCommand::~CGuiCommand()
  1529. {
  1530. Cancel();
  1531. //pCommand->Release();
  1532. pCommand=NULL;
  1533. }
  1536. void CGuiCommand::SetActiveConnection(LPCTSTR szconnec)
  1537. {
  1538. m_pCon.Open(szconnec);
  1539. ASSERT( m_pCon.IsConnect());
  1540. SetActiveConnection(&m_pCon);
  1541. }
  1543. void CGuiCommand::SetActiveConnection(CGuiConnection* pCon)
  1544. {
  1545. ASSERT(pCon->IsConnect());
  1546. pCommand->ActiveConnection=pCon->GetConecction();
  1547. }
  1549. void CGuiCommand::Cancel()
  1550. {
  1551. pCommand->Cancel();
  1552. } 
  1554. void CGuiCommand::SetCommandText(LPCTSTR lpCommand,CommandTypeEnum cmdType)
  1555. {
  1556. CString szCommand=lpCommand;
  1557. pCommand->CommandText=szCommand.AllocSysString();
  1558. pCommand->PutCommandType(cmdType);
  1559. }
  1561. void CGuiCommand::SetCommandTimeout(long CommandTimeout)
  1562. {
  1563. pCommand->PutCommandTimeout(CommandTimeout);
  1564. }
  1566. void CGuiCommand::SetPrepared(BOOL prepared)
  1567. {
  1568. pCommand->PutPrepared((BOOL) prepared);
  1569. }
  1571. long CGuiCommand::GetState()
  1572. {
  1573. return pCommand->GetState();
  1574. }
  1576. CGuiRecordSet* CGuiCommand::Execute(VARIANT* param1,VARIANT* param2,long Options)
  1577. {
  1578. try
  1579. {
  1580. _RecordsetPtr m_rs = pCommand->Execute(NULL, NULL, Options);
  1581. CGuiRecordSet* m_prs= new CGuiRecordSet();
  1582. m_prs->Attach(m_rs);
  1583. return m_prs;
  1584. }
  1585. catch(_com_error &e)
  1586. {
  1587. GetError(e);
  1588. return NULL;
  1589. }
  1591. }
  1593. CGuiParameter* CGuiCommand::CreateParameter(CString Name ,long Size ,
  1594. ADOCG::DataTypeEnum Type, 
  1595. ADOCG::ParameterDirectionEnum Direction)
  1596. {
  1597. _ParameterPtr param=pCommand->CreateParameter(Name.AllocSysString(), Type,Direction, Size);
  1599. CGuiParameter* pParam=new CGuiParameter();
  1600. pParam->Attach(param);
  1601. return pParam;
  1602. }
  1604. BOOL CGuiCommand::Append(CGuiParameter* pParam)
  1605. {
  1606. try
  1607. {
  1608. pCommand->Parameters->Append(pParam->GetParameter());
  1609. return TRUE;
  1610. }
  1611. catch(_com_error& e)
  1612. {
  1613. GetError(e);
  1614. return FALSE;
  1615. }
  1617. }