MFC中ADO方式操作数据库实例

连接ACCESS为例： 

C++代码  

1. //头文件  
2. #pragma once     
3.     
4. #include "math.h"     
5.     
6. #import "MSADO15.DLL"   rename_namespace("ADOWE") rename("EOF","EndOfFile")     
7. using namespace ADOWE;    
8.     
9. class CDBAdo    
10. {    
11. public:    
12.     _CommandPtr     m_ptrCommand;       //命令对象     
13.     _RecordsetPtr   m_ptrRecordset;     //记录集对象     
14.     _ConnectionPtr  m_ptrConnection;    //数据库对象     
15.     
16.     CString         m_strConnect,       //连接字符串     
17.                     m_strErrorMsg;      //错误信息     
18.     
19. public:    
20.     CDBAdo(void);    
21.     ~CDBAdo(void);    
22.     
23.     void    DetectResult(HRESULT hResult);    
24.     void    RecordErrorMsg(_com_error comError);    
25.     CString GetLastError(){return m_strErrorMsg;}    
26.     
27.     bool    CreateInstance();    
28.     bool    SetConnectionString(CString strDriver, CString strIP, WORD wPort, CString strCatalog, CString strUserID, CString strPassword);    
29.     bool    SetConnectionString(CString strDriver, CString strDataSrc, CString strPassword);    
30.     bool    OpenConnection();    
31.     bool    CloseConnection();    
32.     bool    IsConnecting();    
33.     
34.     void    ClearAllParameters();    
35.     void    AddParamter(LPCTSTR lpcsrName, ADOWE::ParameterDirectionEnum Direction, ADOWE::DataTypeEnum Type, long lSize, _variant_t & vtValue);    
36.     void    SetSPName(LPCTSTR lpcsrSPName);    
37.     bool    ExecuteCommand(bool bIsRecordset);    
38.     bool    Execute(LPCTSTR lpcsrCommand);    
39.     long    GetReturnValue();    
40.     
41.     bool    OpenRecordset(char* szSQL);    
42.     bool    CloseRecordset();    
43.     bool    IsRecordsetOpened();    
44.     bool    IsEndRecordset();    
45.     void    MoveToNext();    
46.     void    MoveToFirst();    
47.     void    MoveToLast();    
48.     long    GetRecordCount();    
49.     
50.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, WORD& wValue);    
51.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, CString& strValue);    
52.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, INT& nValue);    
53.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, BYTE& bValue);    
54.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, LONG& lValue);    
55.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, DWORD& dwValue);    
56.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, UINT& ulValue);    
57.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, DOUBLE& dbValue);    
58.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, __int64& llValue);    
59.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, COleDateTime& Time);    
60.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, bool& bValue);    
61. };    
62. #pragma once  
63.   
64. #include "math.h"  
65.   
66. #import "MSADO15.DLL"   rename_namespace("ADOWE") rename("EOF","EndOfFile")  
67. using namespace ADOWE;  
68.   
69. class CDBAdo  
70. {  
71. public:  
72.     _CommandPtr     m_ptrCommand;       //命令对象  
73.     _RecordsetPtr   m_ptrRecordset;     //记录集对象  
74.     _ConnectionPtr  m_ptrConnection;    //数据库对象  
75.   
76.     CString         m_strConnect,       //连接字符串  
77.                     m_strErrorMsg;      //错误信息  
78.   
79. public:  
80.     CDBAdo(void);  
81.     ~CDBAdo(void);  
82.   
83.     void    DetectResult(HRESULT hResult);  
84.     void    RecordErrorMsg(_com_error comError);  
85.     CString GetLastError(){return m_strErrorMsg;}  
86.   
87.     bool    CreateInstance();  
88.     bool    SetConnectionString(CString strDriver, CString strIP, WORD wPort, CString strCatalog, CString strUserID, CString strPassword);  
89.     bool    SetConnectionString(CString strDriver, CString strDataSrc, CString strPassword);  
90.     bool    OpenConnection();  
91.     bool    CloseConnection();  
92.     bool    IsConnecting();  
93.   
94.     void    ClearAllParameters();  
95.     void    AddParamter(LPCTSTR lpcsrName, ADOWE::ParameterDirectionEnum Direction, ADOWE::DataTypeEnum Type, long lSize, _variant_t & vtValue);  
96.     void    SetSPName(LPCTSTR lpcsrSPName);  
97.     bool    ExecuteCommand(bool bIsRecordset);  
98.     bool    Execute(LPCTSTR lpcsrCommand);  
99.     long    GetReturnValue();  
100.   
101.     bool    OpenRecordset(char* szSQL);  
102.     bool    CloseRecordset();  
103.     bool    IsRecordsetOpened();  
104.     bool    IsEndRecordset();  
105.     void    MoveToNext();  
106.     void    MoveToFirst();  
107.     void    MoveToLast();  
108.     long    GetRecordCount();  
109.   
110.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, WORD& wValue);  
111.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, CString& strValue);  
112.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, INT& nValue);  
113.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, BYTE& bValue);  
114.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, LONG& lValue);  
115.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, DWORD& dwValue);  
116.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, UINT& ulValue);  
117.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, DOUBLE& dbValue);  
118.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, __int64& llValue);  
119.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, COleDateTime& Time);  
120.     bool    GetFieldValue(LPCTSTR lpcsrFieldName, bool& bValue);  
121. };   
122.   
123. //实现文件  
124.   
125. [cpp] view plaincopyprint?#include "StdAfx.h"     
126. #include "DBAdo.h"     
127.     
128. CDBAdo::CDBAdo(void)    
129. {    
130.     m_strConnect    = _T("");    
131.     m_strErrorMsg   = _T("");    
132.     
133.     //初始化 COM     
134.     CoInitialize(NULL);    
135. }    
136.     
137. CDBAdo::~CDBAdo(void)    
138. {    
139.     //关闭连接     
140.     CloseConnection();    
141.     
142.     //释放对象     
143.     if(m_ptrCommand!=NULL)    
144.         m_ptrCommand.Release();    
145.     if(m_ptrRecordset!=NULL)    
146.         m_ptrRecordset.Release();    
147.     if(m_ptrConnection!=NULL)    
148.         m_ptrConnection.Release();    
149. }    
150.     
151. bool CDBAdo::CreateInstance()    
152. {    
153.     //创建对象     
154.     m_ptrCommand.CreateInstance(__uuidof(Command));    
155.     m_ptrRecordset.CreateInstance(__uuidof(Recordset));    
156.     m_ptrConnection.CreateInstance(__uuidof(Connection));    
157.     
158.     if(m_ptrCommand==NULL)    
159.     {    
160.         m_strErrorMsg   = _T("数据库命令对象创建失败");    
161.         return  false;    
162.     }    
163.     if(m_ptrRecordset==NULL)    
164.     {    
165.         m_strErrorMsg   = _T("数据库记录集对象创建失败");    
166.         return  false;    
167.     }    
168.     if(m_ptrConnection==NULL)    
169.     {    
170.         m_strErrorMsg   = _T("数据库连接对象创建失败");    
171.         return  false;    
172.     }    
173.     
174.     //设置变量     
175.     m_ptrCommand->CommandType    = adCmdStoredProc;    
176.     return  true;    
177. }    
178.     
179. void CDBAdo::DetectResult(HRESULT hResult)    
180. {    
181.     if(FAILED(hResult))    
182.         _com_issue_error(hResult);    
183. }    
184.     
185. void CDBAdo::RecordErrorMsg(_com_error comError)    
186. {    
187.     _bstr_t bstrDescribe(comError.Description());    
188.     
189.     m_strErrorMsg.Format(TEXT("ADO 错误：0x%8x，%s"), comError.Error(), (LPCTSTR)bstrDescribe);    
190. }    
191.     
192. bool CDBAdo::SetConnectionString(CString strDriver, CString strIP, WORD wPort, CString strCatalog, CString strUserID, CString strPassword)    
193. {    
194.     CString strProvider, strPWD, strUID, strData, strDataSrc;    
195.     
196.     strProvider.Format(_T("Provider=%s;"), strProvider);    
197.     strPWD.Format(_T("Password=%s;"), strPassword);    
198.     strUID.Format(_T("User ID=%s;"), strUserID);    
199.     strData.Format(_T("Initial Catalog=%s;"), strCatalog);    
200.     strDataSrc.Format(_T("Data Source=%s,%ld;"), strIP, wPort);    
201.     
202.     //构造连接字符串     
203.     m_strConnect    = strProvider+strPWD+_T("Persist Security Info=True;")+strUID+strData+strDataSrc;    
204.     
205.     return true;    
206. }    
207.     
208. bool CDBAdo::SetConnectionString(CString strDriver, CString strDataSrc, CString strPassword)    
209. {    
210.     CString strProvider, strDataSource, strPWD;    
211.     
212.     strProvider.Format(_T("Provider=%s;"), strDriver);    
213.     strDataSource.Format(_T("Data Source=%s;"), strDataSrc);    
214.     strPWD.Format(_T("Jet OLEDB:DataBase Password=%s;"), strPassword);    
215.     
216.     //构造连接字符串     
217.     m_strConnect    = strProvider+_T("User ID=Admin;")+strDataSource+strPWD;    
218.     
219.     return true;    
220. }    
221.     
222. bool CDBAdo::OpenConnection()    
223. {    
224.     try    
225.     {    
226.         //关闭连接     
227.         CloseConnection();    
228.     
229.         //连接数据库     
230.         DetectResult(m_ptrConnection->Open(_bstr_t(m_strConnect), "", "", adModeUnknown));    
231.         m_ptrConnection->CursorLocation  = adUseClient;    
232.         m_ptrCommand->ActiveConnection   = m_ptrConnection;    
233.     
234.         return true;    
235.     }    
236.     catch(_com_error& comError)     
237.     {    
238.         RecordErrorMsg(comError);    
239.     }    
240.     
241.     return false;    
242. }    
243.     
244. bool CDBAdo::CloseConnection()    
245. {    
246.     try    
247.     {    
248.         CloseRecordset();    
249.         if((m_ptrConnection!=NULL)&&(m_ptrConnection->GetState()!=adStateClosed))    
250.             DetectResult(m_ptrConnection->Close());    
251.     
252.         return true;    
253.     }    
254.     catch(_com_error& comError)    
255.     {    
256.         RecordErrorMsg(comError);    
257.     }    
258.     
259.     return false;    
260. }    
261.     
262. bool CDBAdo::IsConnecting()    
263. {    
264.     try     
265.     {    
266.         //状态判断     
267.         if(m_ptrConnection==NULL)    
268.             return  false;    
269.         if(m_ptrConnection->GetState()==adStateClosed)    
270.             return  false;    
271.     
272.         //参数判断     
273.         long    lErrorCount = m_ptrConnection->Errors->Count;    
274.         if(lErrorCount>0L)    
275.         {    
276.             ErrorPtr    pError   = NULL;    
277.             for(long i=0; i<lErrorCount; i++)    
278.             {    
279.                 pError  = m_ptrConnection->Errors->GetItem(i);    
280.                 if(pError->Number==0x80004005)    
281.                     return  false;    
282.             }    
283.         }    
284.     
285.         return true;    
286.     }    
287.     catch(_com_error& comError)    
288.     {    
289.         RecordErrorMsg(comError);    
290.     }    
291.     
292.     return false;    
293. }    
294.     
295. bool CDBAdo::OpenRecordset(char* szSQL)    
296. {    
297.     try    
298.     {    
299.         //关闭记录集     
300.         CloseRecordset();    
301.     
302.         m_ptrRecordset->Open(szSQL, m_ptrConnection.GetInterfacePtr(), adOpenDynamic, adLockOptimistic, adCmdText);    
303.     
304.         return true;    
305.     }    
306.     catch(_com_error& comError)    
307.     {    
308.         RecordErrorMsg(comError);    
309.     }    
310.     
311.     return  false;    
312. }    
313.     
314. bool CDBAdo::CloseRecordset()    
315. {    
316.     try    
317.     {    
318.         if(IsRecordsetOpened())    
319.             DetectResult(m_ptrRecordset->Close());    
320.         return true;    
321.     }    
322.     catch(_com_error& comError)    
323.     {    
324.         RecordErrorMsg(comError);    
325.     }    
326.     
327.     return false;    
328. }    
329.     
330. bool CDBAdo::IsRecordsetOpened()    
331. {    
332.     if(m_ptrRecordset==NULL)    
333.         return  false;    
334.     if(m_ptrRecordset->GetState()==adStateClosed)    
335.         return  false;    
336.     
337.     return true;    
338. }    
339.     
340. bool CDBAdo::IsEndRecordset()    
341. {    
342.     try     
343.     {    
344.         return (m_ptrRecordset->EndOfFile==VARIANT_TRUE);    
345.     }    
346.     catch(_com_error& comError)    
347.     {    
348.         RecordErrorMsg(comError);    
349.     }    
350.     
351.     return true;    
352. }    
353.     
354. void CDBAdo::MoveToNext()    
355. {    
356.     try     
357.     {     
358.         m_ptrRecordset->MoveNext();     
359.     }    
360.     catch(_com_error& comError)    
361.     {    
362.         RecordErrorMsg(comError);    
363.     }    
364. }    
365.     
366. void CDBAdo::MoveToFirst()    
367. {    
368.     try     
369.     {     
370.         m_ptrRecordset->MoveFirst();     
371.     }    
372.     catch(_com_error& comError)    
373.     {    
374.         RecordErrorMsg(comError);    
375.     }    
376. }    
377.     
378. void CDBAdo::MoveToLast()    
379. {    
380.     try     
381.     {     
382.         m_ptrRecordset->MoveLast();     
383.     }    
384.     catch(_com_error& comError)    
385.     {    
386.         RecordErrorMsg(comError);    
387.     }    
388. }    
389.     
390. long CDBAdo::GetRecordCount()    
391. {    
392.     try    
393.     {    
394.         if(m_ptrRecordset==NULL)    
395.             return  0;    
396.         return  m_ptrRecordset->GetRecordCount();    
397.     }    
398.     catch(_com_error& comError)    
399.     {    
400.         RecordErrorMsg(comError);    
401.     }    
402.     
403.     return 0;    
404. }    
405.     
406. void CDBAdo::ClearAllParameters()    
407. {    
408.     try     
409.     {    
410.         long    lParamCount = m_ptrCommand->Parameters->Count;    
411.         if(lParamCount>0L)    
412.         {    
413.             for(long i=lParamCount; i>0; i--)    
414.             {    
415.                 _variant_t  vtIndex;    
416.     
417.                 vtIndex.intVal  = i-1;    
418.                 m_ptrCommand->Parameters->Delete(vtIndex);    
419.             }    
420.         }    
421.     }    
422.     catch(_com_error& comError)    
423.     {    
424.         RecordErrorMsg(comError);    
425.     }    
426. }    
427.     
428. void CDBAdo::AddParamter(LPCTSTR lpcsrName, ADOWE::ParameterDirectionEnum Direction, ADOWE::DataTypeEnum Type, long lSize, _variant_t & vtValue)    
429. {    
430.     ASSERT(lpcsrName!=NULL);    
431.     try     
432.     {    
433.         _ParameterPtr   Parameter   = m_ptrCommand->CreateParameter(lpcsrName, Type, Direction, lSize, vtValue);    
434.         m_ptrCommand->Parameters->Append(Parameter);    
435.     }    
436.     catch(_com_error& comError)    
437.     {    
438.         RecordErrorMsg(comError);    
439.     }    
440. }    
441.     
442. void CDBAdo::SetSPName(LPCTSTR lpcsrSPName)    
443. {    
444.     try     
445.     {     
446.         m_ptrCommand->CommandText    = lpcsrSPName;     
447.     }    
448.     catch(_com_error& comError)    
449.     {    
450.         RecordErrorMsg(comError);    
451.     }    
452. }    
453.     
454. bool CDBAdo::ExecuteCommand(bool bIsRecordset)    
455. {    
456.     try     
457.     {    
458.         //关闭记录集     
459.         CloseRecordset();    
460.         //执行命令     
461.         if(bIsRecordset)    
462.         {    
463.             m_ptrRecordset->PutRefSource(m_ptrCommand);    
464.             m_ptrRecordset->CursorLocation   = adUseClient;    
465.             DetectResult(m_ptrRecordset->Open((IDispatch*)m_ptrCommand, vtMissing, adOpenForwardOnly, adLockReadOnly, adOptionUnspecified));    
466.         }else     
467.         {    
468.             m_ptrConnection->CursorLocation  = adUseClient;    
469.             DetectResult(m_ptrCommand->Execute(NULL, NULL, adExecuteNoRecords));    
470.         }    
471.         return  true;    
472.     }    
473.     catch(_com_error& comError)    
474.     {    
475.         RecordErrorMsg(comError);    
476.     }    
477.     
478.     return  false;    
479. }    
480.     
481. bool CDBAdo::Execute(LPCTSTR lpcsrCommand)    
482. {    
483.     try    
484.     {    
485.         m_ptrConnection->CursorLocation  = adUseClient;    
486.         m_ptrConnection->Execute(lpcsrCommand, NULL, adExecuteNoRecords);    
487.         return  true;    
488.     }    
489.     catch(_com_error& comError)    
490.     {    
491.         RecordErrorMsg(comError);    
492.     }    
493.     
494.     return  false;    
495. }    
496.     
497. long CDBAdo::GetReturnValue()    
498. {    
499.     try     
500.     {    
501.         _ParameterPtr   ptrParam;    
502.         long            lParameterCount = m_ptrCommand->Parameters->Count;    
503.         for(long i=0; i<lParameterCount; i++)    
504.         {    
505.             ptrParam    = m_ptrCommand->Parameters->Item[i];    
506.             if(ptrParam->Direction==adParamReturnValue)    
507.                 return  ptrParam->Value.lVal;    
508.         }    
509.     }    
510.     catch(_com_error& comError)    
511.     {    
512.         RecordErrorMsg(comError);    
513.     }    
514.     
515.     return  0;    
516. }    
517.     
518. bool CDBAdo::GetFieldValue(LPCTSTR lpcsrFieldName, WORD& wValue)    
519. {    
520.     wValue  = 0L;    
521.     try    
522.     {    
523.         _variant_t  vtFld   = m_ptrRecordset->Fields->GetItem(lpcsrFieldName)->Value;    
524.         if((vtFld.vt!=VT_NULL)&&(vtFld.vt!=VT_EMPTY))    
525.             wValue  = (WORD)vtFld.ulVal;    
526.     
527.         return true;    
528.     }    
529.     catch(_com_error& comError)    
530.     {    
531.         RecordErrorMsg(comError);    
532.     }    
533.     
534.     return false;    
535. }    
536.     
537. bool CDBAdo::GetFieldValue(LPCTSTR lpcsrFieldName, CString& strValue)    
538. {    
539.     try    
540.     {    
541.         _variant_t vtFld    = m_ptrRecordset->Fields->GetItem(lpcsrFieldName)->Value;    
542.         if(vtFld.vt==VT_BSTR)    
543.         {    
544.             strValue    = (char*)_bstr_t(vtFld);    
545.             strValue.TrimLeft();    
546.             return  true;    
547.         }    
548.         return  false;    
549.     }    
550.     catch(_com_error& comError)    
551.     {    
552.         RecordErrorMsg(comError);    
553.     }    
554.     
555.     return  false;    
556. }    
557.     
558. bool CDBAdo::GetFieldValue(LPCTSTR lpcsrFieldName, INT& nValue)    
559. {    
560.     nValue  = 0;    
561.     try    
562.     {    
563.         _variant_t vtFld = m_ptrRecordset->Fields->GetItem(lpcsrFieldName)->Value;    
564.         switch(vtFld.vt)    
565.         {    
566.         case VT_BOOL:    
567.             {    
568.                 nValue  = vtFld.boolVal;    
569.                 break;    
570.             }    
571.         case VT_I2:    
572.         case VT_UI1:    
573.             {    
574.                 nValue  = vtFld.iVal;    
575.                 break;    
576.             }    
577.         case VT_NULL:    
578.         case VT_EMPTY:    
579.             {    
580.                 nValue  = 0;    
581.                 break;    
582.             }    
583.         default: nValue = vtFld.iVal;    
584.         }       
585.         return true;    
586.     }    
587.     catch(_com_error& comError)    
588.     {    
589.         RecordErrorMsg(comError);    
590.     }    
591.     
592.     return false;    
593. }    
594.     
595. bool CDBAdo::GetFieldValue(LPCTSTR lpcsrFieldName, BYTE& bValue)    
596. {    
597.     bValue  = 0;    
598.     try    
599.     {    
600.         _variant_t vtFld    = m_ptrRecordset->Fields->GetItem(lpcsrFieldName)->Value;    
601.         switch(vtFld.vt)    
602.         {    
603.         case VT_BOOL:    
604.             {    
605.                 bValue  = (vtFld.boolVal!=0)?1:0;    
606.                 break;    
607.             }    
608.         case VT_I2:    
609.         case VT_UI1:    
610.             {    
611.                 bValue  = (vtFld.iVal>0)?1:0;    
612.                 break;    
613.             }    
614.         case VT_NULL:    
615.         case VT_EMPTY:    
616.             {    
617.                 bValue  = 0;    
618.                 break;    
619.             }    
620.         default: bValue = (BYTE)vtFld.iVal;    
621.         }       
622.         return true;    
623.     }    
624.     catch(_com_error& comError)    
625.     {    
626.         RecordErrorMsg(comError);    
627.     }    
628.     
629.     return  false;    
630. }    
631. bool CDBAdo::GetFieldValue(LPCTSTR lpcsrFieldName, UINT& ulValue)    
632. {    
633.     ulValue = 0L;    
634.     try    
635.     {    
636.         _variant_t  vtFld   = m_ptrRecordset->Fields->GetItem(lpcsrFieldName)->Value;    
637.         if((vtFld.vt!=VT_NULL)&&(vtFld.vt!=VT_EMPTY))    
638.             ulValue = vtFld.lVal;    
639.         return  true;    
640.     }    
641.     catch(_com_error& comError)    
642.     {    
643.         RecordErrorMsg(comError);    
644.     }    
645.     
646.     return  false;    
647. }    
648. bool CDBAdo::GetFieldValue(LPCTSTR lpcsrFieldName, DOUBLE& dbValue)    
649. {    
650.     dbValue=0.0L;    
651.     try    
652.     {    
653.         _variant_t  vtFld   = m_ptrRecordset->Fields->GetItem(lpcsrFieldName)->Value;    
654.         switch(vtFld.vt)    
655.         {    
656.         case VT_R4:dbValue  = vtFld.fltVal;break;    
657.         case VT_R8:dbValue  = vtFld.dblVal;break;    
658.         case VT_DECIMAL:    
659.             {    
660.                 dbValue  = vtFld.decVal.Lo32;    
661.                 dbValue *= (vtFld.decVal.sign==128)?-1:1;    
662.                 dbValue /= pow((float)10,vtFld.decVal.scale);    
663.             }    
664.             break;    
665.         case VT_UI1:dbValue = vtFld.iVal;break;    
666.         case VT_I2:    
667.         case VT_I4:dbValue  = vtFld.lVal;break;    
668.         case VT_NULL:    
669.         case VT_EMPTY:dbValue   = 0.0L;break;    
670.         default:dbValue = vtFld.dblVal;    
671.         }    
672.         return true;    
673.     }    
674.     catch(_com_error& comError)    
675.     {    
676.         RecordErrorMsg(comError);    
677.     }    
678.     
679.     return  false;    
680. }    
681. bool CDBAdo::GetFieldValue(LPCTSTR lpcsrFieldName, LONG& lValue)    
682. {    
683.     lValue  = 0L;    
684.     try    
685.     {    
686.         _variant_t  vtFld   = m_ptrRecordset->Fields->GetItem(lpcsrFieldName)->Value;    
687.         if((vtFld.vt!=VT_NULL)&&(vtFld.vt!=VT_EMPTY))    
688.             lValue  = vtFld.lVal;    
689.         return  true;    
690.     }    
691.     catch(_com_error& comError)    
692.     {    
693.         RecordErrorMsg(comError);    
694.     }    
695.     
696.     return  false;    
697. }    
698. bool CDBAdo::GetFieldValue(LPCTSTR lpcsrFieldName, DWORD& dwValue)    
699. {    
700.     dwValue = 0L;    
701.     try    
702.     {    
703.         _variant_t  vtFld   = m_ptrRecordset->Fields->GetItem(lpcsrFieldName)->Value;    
704.         if((vtFld.vt!=VT_NULL)&&(vtFld.vt!=VT_EMPTY))    
705.             dwValue = vtFld.ulVal;    
706.         return  true;    
707.     }    
708.     catch(_com_error& comError)    
709.     {    
710.         RecordErrorMsg(comError);    
711.     }    
712.     
713.     return  false;    
714. }    
715. bool CDBAdo::GetFieldValue(LPCTSTR lpcsrFieldName, __int64& llValue)    
716. {    
717.     llValue = 0L;    
718.     try    
719.     {    
720.         _variant_t  vtFld   = m_ptrRecordset->Fields->GetItem(lpcsrFieldName)->Value;    
721.         if((vtFld.vt!=VT_NULL)&&(vtFld.vt!=VT_EMPTY))    
722.             llValue=vtFld.lVal;    
723.     
724.         return  true;    
725.     }    
726.     catch(_com_error& comError)    
727.     {    
728.         RecordErrorMsg(comError);    
729.     }    
730.     
731.     return  false;    
732. }    
733. bool CDBAdo::GetFieldValue(LPCTSTR lpcsrFieldName, COleDateTime& Time)    
734. {    
735.     try    
736.     {    
737.         _variant_t  vtFld   = m_ptrRecordset->Fields->GetItem(lpcsrFieldName)->Value;    
738.         switch(vtFld.vt)     
739.         {    
740.         case VT_DATE:    
741.             {    
742.                 COleDateTime    TempTime(vtFld);    
743.                 Time    = TempTime;    
744.             }break;    
745.         case VT_EMPTY:    
746.         case VT_NULL:Time.SetStatus(COleDateTime::null);break;    
747.         default: return false;    
748.         }    
749.         return  true;    
750.     }    
751.     catch(_com_error& comError)    
752.     {    
753.         RecordErrorMsg(comError);    
754.     }    
755.     
756.     return  false;    
757. }    
758.     
759. bool CDBAdo::GetFieldValue(LPCTSTR lpcsrFieldName, bool& bValue)    
760. {    
761.     try    
762.     {    
763.         _variant_t  vtFld   = m_ptrRecordset->Fields->GetItem(lpcsrFieldName)->Value;    
764.         switch(vtFld.vt)     
765.         {    
766.         case VT_BOOL:bValue=(vtFld.boolVal==0)?false:true;break;    
767.         case VT_EMPTY:    
768.         case VT_NULL:bValue = false;break;    
769.         default:return false;    
770.         }    
771.     
772.         return  true;    
773.     }    
774.     catch(_com_error& comError)    
775.     {    
776.         RecordErrorMsg(comError);    
777.     }    
778.     
779.     return  false;    
780. }