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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 数据库编程 > 查看源码
QueryDef.cpp
资源名称：querydef.zip　[点击查看]
上传用户：yunnanyeer
上传日期：2007-01-03
资源大小：86k
文件大小：32k
源码类别：

数据库编程

开发平台：

Visual C++

QueryDef.cpp：源码内容
  1. // QueryDef.cpp : Defines the initialization routines for the DLL.
  2. //
  4. #include "stdafx.h"
  5. #include <afxdllx.h>
  6. #include "QueryDef.h"
  8. #ifdef _DEBUG
  9. #define new DEBUG_NEW
  10. #undef THIS_FILE
  11. static char THIS_FILE[] = __FILE__;
  12. #endif
  15. static AFX_EXTENSION_MODULE QueryDefDLL = { NULL, NULL };
  17. extern "C" int APIENTRY
  18. DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
  19. {
  20. UNREFERENCED_PARAMETER(lpReserved);
  22. if (dwReason == DLL_PROCESS_ATTACH)
  23. {
  24. TRACE0("QUERYDEF.DLL Initializing!n");
  26. if (!AfxInitExtensionModule(QueryDefDLL, hInstance))
  27. return 0;
  29. new CDynLinkLibrary(QueryDefDLL);
  30. }
  31. else if (dwReason == DLL_PROCESS_DETACH)
  32. {
  33. TRACE0("QUERYDEF.DLL Terminating!n");
  34. AfxTermExtensionModule(QueryDefDLL);
  35. }
  36. return 1;
  37. }
  39. namespace QueryDef // use using namespace QueryDef or
  40. { // better USE_QUERYDEF macro
  42. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  43. // CQueryVariant Class
  44. //
  45. /*
  46. template <> void AFXAPI ConstructElements <QueryDef::CQueryVar>(QueryDef::CQueryVar* pNewQueryVar,int nCount)
  47. {
  48. #if defined(_DEBUG)
  49. #undef new
  50. #endif
  51. for ( int i = 0; i < nCount; i++, pNewQueryVar++ )
  52.         // call CQueryVar default constructor directly
  53.         new (pNewQueryVar) QueryDef::CQueryVar;
  54. }
  55. */
  56. void CQueryVariant::ConstructObject()
  57. {
  58. m_decPlaces = 2; // two decimal digits by default
  59. m_dateFormat = "%d/%m/%Y %H:%M"; // default date time format
  60. }
  62. CQueryVariant::CQueryVariant()
  63. {
  64. ConstructObject();
  65. m_varDB.Add(CQueryVar());
  66. }
  68. CQueryVariant::~CQueryVariant()
  69. {
  70. }
  72. CQueryVariant::CQueryVariant(LPCTSTR str)
  73. {
  74. ConstructObject();
  75. m_varDB.Add(CQueryVar(str));
  76. }
  78. CQueryVariant::CQueryVariant(int i)
  79. {
  80. ConstructObject();
  81. m_varDB.Add(CQueryVar(i));
  82. }
  84. CQueryVariant::CQueryVariant(long l)
  85. {
  86. ConstructObject();
  87. m_varDB.Add(CQueryVar(l));
  88. }
  90. CQueryVariant::CQueryVariant(short s)
  91. {
  92. ConstructObject();
  93. m_varDB.Add(CQueryVar(s));
  94. }
  96. CQueryVariant::CQueryVariant(float f)
  97. {
  98. ConstructObject();
  99. m_varDB.Add(CQueryVar(f));
  100. }
  102. CQueryVariant::CQueryVariant(double d)
  103. {
  104. ConstructObject();
  105. m_varDB.Add(CQueryVar(d));
  106. }
  108. CQueryVariant::CQueryVariant(COleDateTime& t)
  109. {
  110. ConstructObject();
  111. m_varDB.Add(CQueryVar(t));
  112. }
  114. CQueryVariant::CQueryVariant(CLongBinary& lB)
  115. {
  116. ConstructObject();
  117. m_varDB.Add(CQueryVar(lB));
  118. }
  120. // CQueryVariant conversion operators
  122. CQueryVariant::operator CString()
  123. {
  124. return (CString)(m_varDB[0]);
  125. }
  127. CQueryVariant::operator BYTE()
  128. {
  129. return (BYTE)(m_varDB[0]);
  130. }
  132. CQueryVariant::operator int()
  133. {
  134. return (int)(m_varDB[0]);
  135. }
  137. CQueryVariant::operator long()
  138. {
  139. return (long)(m_varDB[0]);
  140. }
  142. CQueryVariant::operator short()
  143. {
  144. return (short)(m_varDB[0]);
  145. }
  147. CQueryVariant::operator float()
  148. {
  149. return (float)(m_varDB[0]);
  150. }
  152. CQueryVariant::operator double()
  153. {
  154. return (double)(m_varDB[0]);
  155. }
  157. CQueryVariant::operator COleDateTime&()
  158. {
  159. return m_varDB[0].operator COleDateTime&();
  160. }
  162. CQueryVariant::operator CLongBinary&()
  163. {
  164. return (CLongBinary&)(m_varDB[0]);
  165. }
  167. CQueryVariant::operator LPCTSTR()
  168. {
  169. return (LPCTSTR)m_varDB[0];
  170. }
  172. CQueryVariant& CQueryVariant::operator=(CStringArray& src) // converts all columns to strings
  173. {
  174. src.SetSize(m_varDB.GetSize()); // make the two arrays equal length
  176. for (WORD i = 0; i < m_varDB.GetSize(); i++)
  177. src[i] = m_varDB.GetAt(i);
  179. return *this;
  180. }
  182. CQueryVar& CQueryVariant::operator[](int i)
  183. {
  184. if (i >= m_varDB.GetSize())
  185. SetSize(i+1);
  187. return m_varDB.ElementAt(i);
  188. }
  190. CQueryVariant& CQueryVariant::operator=(CQueryVariant& v)
  191. {
  192. m_decPlaces = v.m_decPlaces;
  193. m_dateFormat = v.m_dateFormat;
  195. m_varDB.SetSize(v.m_varDB.GetSize());
  197. for (WORD i = 0; i < m_varDB.GetSize(); i++)
  198. m_varDB[i] = v.m_varDB[i];
  200. return *this;
  201. }
  203. short CQueryVariant::SetDecimalDigits(short d)
  204. {
  205. short prevDecPlaces = m_decPlaces;
  206. m_decPlaces = d;
  208. for (WORD i = 0; i < m_varDB.GetSize(); i++)
  209. m_varDB[i].SetDecimalDigits(d);
  211. return prevDecPlaces;
  212. }
  214. LPCSTR CQueryVariant::SetDateFormat(LPCSTR strDateFormat)
  215. {
  216. CString oldDateFormat = m_dateFormat;
  217. m_dateFormat = strDateFormat;
  219. for (WORD i = 0; i < m_varDB.GetSize(); i++)
  220. m_varDB[i].SetDateFormat(strDateFormat);
  222. return oldDateFormat;
  223. }
  225. void CQueryVariant::SetSize(int nNewSize)
  226. {
  227. int i,nOldSize = m_varDB.GetSize();
  229. m_varDB.SetSize(nNewSize); // calls the CQueryVar constructor
  231. for (i = nOldSize; i < nNewSize; i++)
  232. {
  233. m_varDB[i].m_decPlaces = m_decPlaces;
  234. m_varDB[i].m_dateFormat = m_dateFormat;
  235. }
  236. }
  238. //////////////////////////////////////////////////////////////////////
  239. // CQueryVar Class
  240. //////////////////////////////////////////////////////////////////////
  241. void CQueryVar::ConstructObject()
  242. {
  243. m_decPlaces = 2; // two decimal digits by default
  244. m_dateFormat = "%d/%m/%Y %H:%M"; // default date time format
  246. m_allocFlags = eAllocNothing;
  247. }
  249. CQueryVar::CQueryVar()
  250. {
  251. ConstructObject();
  252. m_dwType = DBVT_NULL;
  253. }
  255. CQueryVar::~CQueryVar()
  256. { // may be marked as NULL but with
  257. if (m_dwType != DBVT_NULL) // buffers allocated due to a
  258. return; // AddNew or Edit applied on a
  259. // subsequent CQueryDef container
  260. if (m_allocFlags == eAllocString)
  261. delete m_pstring;
  262. else if (m_allocFlags == eAllocDate)
  263. delete m_pdate;
  264. else if (m_allocFlags == eAllocBinary)
  265. delete m_pbinary;
  266. }
  268. CQueryVar::CQueryVar(LPCTSTR str)
  269. {
  270. ConstructObject();
  271. m_pstring = new CString();
  272. *m_pstring = str;
  273. m_allocFlags = eAllocString;
  274. m_dwType = DBVT_STRING;
  275. }
  277. CQueryVar::CQueryVar(int i)
  278. {
  279. ConstructObject();
  280. m_dwType = DBVT_LONG;
  281. m_lVal = i;
  282. }
  284. CQueryVar::CQueryVar(long l)
  285. {
  286. ConstructObject();
  287. m_lVal = l;
  288. m_dwType = DBVT_LONG;
  289. }
  291. CQueryVar::CQueryVar(short s)
  292. {
  293. ConstructObject();
  294. m_iVal = s;
  295. m_dwType = DBVT_SHORT;
  296. }
  298. CQueryVar::CQueryVar(float f)
  299. {
  300. ConstructObject();
  301. m_fltVal = f;
  302. m_dwType = DBVT_SINGLE;
  303. }
  305. CQueryVar::CQueryVar(double d)
  306. {
  307. ConstructObject();
  308. m_dblVal = d;
  309. m_dwType = DBVT_DOUBLE;
  310. }
  312. CQueryVar::CQueryVar(COleDateTime& t)
  313. {
  314. ConstructObject();
  315. m_pdate = new TIMESTAMP_STRUCT;
  316. m_allocFlags = eAllocDate;
  317. m_pdate->year    = (SWORD)t.GetYear();
  318. m_pdate->month   = t.GetMonth();
  319. m_pdate->day     = t.GetDay();
  320. m_pdate->hour    = t.GetHour();
  321. m_pdate->minute  = t.GetMinute();
  322. m_pdate->second  = t.GetSecond();
  323. m_pdate->fraction = 0;
  324. m_dwType = DBVT_DATE;
  325. }
  327. CQueryVar::CQueryVar(CLongBinary& lB)
  328. {
  329. void* pSrc;
  330. void* pDest;
  332. ConstructObject();
  333. m_pbinary = new CLongBinary;
  334. m_allocFlags = eAllocBinary;
  336. m_pbinary->m_hData = GlobalAlloc(GMEM_MOVEABLE,lB.m_dwDataLength);
  338. pSrc  = GlobalLock(lB.m_hData);
  339. pDest = GlobalLock(m_pbinary->m_hData);
  341. memcpy(pDest,pSrc,lB.m_dwDataLength);
  343. GlobalUnlock(lB.m_hData);
  344. GlobalUnlock(m_pbinary->m_hData);
  346. m_pbinary->m_dwDataLength = lB.m_dwDataLength;
  347. m_dwType = DBVT_BINARY;
  348. }
  350. // CQueryVar changes data type
  351. void CQueryVar::ChangeDataType(int allocFlags)
  352. {
  353. if (allocFlags == m_allocFlags)
  354. return;
  356. switch (m_allocFlags)
  357. {
  358. case eAllocString:
  359. delete m_pstring;
  360. break;
  362. case eAllocDate:
  363. delete m_pdate;
  364. break;
  366. case eAllocBinary:
  367. delete m_pbinary;
  368. break;
  369. }
  371. switch (allocFlags)
  372. {
  373. case eAllocString:
  374. m_pstring = new CString;
  375. break;
  377. case eAllocDate:
  378. m_pdate = new TIMESTAMP_STRUCT;
  379. break;
  381. case eAllocBinary:
  382. m_pbinary = new CLongBinary;
  383. m_pbinary->m_dwDataLength = 0;
  384. break;
  385. }
  387. m_allocFlags = allocFlags;
  388. }
  390. // CQueryVar conversion operators
  392. CQueryVar::operator LPCTSTR()
  393. {
  394. return ToString();
  395. }
  397. LPCTSTR CQueryVar::ToString()
  398. {
  399. CString strFormat;
  400. COleDateTime d;
  401. void* pbinary;
  403. switch (m_dwType)
  404. {
  405. case DBVT_NULL:
  406. break;
  408. case DBVT_BOOL:
  409. m_convert = m_boolVal? '1' : '0';
  410. break;
  412. case DBVT_UCHAR:
  413. m_convert.Format("%c",m_chVal);
  414. break;
  416. case DBVT_SHORT:
  417. m_convert.Format("%d",m_iVal);
  418. break;
  420. case DBVT_LONG:
  421. m_convert.Format("%ld",m_lVal);
  422. break;
  424. case DBVT_SINGLE:
  425. strFormat.Format("%%.%df",m_decPlaces);
  426. m_convert.Format(strFormat,m_fltVal);
  427. break;
  429. case DBVT_DOUBLE:
  430. strFormat.Format("%%.%dlf",m_decPlaces);
  431. m_convert.Format(strFormat,m_dblVal);
  432. break;
  434. case DBVT_DATE:
  435. d = operator COleDateTime&();
  437. m_convert = d.Format(m_dateFormat);
  438. break;
  440. case DBVT_STRING:
  441. m_convert = *m_pstring;
  442. break;
  444. case DBVT_BINARY:
  445. if (m_pbinary->m_dwDataLength > MAX_SHORT) // the BLOB is converted if less
  446. throw CQueryVariant::eMemoryLimit;
  448. pbinary = GlobalLock(m_pbinary->m_hData);
  449. if (pbinary)
  450. {
  451. m_convert = ConvertToHex(pbinary,m_pbinary->m_dwDataLength);
  452. GlobalUnlock(m_pbinary->m_hData);
  453. }
  455. break;
  457. default:
  458. throw CQueryVar::eConversionError;
  459. }
  461. return m_convert;
  462. }
  464. CQueryVar::operator BYTE()
  465. {
  466. switch (m_dwType)
  467. {
  468. case DBVT_UCHAR:
  469. return m_chVal;
  470. case DBVT_BOOL:
  471. return m_boolVal;
  472. case DBVT_SHORT:
  473. return (BYTE)m_iVal;
  474. case DBVT_LONG:
  475. return (BYTE)m_lVal;
  476. default:
  477. throw CQueryVar::eConversionError;
  478. }
  480. return m_chVal;
  481. }
  483. CQueryVar::operator int()
  484. {
  485. switch (m_dwType)
  486. {
  487. case DBVT_UCHAR:
  488. return m_chVal;
  489. case DBVT_SHORT:
  490. return m_iVal;
  491. case DBVT_BOOL:
  492. return m_boolVal;
  493. case DBVT_LONG:
  494. return m_lVal;
  495. default:
  496. throw CQueryVar::eConversionError;
  497. }
  499. return m_lVal;
  500. }
  502. CQueryVar::operator long()
  503. {
  504. switch (m_dwType)
  505. {
  506. case DBVT_LONG:
  507. return m_lVal;
  508. case DBVT_UCHAR:
  509. return m_chVal;
  510. case DBVT_SHORT:
  511. return m_iVal;
  512. case DBVT_BOOL:
  513. return m_boolVal;
  514. default:
  515. throw CQueryVar::eConversionError;
  516. }
  518. return m_lVal;
  519. }
  521. CQueryVar::operator short()
  522. {
  523. switch (m_dwType)
  524. {
  525. case DBVT_UCHAR:
  526. return m_chVal;
  527. case DBVT_SHORT:
  528. return m_iVal;
  529. case DBVT_BOOL:
  530. return m_boolVal;
  531. default:
  532. throw CQueryVar::eConversionError;
  533. }
  535. return m_iVal;
  536. }
  538. CQueryVar::operator float()
  539. {
  540. switch (m_dwType)
  541. {
  542. case DBVT_UCHAR:
  543. return m_chVal;
  544. case DBVT_SHORT:
  545. return m_iVal;
  546. case DBVT_BOOL:
  547. return (float)m_boolVal;
  548. case DBVT_SINGLE:
  549. return m_fltVal;
  550. default:
  551. throw CQueryVar::eConversionError;
  552. }
  554. return m_fltVal;
  555. }
  557. CQueryVar::operator double()
  558. {
  559. switch (m_dwType)
  560. {
  561. case DBVT_LONG:
  562. return m_lVal;
  563. case DBVT_UCHAR:
  564. return m_chVal;
  565. case DBVT_SHORT:
  566. return m_iVal;
  567. case DBVT_BOOL:
  568. return m_boolVal;
  569. case DBVT_SINGLE:
  570. return m_fltVal;
  571. case DBVT_DOUBLE:
  572. return m_dblVal;
  573. default:
  574. throw CQueryVar::eConversionError;
  575. }
  577. return m_dblVal;
  578. }
  580. CQueryVar::operator void*()
  581. {
  582. switch (m_dwType)
  583. {
  584. case DBVT_NULL: // patching CQueryDef (AddNew and Edit)
  585. if (m_allocFlags == eAllocString)
  586. return (void*)m_pstring;
  587. else if (m_allocFlags == eAllocDate)
  588. return (void*)m_pdate;
  589. else if (m_allocFlags == eAllocBinary)
  590. return (void*)m_pbinary;
  591. break;
  593. case DBVT_BOOL:
  594. case DBVT_UCHAR:
  595. case DBVT_SHORT:
  596. case DBVT_LONG:
  597. case DBVT_SINGLE:
  598. case DBVT_DOUBLE:
  599. return (void*)&m_chVal;
  601. case DBVT_STRING:
  602. return (void*)m_pstring;
  604. case DBVT_DATE:
  605. return (void*)m_pdate;
  607. case DBVT_BINARY:
  608. return (void*)m_pbinary;
  609. }
  611. return (void*)&m_chVal;
  612. }
  614. CQueryVar::operator COleDateTime&()
  615. {
  616. static COleDateTime t;
  618. if (m_dwType != DBVT_DATE)
  619. throw CQueryVar::eConversionError;
  621. t.SetDateTime(m_pdate->year,m_pdate->month,m_pdate->day,m_pdate->hour,m_pdate->minute,m_pdate->second);
  623. return t;
  624. }
  626. CQueryVar::operator CLongBinary&()
  627. {
  628. if (m_dwType != DBVT_BINARY)
  629. throw CQueryVar::eConversionError;
  631. return *m_pbinary;
  632. }
  634. CQueryVar& CQueryVar::operator=(LPCTSTR str)
  635. {
  636. m_dwType = DBVT_STRING;
  637. ChangeDataType(eAllocString);
  638. *m_pstring = str;
  640. return *this;
  641. }
  643. CQueryVar& CQueryVar::operator=(UCHAR ch)
  644. {
  645. m_dwType = DBVT_UCHAR;
  646. ChangeDataType(eAllocNothing);
  647. m_chVal = ch;
  649. return *this;
  650. }
  652. CQueryVar& CQueryVar::operator=(int l)
  653. {
  654. m_dwType = DBVT_LONG;
  655. ChangeDataType(eAllocNothing);
  656. m_lVal = l;
  658. return *this;
  659. }
  661. CQueryVar& CQueryVar::operator=(long l)
  662. {
  663. m_dwType = DBVT_LONG;
  664. ChangeDataType(eAllocNothing);
  665. m_lVal = l;
  667. return *this;
  668. }
  670. CQueryVar& CQueryVar::operator=(short s)
  671. {
  672. m_dwType = DBVT_SHORT;
  673. ChangeDataType(eAllocNothing);
  674. m_iVal = s;
  676. return *this;
  677. }
  679. CQueryVar& CQueryVar::operator=(float f)
  680. {
  681. m_dwType = DBVT_SINGLE;
  682. ChangeDataType(eAllocNothing);
  683. m_fltVal = f;
  685. return *this;
  686. }
  688. CQueryVar& CQueryVar::operator=(double d)
  689. {
  690. m_dwType = DBVT_DOUBLE;
  691. ChangeDataType(eAllocNothing);
  692. m_dblVal = d;
  694. return *this;
  695. }
  697. CQueryVar& CQueryVar::operator=(COleDateTime& date)
  698. {
  699. m_dwType = DBVT_DATE;
  700. ChangeDataType(eAllocDate);
  702. m_pdate->year = date.GetYear();
  703. m_pdate->month = date.GetMonth();
  704. m_pdate->day = date.GetDay();
  705. m_pdate->hour = date.GetHour();
  706. m_pdate->minute = date.GetMinute();
  707. m_pdate->second = date.GetSecond();
  708. m_pdate->fraction = 0;
  710. return *this;
  711. }
  713. CQueryVar& CQueryVar::operator=(CLongBinary& lB)
  714. {
  715. void* pSrc;
  716. void* pDest;
  717. int allocFlags;
  719. m_dwType = DBVT_BINARY;
  720. allocFlags = m_allocFlags;
  722. ChangeDataType(eAllocBinary);
  724. if (allocFlags != eAllocBinary)
  725. m_pbinary->m_hData = GlobalAlloc(GMEM_MOVEABLE,lB.m_dwDataLength);
  726. else if (m_pbinary->m_dwDataLength != lB.m_dwDataLength)
  727. m_pbinary->m_hData = GlobalReAlloc(m_pbinary->m_hData,lB.m_dwDataLength,GMEM_MOVEABLE);
  729. pSrc  = GlobalLock(lB.m_hData);
  730. pDest = GlobalLock(m_pbinary->m_hData);
  732. memcpy(pDest,pSrc,lB.m_dwDataLength);
  734. GlobalUnlock(lB.m_hData);
  735. GlobalUnlock(m_pbinary->m_hData);
  737. m_pbinary->m_dwDataLength = lB.m_dwDataLength;
  739. return *this;
  740. }
  742. CQueryVar& CQueryVar::operator=(CQueryVar& v)
  743. {
  744. void* pSrc;
  745. void* pDest;
  746. int allocFlags;
  748. m_decPlaces = v.m_decPlaces;
  749. m_dateFormat= v.m_dateFormat;
  750. m_dwType = v.m_dwType;
  752. switch (m_dwType)
  753. {
  754. case DBVT_DATE:
  755. ChangeDataType(eAllocDate);
  756. memcpy(m_pdate,v.m_pdate,sizeof(TIMESTAMP_STRUCT));
  757. break;
  759. case DBVT_STRING:
  760. ChangeDataType(eAllocString);
  761. *m_pstring = *v.m_pstring;
  762. break;
  764. case DBVT_BINARY:
  765. allocFlags = m_allocFlags;
  767. ChangeDataType(eAllocBinary);
  769. if (allocFlags != eAllocBinary)
  770. m_pbinary->m_hData = GlobalAlloc(GMEM_MOVEABLE,v.m_pbinary->m_dwDataLength);
  771. else if (m_pbinary->m_dwDataLength != v.m_pbinary->m_dwDataLength)
  772. m_pbinary->m_hData = GlobalReAlloc(m_pbinary->m_hData,v.m_pbinary->m_dwDataLength,GMEM_MOVEABLE);
  774. pSrc  = GlobalLock(v.m_pbinary->m_hData);
  775. pDest = GlobalLock(m_pbinary->m_hData);
  777. memcpy(pDest,pSrc,v.m_pbinary->m_dwDataLength);
  779. GlobalUnlock(v.m_pbinary->m_hData);
  780. GlobalUnlock(m_pbinary->m_hData);
  782. m_pbinary->m_dwDataLength = v.m_pbinary->m_dwDataLength;
  783. break;
  785. case DBVT_NULL:
  786. ChangeDataType(eAllocNothing);
  787. break;
  789. default:
  790. ChangeDataType(eAllocNothing);
  792. m_boolVal = v.m_boolVal;
  793. m_chVal   = v.m_chVal;
  794. m_iVal    = v.m_iVal;
  795. m_lVal    = v.m_lVal;
  796. m_fltVal  = v.m_fltVal;
  797. m_dblVal  = v.m_dblVal;
  798. break;
  799. }
  801. return *this;
  802. }
  804. BOOL CQueryVar::operator==(CSQLNull& sqlNull)
  805. {
  806. return m_dwType == (DWORD)sqlNull.SqlNull;
  807. }
  809. BOOL CQueryVar::operator!=(CSQLNull& sqlNull)
  810. {
  811. return m_dwType != (DWORD)sqlNull.SqlNull;
  812. }
  814. short CQueryVar::SetDecimalDigits(short d)
  815. {
  816. short prevDecPlaces = m_decPlaces;
  817. m_decPlaces = d;
  819. return prevDecPlaces;
  820. }
  822. LPCSTR CQueryVar::SetDateFormat(LPCSTR strDateFormat)
  823. {
  824. CString oldDateFormat = m_dateFormat;
  825. m_dateFormat = strDateFormat;
  827. return oldDateFormat;
  828. }
  830. //////////////////////////////////////////////////////////////////////
  831. // V2.0 CQueryCol Class
  832. //
  833. CQueryCol::CQueryCol()
  834. {
  835. m_pValue   = NULL;
  836. m_pfldInfo = NULL;
  837. }
  839. CQueryCol::CQueryCol(CQueryVar& qv,CODBCFieldInfo& fi)
  840. {
  841. m_pValue   = &qv;
  842. m_pfldInfo = &fi;
  843. }
  845. CQueryCol::~CQueryCol()
  846. {
  847. }
  849. //////////////////////////////////////////////////////////////////////
  850. // CQueryDef Class
  851. //////////////////////////////////////////////////////////////////////
  852. IMPLEMENT_DYNAMIC(CQueryDef, CRecordset2)
  854. CQueryDef::CQueryDef(CDatabase* pDB) : CRecordset2(pDB)
  855. {
  856. m_nParams = 0;
  857. m_nFields = 0;
  859. m_nOpenType = CRecordset::forwardOnly; // helps implementation of ReOpen()
  860. m_dwOptions = CRecordset::readOnly;
  862. m_nMode = eModeNoMode;
  863. }
  865. CQueryDef::CQueryDef(CDatabase* pDB,LPCSTR strSelect) : CRecordset2(pDB)
  866. {
  867. m_nParams = 0;
  868. m_nFields = 0;
  870. m_nMode = eModeNoMode;
  872. Open(forwardOnly,strSelect,readOnly|noDirtyFieldCheck|executeDirect);
  873. }
  875. CQueryDef::~CQueryDef()
  876. {
  877. Close();
  878. }
  880. BOOL CQueryDef::Open(UINT nOpenType,LPCTSTR lpszSQL,DWORD dwOptions)
  881. {
  882. CString m_query;
  883. int i,maxQL;
  884. BOOL b;
  886. m_nOpenType = nOpenType; // helps implementation of ReOpen()
  887. m_strSQL = lpszSQL;
  888. m_dwOptions = dwOptions;
  890. m_originalQuery = lpszSQL;
  891. if (m_originalQuery.GetLength() == 0)
  892. m_originalQuery = GetDefaultSQL();
  894. for (maxQL = m_originalQuery.GetLength(), i = 0; i < maxQL; i++)
  895. {
  896. m_query += m_originalQuery[i];
  898. if (m_originalQuery[i] == '?')
  899. {
  900. m_ioParam[m_nParams] = 0;
  902. if (i+1 < maxQL && CString("LFDIYCBTX").Find(m_originalQuery[i+1]) != -1)
  903. m_ioParam[m_nParams] = m_originalQuery[++i];
  905. m_nParams++;
  906. }
  907. }
  909. m_cParam.SetSize(m_nParams);
  911. FreezeAllEvents(); // avoid NotifyMove before NotifyOpen
  912. b = CRecordset2::Open(nOpenType,m_query,dwOptions);
  913. FreezeAllEvents(FALSE); // restore notifications
  915. // V2.0 SQL column descriptors
  916. for (i = 0; i < GetODBCFieldCount(); i++)
  917. m_columns.Add(CQueryCol(m_cLine[i],m_ODBCFieldInfo[i]));
  919. NotifySink(eNotifyOpen); // is gotta be open then
  920. if (!IsEOF())
  921. NotifySink(eNotifyMove); // followed by move on the first record
  923. return b;
  924. }
  926. void CQueryDef::Close()
  927. {
  928. NotifySink(eNotifyClose);
  930. CRecordset2::Close();
  932. m_nFields = 0;
  933. m_nParams = 0;
  935. m_columns.RemoveAll();
  936. ClearEventSinkList();
  937. }
  939. BOOL CQueryDef::ReOpen(CDatabase* pDB)
  940. {
  941. if (IsOpen())
  942. Close();
  944. m_pDatabase = pDB;
  945. return Open(m_nOpenType,m_strSQL,m_dwOptions);
  946. }
  948. void CQueryDef::PreBindFields()
  949. {
  950. if (m_nFields == 0) // fetch columns information
  951. {
  952. m_nFields = GetODBCFieldCount();
  954. m_ODBCFieldInfo.SetSize(m_nFields);
  956. for (WORD i = 0; i < m_nFields; i++)
  957. GetODBCFieldInfo(i,m_ODBCFieldInfo[i]);
  959. m_cLine.SetSize(m_nFields); // make room for columns values
  960. }
  962. AllocStatusArrays(); // may change in future versions of MFC
  963. }
  965. void CQueryDef::AddNew()
  966. {
  967. m_nMode = eModeAddNew; // signal BindFields that an AddNew is in progress
  968. CRecordset2::AddNew();
  970. NotifySink(eNotifyAddNew);
  971. }
  973. void CQueryDef::Edit()
  974. {
  975. m_nMode = eModeEdit;
  976. CRecordset2::Edit();
  978. NotifySink(eNotifyEdit);
  979. }
  981. BOOL CQueryDef::Update()
  982. {
  983. BOOL bResult = CRecordset2::Update();
  984. m_nMode = eModeNoMode;
  986. NotifySink(eNotifyUpdate);
  988. return bResult;
  989. }
  991. void CQueryDef::Delete()
  992. {
  993. CRecordset2::Delete();
  994. NotifySink(eNotifyDelete);
  995. }
  997. BOOL CQueryDef::Requery()
  998. {
  999. BOOL b = CRecordset2::Requery();
  1001. NotifySink(eNotifyRequery);
  1002. return b;
  1003. }
  1005. void CQueryDef::CancelUpdate()
  1006. {
  1007. CRecordset2::CancelUpdate();
  1009. NotifySink(eNotifyCancelUpdate);
  1010. }
  1012. void CQueryDef::DoFieldExchange(CFieldExchange* pFX) // input/output parameters only
  1013. {
  1014. BindParams(pFX);
  1015. BindFields(pFX);
  1016. }
  1018. void CQueryDef::BindParams(CFieldExchange* pFX) // cannot have SQL_NULL outparams
  1019. {
  1020. USES_RecordsetPatch;
  1022. unsigned int i;
  1024. ASSERT(m_cParam.m_varDB.GetSize() == (WORD)m_nParams);
  1026. for (i = 0; i < m_nParams; i++)
  1027. {
  1028. pFX->SetFieldType(m_ioParam[i]==0? CFieldExchange::inputParam : CFieldExchange::inoutParam);
  1030. switch (m_ioParam[i])
  1031. {
  1032. case 'L':
  1033. m_cParam.m_varDB[i].m_dwType = DBVT_LONG;
  1034. m_cParam.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1035. break;
  1037. case 'I':
  1038. m_cParam.m_varDB[i].m_dwType = DBVT_SHORT;
  1039. m_cParam.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1040. break;
  1042. case 'Y':
  1043. m_cParam.m_varDB[i].m_dwType = DBVT_UCHAR;
  1044. m_cParam.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1045. break;
  1047. case 'B':
  1048. m_cParam.m_varDB[i].m_dwType = DBVT_BOOL;
  1049. m_cParam.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1050. break;
  1052. case 'C':
  1053. m_cParam.m_varDB[i].m_dwType = DBVT_STRING;
  1054. m_cParam.m_varDB[i].ChangeDataType(CQueryVar::eAllocString);
  1055. break;
  1057. case 'F':
  1058. m_cParam.m_varDB[i].m_dwType = DBVT_SINGLE;
  1059. m_cParam.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1060. break;
  1062. case 'D':
  1063. m_cParam.m_varDB[i].m_dwType = DBVT_DOUBLE;
  1064. m_cParam.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1065. break;
  1067. case 'T':
  1068. m_cParam.m_varDB[i].m_dwType = DBVT_DATE;
  1069. m_cParam.m_varDB[i].ChangeDataType(CQueryVar::eAllocDate);
  1070. break;
  1072. case 'X':
  1073. m_cParam.m_varDB[i].m_dwType = DBVT_BINARY;
  1074. m_cParam.m_varDB[i].ChangeDataType(CQueryVar::eAllocBinary);
  1075. break;
  1076. }
  1078. switch (m_cParam.m_varDB[i].m_dwType)
  1079. {
  1080. case DBVT_NULL:
  1081. CRecordset2::SetParamNull(i);
  1082. RFX_Bool(pFX,"",m_cParam.m_varDB[i].m_boolVal); // phony binding
  1083. break;
  1085. case DBVT_BOOL:
  1086. RFX_Bool(pFX,"",m_cParam.m_varDB[i].m_boolVal);
  1087. break;
  1089. case DBVT_STRING:
  1090. RFX_Text(pFX,"",*m_cParam.m_varDB[i].m_pstring);
  1091. break;
  1093. case DBVT_UCHAR:
  1094. RFX_Byte(pFX,"",m_cParam.m_varDB[i].m_chVal);
  1095. break;
  1097. case DBVT_LONG:
  1098. RFX_Long(pFX,"",m_cParam.m_varDB[i].m_lVal);
  1099. break;
  1101. case DBVT_SHORT:
  1102. RFX_Int(pFX,"",(int&)m_cParam.m_varDB[i].m_iVal);
  1103. break;
  1105. case DBVT_SINGLE:
  1106. RFX_Single(pFX,"",m_cParam.m_varDB[i].m_fltVal);
  1107. break;
  1109. case DBVT_DOUBLE:
  1110. RFX_Double(pFX,"",m_cParam.m_varDB[i].m_dblVal);
  1111. break;
  1113. case DBVT_DATE:
  1114. RFX_Date(pFX,"",*m_cParam.m_varDB[i].m_pdate);
  1115. break;
  1117. case DBVT_BINARY:
  1118. RFX_LongBinary(pFX,"",*m_cParam.m_varDB[i].m_pbinary);
  1119. break;
  1120. }
  1121. }
  1122. }
  1124. void CQueryDef::BindFields(CFieldExchange* pFX)
  1125. {
  1126. static BOOL bReentrant = FALSE;
  1127. DWORD dwType;
  1129. USES_RecordsetPatch;
  1131. for (UINT i = 0; i < m_nFields; i++)
  1132. {
  1133. if (!bReentrant && m_nMode != eModeNoMode) // AddNew or Edit
  1134. {
  1135. bReentrant = TRUE;
  1136. if (m_cLine.m_varDB[i].m_dwType == DBVT_NULL)
  1137. CRecordset::SetFieldNull(m_cLine.m_varDB[i],TRUE);
  1138. else
  1139. CRecordset::SetFieldNull(m_cLine.m_varDB[i],FALSE);
  1140. bReentrant = FALSE;
  1141. }
  1143. pFX->SetFieldType(CFieldExchange::outputColumn);
  1145. switch (m_ODBCFieldInfo[i].m_nSQLType)
  1146. {
  1147. case SQL_DATE:
  1148. case SQL_TIME:
  1149. case SQL_TIMESTAMP:
  1150. m_cLine.m_varDB[i].ChangeDataType(CQueryVar::eAllocDate);
  1151. RFX_Date(pFX,m_ODBCFieldInfo[i].m_strName,*m_cLine.m_varDB[i].m_pdate);
  1152. dwType = DBVT_DATE;
  1153. break;
  1155. case SQL_NUMERIC:
  1156. case SQL_DECIMAL:
  1157. case SQL_BIGINT:
  1158. case SQL_CHAR:
  1159. case SQL_VARCHAR:
  1160. case SQL_LONGVARCHAR:
  1161. m_cLine.m_varDB[i].ChangeDataType(CQueryVar::eAllocString);
  1162. RFX_Text(pFX,m_ODBCFieldInfo[i].m_strName,*m_cLine.m_varDB[i].m_pstring);
  1163. dwType = DBVT_STRING;
  1164. break;
  1166. case SQL_BINARY:
  1167. case SQL_VARBINARY:
  1168. case SQL_LONGVARBINARY:
  1169. m_cLine.m_varDB[i].ChangeDataType(CQueryVar::eAllocBinary);
  1170. RFX_LongBinary(pFX,m_ODBCFieldInfo[i].m_strName,*m_cLine.m_varDB[i].m_pbinary);
  1171. dwType = DBVT_BINARY;
  1172. break;
  1174. case SQL_BIT:
  1175. m_cLine.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1176. RFX_Bool(pFX,m_ODBCFieldInfo[i].m_strName,m_cLine.m_varDB[i].m_boolVal);
  1177. dwType = DBVT_BOOL;
  1178. break;
  1180. case SQL_TINYINT:
  1181. m_cLine.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1182. RFX_Byte(pFX,m_ODBCFieldInfo[i].m_strName,(BYTE&)m_cLine.m_varDB[i].m_iVal);
  1183. dwType = DBVT_SHORT;
  1184. break;
  1186. case SQL_SMALLINT:
  1187. m_cLine.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1188. RFX_Int(pFX,m_ODBCFieldInfo[i].m_strName,(int&)m_cLine.m_varDB[i].m_iVal);
  1189. dwType = DBVT_SHORT;
  1190. break;
  1192. case SQL_INTEGER:
  1193. m_cLine.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1194. RFX_Long(pFX,m_ODBCFieldInfo[i].m_strName,m_cLine.m_varDB[i].m_lVal);
  1195. dwType = DBVT_LONG;
  1196. break;
  1198. case SQL_REAL:
  1199. m_cLine.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1200. RFX_Single(pFX,m_ODBCFieldInfo[i].m_strName,m_cLine.m_varDB[i].m_fltVal);
  1201. dwType = DBVT_SINGLE;
  1202. break;
  1204. case SQL_FLOAT:
  1205. case SQL_DOUBLE:
  1206. m_cLine.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1207. RFX_Double(pFX,m_ODBCFieldInfo[i].m_strName,m_cLine.m_varDB[i].m_dblVal);
  1208. dwType = DBVT_DOUBLE;
  1209. break;
  1210. }
  1212. if (m_nMode == eModeNoMode)
  1213. {
  1214. m_cLine.m_varDB[i].m_dwType = dwType;
  1215. if (IsFieldStatusNull(i))
  1216. {
  1217. // m_cLine.m_varDB[i].ChangeDataType(CQueryVar::eAllocNothing);
  1218. m_cLine.m_varDB[i].m_dwType = DBVT_NULL;
  1219. }
  1220. }
  1221. }
  1222. }
  1224. /* removed from V1.5 & later; has been replaced with RFX_xxx binding functions
  1225. void CQueryDef::GetSQLData()
  1226. {
  1227. for (short i = 0; i < GetODBCFieldCount(); i++)
  1228. {
  1229. m_cLine.m_varDB[i].m_allocFlags = CQueryVar::eAllocNothing;
  1230. GetFieldValue(i,m_cLine.m_varDB[i]);
  1232. switch (m_ODBCFieldInfo[i].m_nSQLType)
  1233. {
  1234. case SQL_DATE:
  1235. case SQL_TIME:
  1236. case SQL_TIMESTAMP:
  1237. m_cLine.m_varDB[i].m_allocFlags = CQueryVar::eAllocDate;
  1238. break;
  1240. case SQL_NUMERIC:
  1241. case SQL_DECIMAL:
  1242. case SQL_BIGINT:
  1243. case SQL_CHAR:
  1244. case SQL_VARCHAR:
  1245. case SQL_LONGVARCHAR:
  1246. m_cLine.m_varDB[i].m_allocFlags = CQueryVar::eAllocString;
  1247. break;
  1249. case SQL_BINARY:
  1250. case SQL_VARBINARY:
  1251. case SQL_LONGVARBINARY:
  1252. m_cLine.m_varDB[i].m_allocFlags = CQueryVar::eAllocBinary;
  1253. break;
  1255. default:
  1256. m_cLine.m_varDB[i].m_allocFlags = CQueryVar::eAllocNothing;
  1257. break;
  1258. }
  1259. }
  1260. }
  1261. */
  1263. CQueryVar& CQueryDef::operator[](int index)
  1264. {
  1265. return m_cLine[index];
  1266. }
  1268. CQueryVar& CQueryDef::operator[](LPCTSTR lpszColumnName) // applies only on columns
  1269. {
  1270. for (int i = 0; i < GetODBCFieldCount(); i++)
  1271. if (m_ODBCFieldInfo[i].m_strName == lpszColumnName)
  1272. return m_cLine[i];
  1274. throw CQueryVar::eBoundary;
  1276. return CQueryVar(); // never called
  1277. }
  1279. CQueryVariant& CQueryDef::operator=(CQueryVariant& v)
  1280. {
  1281. v.m_decPlaces = m_cLine.m_decPlaces;
  1282. v.m_dateFormat = m_cLine.m_dateFormat;
  1284. v.SetSize(m_cLine.Columns());
  1286. for (WORD i = 0; i < v.Columns(); i++)
  1287. v.m_varDB[i] = m_cLine.m_varDB[i];
  1289. return v;
  1290. }
  1292. void CQueryDef::Move(long nRows,WORD wFetchType)
  1293. {
  1294. try
  1295. {
  1296. CRecordset::Move(nRows,wFetchType);
  1297. }
  1298. catch (CDBException* e) // no rowset; parameters only
  1299. {
  1300. if (e->m_strStateNativeOrigin.Left(11) != "State:24000") // invalid cursor state
  1301. throw e;
  1303. e->Delete();
  1305. if (m_bEOF) // already been here
  1306. return;
  1308. m_bEOF = m_bBOF = TRUE;
  1310. ASSERT_VALID(this);
  1311. ASSERT(m_hstmt != SQL_NULL_HSTMT);
  1313. CFieldExchange fx(CFieldExchange::Fixup,this); // fixup strings
  1314. fx.m_hstmt = m_hstmt;
  1315. DoFieldExchange(&fx);
  1316. }
  1318. NotifySink(eNotifyMove);
  1320. // if (!IsEOF())
  1321. // GetSQLData();
  1322. }
  1324. short CQueryDef::SetDecimalDigits(short d)
  1325. {
  1326. short s = m_cLine.SetDecimalDigits(d);
  1327. NotifySink(eNotifyFormatChanged,eFormatChangedDecimalDigits);
  1328. return s;
  1329. }
  1331. LPCSTR CQueryDef::SetDateFormat(LPCSTR strFormat)
  1332. {
  1333. LPCSTR lpstr = m_cLine.SetDateFormat(strFormat);
  1334. NotifySink(eNotifyFormatChanged,eFormatChangedDate);
  1335. return lpstr;
  1336. }
  1338. CQueryCol& CQueryDef::Column(LPCTSTR lpColName)
  1339. {
  1340. for (int i = 0; i < m_columns.GetSize(); i++)
  1341. if (strcmp(m_columns[i].Name(),lpColName) == 0)
  1342. return m_columns[i];
  1344. throw CQueryVar::eBoundary;
  1346. return CQueryCol(CQueryVar(),CODBCFieldInfo());
  1347. }
  1349. EVNHANDLE CQueryDef::Advise(IQueryDefEventSink* pSink)
  1350. {
  1351. return m_evSink.AddTail(new SQueryDefEventSink(pSink,FALSE));
  1352. }
  1354. void CQueryDef::Unadvise(EVNHANDLE evnHandle)
  1355. {
  1356. m_evSink.RemoveAt(evnHandle);
  1357. }
  1359. void CQueryDef::FreezeEvents(EVNHANDLE evnHandle,BOOL bFreeze)
  1360. {
  1361. m_evSink.GetAt(evnHandle)->m_frozen = bFreeze;
  1362. }
  1364. void CQueryDef::FreezeAllEvents(BOOL bFreeze)
  1365. {
  1366. // freeze all events keeping track of already frozen ones
  1367. EVNHANDLE posHandle = m_evSink.GetHeadPosition();
  1368. SQueryDefEventSink* pSink;
  1369. int inc = bFreeze? +1 : -1;
  1371. while (posHandle)
  1372. {
  1373. pSink = m_evSink.GetNext(posHandle);
  1374. pSink->m_frozen += inc; // if 0 -> 1 if 1 -> 2 (all frozen)
  1375. }
  1376. }
  1378. void CQueryDef::ClearEventSinkList()
  1379. {
  1380. EVNHANDLE evH = m_evSink.GetHeadPosition();
  1381. while (evH != NULL)
  1382. delete m_evSink.GetNext(evH);
  1384. m_evSink.RemoveAll();
  1385. }
  1387. void CQueryDef::NotifySink(ENOTIFICATION nNotify,LPARAM lp)
  1388. {
  1389. SQueryDefEventSink* pSink;
  1390. EVNHANDLE evnH = m_evSink.GetHeadPosition();
  1391. EVNHANDLE evnHPrev;
  1392. LPARAM retVal;
  1394. while (evnH != NULL)
  1395. {
  1396. evnHPrev = evnH;
  1397. pSink = m_evSink.GetNext(evnH);
  1399. if (pSink->m_frozen)
  1400. continue;
  1402. // a sink returning non 0 value blocks all the other sinks receiving the notification
  1403. switch (nNotify)
  1404. {
  1405. case eNotifyOpen:
  1406. retVal = pSink->m_pSink->RSNotifyOpen(evnHPrev);
  1407. break;
  1408. case eNotifyClose:
  1409. retVal = pSink->m_pSink->RSNotifyClose(evnHPrev);
  1410. break;
  1411. case eNotifyMove:
  1412. retVal = pSink->m_pSink->RSNotifyMove(evnHPrev);
  1413. break;
  1414. case eNotifyAddNew:
  1415. retVal = pSink->m_pSink->RSNotifyAddNew(evnHPrev);
  1416. break;
  1417. case eNotifyEdit:
  1418. retVal = pSink->m_pSink->RSNotifyEdit(evnHPrev);
  1419. break;
  1420. case eNotifyUpdate:
  1421. retVal = pSink->m_pSink->RSNotifyUpdate(evnHPrev);
  1422. break;
  1423. case eNotifyDelete:
  1424. retVal = pSink->m_pSink->RSNotifyDelete(evnHPrev);
  1425. break;
  1426. case eNotifyCancelUpdate:
  1427. retVal = pSink->m_pSink->RSNotifyCancelUpdate(evnHPrev);
  1428. break;
  1429. case eNotifyRequery:
  1430. retVal = pSink->m_pSink->RSNotifyRequery(evnHPrev);
  1431. break;
  1432. case eNotifyFormatChanged:
  1433. retVal = pSink->m_pSink->RSNotifyFormatChanged(evnHPrev,(BYTE)lp);
  1434. break;
  1435. default:
  1436. break;
  1437. }
  1439. if (retVal != 0) // blocks event bubbling
  1440. return;
  1441. }
  1442. }
  1444. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1445. // class CTabbedString
  1446. //
  1448. CTabbedString& CTabbedString::operator=(CQueryDef& qDef)
  1449. {
  1450. WORD nCount = qDef.GetODBCFieldCount();
  1451. CQueryVar varTemp;
  1453. Empty();
  1454. for (WORD i = 0; i < nCount; i++)
  1455. {
  1456. varTemp = (CQueryVar&)qDef.m_cLine.m_varDB[i];
  1458. if (!varTemp.IsNull())
  1459. *this += (LPCTSTR)varTemp;
  1460. else
  1461. *this += "<NULL>";
  1463. if (i+1 < nCount)
  1464. *this += 't';
  1465. }
  1467. return *this;
  1468. }
  1470. CTabbedString& CTabbedString::operator=(CQueryVariant& qV)
  1471. {
  1472. WORD nCount = qV.Columns();
  1473. CQueryVar varTemp;
  1475. Empty();
  1476. for (WORD i = 0; i < nCount; i++)
  1477. {
  1478. varTemp = (CQueryVar&)qV.m_varDB[i];
  1480. if (!varTemp.IsNull())
  1481. *this += (LPCTSTR)varTemp;
  1482. else
  1483. *this += "<NULL>";
  1485. if (i+1 < nCount)
  1486. *this += 't';
  1487. }
  1489. return *this;
  1490. }
  1492. CTabbedString CTabbedString::operator[](int index)
  1493. {
  1494. CString strRet;
  1495. int nLength = GetLength();
  1497. for (int i = 0; i < nLength; i++)
  1498. {
  1499. if (GetAt(i) == 't' && --index == 0)
  1500. {
  1501. i++;
  1502. while (i < nLength && GetAt(i) != 't')
  1503. strRet += GetAt(i++);
  1504. }
  1505. }
  1507. if (index > -1)
  1508. throw CQueryVariant::eBoundary;
  1510. return strRet;
  1511. }
  1513. BOOL CTabbedString::IsNull(int index)
  1514. {
  1515. return operator[](index) == "<NULL>";
  1516. }
  1518. BOOL CTabbedString::operator==(CSQLNull&)
  1519. {
  1520. return *this == "<NULL>";
  1521. }
  1523. BOOL CTabbedString::operator!=(CSQLNull&)
  1524. {
  1525. return *this != "<NULL>";
  1526. }
  1527. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1528. // class CSQLNull
  1529. //
  1530. const int CSQLNull::SqlNull = DBVT_NULL; // taken from CDBVariant;
  1532. BOOL CSQLNull::operator==(CQueryVar& qVar)
  1533. {
  1534. return SqlNull == qVar.m_dwType;
  1535. }
  1537. BOOL CSQLNull::operator!=(CQueryVar& qVar)
  1538. {
  1539. return SqlNull != qVar.m_dwType;
  1540. }
  1542. BOOL CSQLNull::operator==(CTabbedString& strTab)
  1543. {
  1544. return strTab == "<NULL>";
  1545. }
  1547. BOOL CSQLNull::operator!=(CTabbedString& strTab)
  1548. {
  1549. return strTab != "<NULL>";
  1550. }
  1552. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1553. CString ConvertToHex(void* pbinary,int length) // converts a binary stream to hex representation
  1554. {
  1555. int i;
  1556. char* p;
  1557. CString s;
  1558. BYTE b;
  1560. for (i = 0, p = static_cast<char*>(pbinary); i < length; i++, p++)
  1561. {
  1562. b = *p & 0xF0;
  1563. s += chHexDigits[b>>4];
  1564. b = *p & 0x0F;
  1565. s += chHexDigits[b];
  1566. }
  1567. s = (CString)"0x" + s;
  1569. return s;
  1570. }
  1572. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1573. }; // namespace QueryDef
  1575. #if defined(_QUERYDEFCOMPILE)
  1576. __declspec(dllexport) QueryDef::CSQLNull SQL_NULL; // value of SQL NULL as defined by this class
  1577. #endif