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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
variant.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：20k
源码类别：

生物技术

开发平台：

C/C++

variant.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: variant.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:18:55  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.29
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: variant.cpp,v 1000.4 2004/06/01 19:18:55 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE                          
  14. *               National Center for Biotechnology Information
  15. *                                                                          
  16. *  This software/database is a "United States Government Work" under the   
  17. *  terms of the United States Copyright Act.  It was written as part of    
  18. *  the author's official duties as a United States Government employee and 
  19. *  thus cannot be copyrighted.  This software/database is freely available 
  20. *  to the public for use. The National Library of Medicine and the U.S.    
  21. *  Government have not placed any restriction on its use or reproduction.  
  22. *                                                                          
  23. *  Although all reasonable efforts have been taken to ensure the accuracy  
  24. *  and reliability of the software and data, the NLM and the U.S.          
  25. *  Government do not and cannot warrant the performance or results that    
  26. *  may be obtained by using this software or data. The NLM and the U.S.    
  27. *  Government disclaim all warranties, express or implied, including       
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.                                                                
  30. *                                                                          
  31. *  Please cite the author in any work or product based on this material.   
  32. *
  33. * ===========================================================================
  34. *
  35. * File Name:  $Id: variant.cpp,v 1000.4 2004/06/01 19:18:55 gouriano Exp $
  36. *
  37. * Author:  Michael Kholodov
  38. *   
  39. * File Description:   CVariant class implementation
  40. *
  41. *
  42. * $Log: variant.cpp,v $
  43. * Revision 1000.4  2004/06/01 19:18:55  gouriano
  44. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.29
  45. *
  46. * Revision 1.29  2004/05/17 21:10:28  gorelenk
  47. * Added include of PCH ncbi_pch.hpp
  48. *
  49. * Revision 1.28  2004/04/08 15:56:58  kholodov
  50. * Multiple bug fixes and optimizations
  51. *
  52. * Revision 1.27  2004/02/10 18:50:44  kholodov
  53. * Modified: made Move() method const
  54. *
  55. * Revision 1.26  2003/12/10 22:34:14  kholodov
  56. * Added: MoveTo() method
  57. *
  58. * Revision 1.25  2003/12/10 21:08:48  kholodov
  59. * Fixed: size of the fixed size columns is now correct for NULL value
  60. *
  61. * Revision 1.24  2003/12/05 15:05:06  kholodov
  62. * Added: float->double implicit conversion
  63. *
  64. * Revision 1.23  2003/11/18 16:59:18  kholodov
  65. * Added: operator=(const char*)
  66. *
  67. * Revision 1.22  2003/08/15 19:48:43  kholodov
  68. * Fixed: const method GetBlobSize()
  69. *
  70. * Revision 1.21  2003/08/12 21:08:39  kholodov
  71. * Added: AsNotNullString() method
  72. *
  73. * Revision 1.20  2003/07/17 18:34:11  kholodov
  74. * Modified: operator=(CVariant& ) uses now CDB_Object::AssignValue() method
  75. *
  76. * Revision 1.19  2003/06/25 22:24:21  kholodov
  77. * Added: GetBlobSize() method
  78. *
  79. * Revision 1.18  2003/05/05 18:32:50  kholodov
  80. * Added: LONGCHAR and LONGBINARY support
  81. *
  82. * Revision 1.17  2003/01/10 14:23:33  kholodov
  83. * Modified: GetString() uses NStr::<...> type conversion
  84. *
  85. * Revision 1.16  2003/01/09 19:59:29  kholodov
  86. * Fixed: operator=(CVariant&) rewritten using copy ctor
  87. *
  88. * Revision 1.15  2002/10/31 22:37:05  kholodov
  89. * Added: DisableBind(), GetColumnNo(), GetTotalColumns() methods
  90. * Fixed: minor errors, diagnostic messages
  91. *
  92. * Revision 1.14  2002/10/21 20:38:08  kholodov
  93. * Added: GetParentConn() method to get the parent connection from IStatement,
  94. * ICallableStatement and ICursor objects.
  95. * Fixed: Minor fixes
  96. *
  97. * Revision 1.13  2002/10/11 16:42:50  kholodov
  98. * Added: return Binary and Varbinary columns as CVariant::GetString()
  99. *
  100. * Revision 1.12  2002/09/16 21:04:02  kholodov
  101. * Modified: CVariant::Assign<> template removed
  102. *
  103. * Revision 1.11  2002/09/16 20:22:44  kholodov
  104. * Fixed: return statement for the void function
  105. *
  106. * Revision 1.10  2002/09/16 19:30:58  kholodov
  107. * Added: Numeric datatype support
  108. * Added: CVariant::operator=() methods for working with bulk insert
  109. * Added: Methods for writing BLOBs during bulk insert
  110. *
  111. * Revision 1.9  2002/09/10 16:54:15  kholodov
  112. * Modified: using CDB_Object::operator=() for CVariant assignments
  113. *
  114. * Revision 1.8  2002/04/15 19:12:11  kholodov
  115. * Added simple type conversions
  116. *
  117. * Revision 1.7  2002/03/13 16:52:10  kholodov
  118. * Added: Full destructor definition in CVariantException with throw()
  119. * to conform with the parent's virtual destructor.
  120. * Modified: Moved CVariantException methods' definitions to variant.cpp file
  121. *
  122. * Revision 1.6  2002/02/15 23:24:42  vakatov
  123. * CVariant::CVariant() -- fixed a bug introduced during the cleanup
  124. *
  125. * Revision 1.5  2002/02/14 00:59:40  vakatov
  126. * Clean-up: warning elimination, fool-proofing, fine-tuning, identation, etc.
  127. *
  128. * Revision 1.4  2002/02/08 15:50:32  kholodov
  129. * Modified: integer types used are Int8, Int4, Int2, Uint1
  130. * Added: factories for CVariants of a particular type
  131. *
  132. * Revision 1.3  2002/02/06 22:50:48  kholodov
  133. * Conditionalized the usage of long long
  134. *
  135. * Revision 1.2  2002/02/06 22:21:00  kholodov
  136. * Added constructor from long long to BigInt type
  137. *
  138. * Revision 1.1  2002/01/30 14:51:22  kholodov
  139. * User DBAPI implementation, first commit
  140. *
  141. *
  142. *
  143. */ 
  145. #include <ncbi_pch.hpp>
  146. #include <dbapi/variant.hpp>
  147. #include <algorithm>
  148. //#include "basetmpl.hpp"
  149. //#include <corelib/ncbistr.hpp>
  152. BEGIN_NCBI_SCOPE
  154. CVariantException::CVariantException(const string& msg)
  155.     : m_msg(msg) 
  156. {
  158. }
  159.     
  160. CVariantException::~CVariantException() throw() 
  161. {
  163. }
  165. const char* CVariantException::what() const throw() 
  166. {
  167.     return m_msg.c_str();
  168. }
  170. //==================================================================
  171. CVariant CVariant::BigInt(Int8 *p)
  172. {
  173.     return CVariant(p ? new CDB_BigInt(*p) : new CDB_BigInt());
  174. }
  176. CVariant CVariant::Int(Int4 *p)
  177. {
  178.     return CVariant(p ? new CDB_Int(*p) : new CDB_Int());
  179. }
  181. CVariant CVariant::SmallInt(Int2 *p)
  182. {
  183.     return CVariant(p ? new CDB_SmallInt(*p) : new CDB_SmallInt());
  184. }
  186. CVariant CVariant::TinyInt(Uint1 *p)
  187. {
  188.     return CVariant(p ? new CDB_TinyInt(*p) : new CDB_TinyInt());
  189. }
  191. CVariant CVariant::Float(float *p)
  192. {
  193.     return CVariant(p ? new CDB_Float(*p) : new CDB_Float());
  194. }
  196. CVariant CVariant::Double(double *p)
  197. {
  198.     return CVariant(p ? new CDB_Double(*p) : new CDB_Double());
  199. }
  201. CVariant CVariant::Bit(bool *p)
  202. {
  203.     return CVariant(p ? new CDB_Bit(*p) : new CDB_Bit());
  204. }
  206. CVariant CVariant::LongChar(const char *p, size_t len)
  207. {
  208.     return CVariant(p ? new CDB_LongChar(len, p) : new CDB_LongChar(len));
  209. }
  211. CVariant CVariant::VarChar(const char *p, size_t len)
  212. {
  213.     return CVariant(p ? (len ? new CDB_VarChar(p, len) : new CDB_VarChar(p))
  214.                     : new CDB_VarChar());
  215. }
  217. CVariant CVariant::Char(size_t size, const char *p)
  218. {
  219.     return CVariant(p ? new CDB_Char(size, p) : new CDB_Char(size));
  220. }
  222. CVariant CVariant::LongBinary(size_t maxSize, const void *p, size_t len)
  223. {
  224.     return CVariant(p ? new CDB_LongBinary(maxSize, p, len) : new CDB_LongBinary(maxSize));
  225. }
  227. CVariant CVariant::VarBinary(const void *p, size_t len)
  228. {
  229.     return CVariant(p ? new CDB_VarBinary(p, len) : new CDB_VarBinary());
  230. }
  232. CVariant CVariant::Binary(size_t size, const void *p, size_t len)
  233. {
  234.     return CVariant(p ? new CDB_Binary(size, p, len) : new CDB_Binary(size));
  235. }
  237. CVariant CVariant::SmallDateTime(CTime *p)
  238. {
  239.     return CVariant(p ? new CDB_SmallDateTime(*p) : new CDB_SmallDateTime());
  240. }
  242. CVariant CVariant::DateTime(CTime *p)
  243. {
  244.     return CVariant(p ? new CDB_DateTime(*p) : new CDB_DateTime());
  245. }
  247. CVariant CVariant::Numeric(unsigned int precision,
  248.                            unsigned int scale,
  249.                            const char* p)
  250. {
  251.     return CVariant(p ? new CDB_Numeric(precision, scale, p) 
  252.                     : new CDB_Numeric());
  253. }
  256. CVariant::CVariant(EDB_Type type, size_t size)
  257.     : m_data(0)
  258. {
  259.     switch ( type ) {
  260.     case eDB_Int:
  261.         m_data = new CDB_Int();
  262.         return;  
  263.     case eDB_SmallInt:
  264.         m_data = new CDB_SmallInt();
  265.         return;  
  266.     case eDB_TinyInt:
  267.         m_data = new CDB_TinyInt();
  268.         return;  
  269.     case eDB_BigInt:
  270.         m_data = new CDB_BigInt();
  271.         return;  
  272.     case eDB_LongChar:
  273.         m_data = new CDB_LongChar(size);
  274.         return;  
  275.     case eDB_VarChar:
  276.         m_data = new CDB_VarChar();
  277.         return;  
  278.     case eDB_Char:
  279.         m_data = new CDB_Char(size);
  280.         return;  
  281.     case eDB_LongBinary:
  282.         m_data = new CDB_LongBinary(size);
  283.         return;  
  284.     case eDB_VarBinary:
  285.         m_data = new CDB_VarBinary();
  286.         return;  
  287.     case eDB_Binary:
  288.         m_data = new CDB_Binary(size);
  289.         return;  
  290.     case eDB_Float:
  291.         m_data = new CDB_Float();
  292.         return;  
  293.     case eDB_Double:
  294.         m_data = new CDB_Double();
  295.         return;  
  296.     case eDB_DateTime:
  297.         m_data = new CDB_DateTime();
  298.         return;
  299.     case eDB_SmallDateTime:
  300.         m_data = new CDB_SmallDateTime();
  301.         return;
  302.     case eDB_Text:
  303.         m_data = new CDB_Text();
  304.         return;
  305.     case eDB_Image:
  306.         m_data = new CDB_Image();
  307.         return;
  308.     case eDB_Bit:
  309.         m_data = new CDB_Bit();
  310.         return;
  311.     case eDB_Numeric:
  312.         m_data = new CDB_Numeric();
  313.         return;
  314.     case eDB_UnsupportedType:
  315.         break;
  316.     }
  317.     throw CVariantException("CVariant::ctor():  unsupported type");
  318. }
  321. CVariant::CVariant(CDB_Object* o) 
  322.     : m_data(o) 
  323. {
  324.     return;
  325. }
  328. CVariant::CVariant(Int8 v) 
  329.     : m_data(new CDB_BigInt(v)) {}
  332. CVariant::CVariant(Int4 v) 
  333.     : m_data(new CDB_Int(v)) {}
  335. //CVariant::CVariant(int v) 
  336. //: m_data(new CDB_Int(v)) {}
  338. CVariant::CVariant(Int2 v) 
  339.     : m_data(new CDB_SmallInt(v)) {}
  341. CVariant::CVariant(Uint1 v) 
  342.     : m_data(new CDB_TinyInt(v)) {}
  344. CVariant::CVariant(float v)
  345.     : m_data(new CDB_Float(v)) {}
  347. CVariant::CVariant(double v) 
  348.     : m_data(new CDB_Double(v)) {}
  350. CVariant::CVariant(bool v) 
  351.     : m_data(new CDB_Bit(v)) {}
  353. CVariant::CVariant(const string& v) 
  354.     : m_data(new CDB_VarChar(v)) {}
  356. CVariant::CVariant(const char* s) 
  357.     : m_data(new CDB_VarChar(s)) {}
  359. CVariant::CVariant(const CTime& v, EDateTimeFormat fmt)
  360.     : m_data(0)
  361. {
  363.     switch(fmt) {
  364.     case eShort:
  365.         m_data = new CDB_SmallDateTime(v);
  366.         break;
  367.     case eLong:
  368.         m_data = new CDB_DateTime(v);
  369.         break;
  370.     default:
  371.         throw CVariantException("CVariant::ctor(): unsupported datetime type");
  372.     }
  373. }
  376. CVariant::CVariant(const CVariant& v)
  377.     : m_data(0)
  378. {
  379.     if( v.GetData() != 0 ) {
  380.         m_data = v.GetData()->Clone();
  381.     }
  382. }
  383.       
  384. CVariant::~CVariant(void) 
  385. {
  386.     delete m_data;
  387. }
  390. CDB_Object* CVariant::GetNonNullData() const {
  391.     if( m_data == 0 )
  392.         throw CVariantException("CVariant::GetNonNullData(): null data");
  393.   
  394.     return m_data;
  395. }
  397. void CVariant::SetData(CDB_Object* o) {
  398.     delete m_data;
  399.     m_data = o;
  400. }
  404. string CVariant::GetString(void) const 
  405. {
  407.     if( IsNull() )
  408.         return "null";
  410.     switch( GetType() ) {
  411.     case eDB_Char:
  412.         return ((CDB_Char*)GetData())->Value();
  413.     case eDB_VarChar:
  414.         return ((CDB_VarChar*)GetData())->Value();
  415.     case eDB_LongChar:
  416.         return ((CDB_LongChar*)GetData())->Value();
  417.     case eDB_Binary:
  418.         {
  419.             CDB_Binary *b = (CDB_Binary*)GetData();
  420.             return string((char*)b->Value(), b->Size());
  421.         }
  422.     case eDB_LongBinary:
  423.         {
  424.             CDB_LongBinary *vb = (CDB_LongBinary*)GetData();
  425.             return string((char*)vb->Value(), vb->Size());
  426.         }
  427.     case eDB_VarBinary:
  428.         {
  429.             CDB_VarBinary *vb = (CDB_VarBinary*)GetData();
  430.             return string((char*)vb->Value(), vb->Size());
  431.         }
  432.     case eDB_TinyInt:
  433.         return NStr::IntToString((long)GetByte()); 
  434.     case eDB_SmallInt:      
  435.         return NStr::IntToString(GetInt2()); 
  436.     case eDB_Int:
  437.         return NStr::IntToString(GetInt4()); 
  438.     case eDB_BigInt:
  439.         return NStr::Int8ToString(GetInt8()); 
  440.     case eDB_Float:
  441.         return NStr::DoubleToString(GetFloat()); 
  442.     case eDB_Double:
  443.         return NStr::DoubleToString(GetDouble()); 
  444.     case eDB_Bit:
  445.         return NStr::BoolToString(GetBit()); 
  446.     case eDB_Numeric:
  447.         return ((CDB_Numeric*)GetData())->Value(); 
  448.     case eDB_DateTime:
  449.     case eDB_SmallDateTime:
  450.         return GetCTime().AsString();
  451.     default:
  452.         break;
  453.     }
  454.   
  455.     throw CVariantException("CVariant::GetString(): type not supported");
  456. }
  459. Int8 CVariant::GetInt8() const
  460. {
  461.     switch( GetType() ) {
  462.     case eDB_BigInt:
  463.         return ((CDB_BigInt*)GetData())->Value();
  464.     case eDB_Int:
  465.         return ((CDB_Int*)GetData())->Value();
  466.     case eDB_SmallInt:
  467.         return ((CDB_SmallInt*)GetData())->Value();
  468.     case eDB_TinyInt:
  469.         return ((CDB_TinyInt*)GetData())->Value();
  470.     default:
  471.         VerifyType(false);
  472.     }
  473.     return 0;
  474. }
  477. Int4 CVariant::GetInt4() const
  478. {
  479.     switch( GetType() ) {
  480.     case eDB_Int:
  481.         return ((CDB_Int*)GetData())->Value();
  482.     case eDB_SmallInt:
  483.         return ((CDB_SmallInt*)GetData())->Value();
  484.     case eDB_TinyInt:
  485.         return ((CDB_TinyInt*)GetData())->Value();
  486.     default:
  487.         VerifyType(false);
  488.     }
  489.     return 0;
  490. }
  492. Int2 CVariant::GetInt2() const
  493. {
  494.     switch( GetType() ) {
  495.     case eDB_SmallInt:
  496.         return ((CDB_SmallInt*)GetData())->Value();
  497.     case eDB_TinyInt:
  498.         return ((CDB_TinyInt*)GetData())->Value();
  499.     default:
  500.         VerifyType(false);
  501.     }
  502.     return 0;
  503. }
  505. Uint1 CVariant::GetByte() const
  506. {
  507.     switch( GetType() ) {
  508.     case eDB_TinyInt:
  509.         return ((CDB_TinyInt*)GetData())->Value();
  510.     default:
  511.         VerifyType(false);
  512.     }
  513.     return 0;
  514. }
  516. float CVariant::GetFloat() const
  517. {
  518.     switch( GetType() ) {
  519.     case eDB_Float:
  520.         return ((CDB_Float*)GetData())->Value();
  521.     case eDB_Int:
  522.         return ((CDB_Int*)GetData())->Value();
  523.     case eDB_SmallInt:
  524.         return ((CDB_SmallInt*)GetData())->Value();
  525.     case eDB_TinyInt:
  526.         return ((CDB_TinyInt*)GetData())->Value();
  527.     default:
  528.         VerifyType(false);
  529.     }
  530.     return 0;
  531. }
  533. double CVariant::GetDouble() const
  534. {
  535.     switch( GetType() ) {
  536.     case eDB_Float:
  537.         return ((CDB_Float*)GetData())->Value();
  538.     case eDB_Double:
  539.         return ((CDB_Double*)GetData())->Value();
  540.     case eDB_Int:
  541.         return ((CDB_Int*)GetData())->Value();
  542.     case eDB_SmallInt:
  543.         return ((CDB_SmallInt*)GetData())->Value();
  544.     case eDB_TinyInt:
  545.         return ((CDB_TinyInt*)GetData())->Value();
  546.     default:
  547.         VerifyType(false);
  548.     }
  549.     return 0;
  550. }
  552. bool CVariant::GetBit() const
  553. {
  554.     VerifyType( GetType() == eDB_Bit );
  555.     return ((CDB_Bit*)GetData())->Value() != 0;
  556. }
  558. string CVariant::GetNumeric() const
  559. {
  560.     VerifyType( GetType() == eDB_Numeric );
  561.     return ((CDB_Numeric*)GetData())->Value();
  562. }
  564. const CTime& CVariant::GetCTime() const
  565. {
  566.     switch(GetType()) {
  567.     case eDB_DateTime:
  568.         return ((CDB_DateTime*)GetData())->Value();
  569.     case eDB_SmallDateTime:
  570.         return ((CDB_SmallDateTime*)GetData())->Value();
  571.     default:
  572.         throw CVariantException("CVariant::GetCTime(): invalid type");
  573.     }
  574. }
  576. string CVariant::AsNotNullString(const string& v) const 
  577. {
  578.     if( IsNull() )
  579.         return v;
  580.     else
  581.         return GetString();
  582. }
  584. bool CVariant::IsNull() const
  585. {
  586.     return GetData() == 0 ? true : GetData()->IsNULL();
  587. }
  589. size_t CVariant::Read(void* buf, size_t len) const
  590. {
  592.     switch(GetType()) {
  593.     case eDB_Image:
  594.     case eDB_Text:
  595.         return ((CDB_Stream*)GetData())->Read(buf, len);
  597.     default:
  598.         throw CVariantException("CVariant::Read(): invalid type");
  599.     }
  600. }
  602. size_t CVariant::Append(const void* buf, size_t len)
  603. {
  605.     switch(GetType()) {
  606.     case eDB_Image:
  607.     case eDB_Text:
  608.         return ((CDB_Stream*)GetData())->Append(buf, len);
  610.     default:
  611.         throw CVariantException("CVariant::Append(): invalid type");
  612.     }
  613. }
  615. size_t CVariant::GetBlobSize() const
  616. {
  618.     switch(GetType()) {
  619.     case eDB_Image:
  620.     case eDB_Text:
  621.         return ((CDB_Stream*)GetData())->Size();
  623.     default:
  624.         throw CVariantException("CVariant::GetBlobSize(): invalid type");
  625.     }
  626. }
  628. void CVariant::Truncate(size_t len)
  629. {
  631.     switch(GetType()) {
  632.     case eDB_Image:
  633.         ((CDB_Image*)GetData())->Truncate(len);
  634.         break;
  635.     case eDB_Text:
  636.         ((CDB_Text*)GetData())->Truncate(len);
  637.         break;
  638.     default:
  639.         throw CVariantException("CVariant::Truncate(): invalid type");
  640.     }
  641.     return;
  642. }
  644. bool CVariant::MoveTo(size_t pos) const
  645. {
  647.     switch(GetType()) {
  648.     case eDB_Image:
  649.         return ((CDB_Image*)GetData())->MoveTo(pos);
  650.         break;
  651.     case eDB_Text:
  652.         return ((CDB_Text*)GetData())->MoveTo(pos);
  653.         break;
  654.     default:
  655.         throw CVariantException("CVariant::MoveTo(): invalid type");
  656.     }
  657.     return false;
  658. }
  660. CVariant& CVariant::operator=(const Int8& v)
  661. {
  662.     VerifyType(GetType() == eDB_BigInt);
  663.     *((CDB_BigInt*)GetData()) = v;
  664.     return *this;
  665. }
  667. CVariant& CVariant::operator=(const Int4& v)
  668. {
  669.     VerifyType(GetType() == eDB_Int);
  670.     *((CDB_Int*)GetData()) = v;
  671.     return *this;
  672. }
  674. CVariant& CVariant::operator=(const Int2& v)
  675. {
  676.     VerifyType(GetType() == eDB_SmallInt);
  677.     *((CDB_SmallInt*)GetData()) = v;
  678.     return *this;
  679. }
  681. CVariant& CVariant::operator=(const Uint1& v)
  682. {
  683.     VerifyType(GetType() == eDB_TinyInt);
  684.     *((CDB_TinyInt*)GetData()) = v;
  685.     return *this;
  686. }
  688. CVariant& CVariant::operator=(const float& v)
  689. {
  690.     VerifyType(GetType() == eDB_Float);
  691.     *((CDB_Float*)GetData()) = v;
  692.     return *this;
  693. }
  695. CVariant& CVariant::operator=(const double& v)
  696. {
  697.     VerifyType(GetType() == eDB_Double);
  698.     *((CDB_Double*)GetData()) = v;
  699.     return *this;
  700. }
  702. CVariant& CVariant::operator=(const string& v)
  703. {
  704.     switch( GetType()) {
  705.     case eDB_VarChar:
  706.         *((CDB_VarChar*)GetData()) = v;
  707.         break;
  708.     case eDB_LongChar:
  709.         *((CDB_LongChar*)GetData()) = v;
  710.         break;
  711.     case eDB_Char:
  712.         *((CDB_Char*)GetData()) = v;
  713.         break;
  714.     default:
  715.         VerifyType(false);
  716.     }
  718.     return *this;
  719. }
  721. CVariant& CVariant::operator=(const char* v)
  722. {
  723.     switch( GetType()) {
  724.     case eDB_VarChar:
  725.         *((CDB_VarChar*)GetData()) = v;
  726.         break;
  727.     case eDB_LongChar:
  728.         *((CDB_LongChar*)GetData()) = v;
  729.         break;
  730.     case eDB_Char:
  731.         *((CDB_Char*)GetData()) = v;
  732.         break;
  733.     default:
  734.         VerifyType(false);
  735.     }
  737.     return *this;
  738. }
  740. CVariant& CVariant::operator=(const bool& v)
  741. {
  742.     VerifyType(GetType() == eDB_Bit);
  743.     *((CDB_Bit*)GetData()) = v;
  744.     return *this;
  745. }
  747. CVariant& CVariant::operator=(const CTime& v)
  748. {
  749.     switch(GetType()) {
  750.     case eDB_DateTime:
  751.         *((CDB_DateTime*)GetData()) = v;
  752.         break;
  753.     case eDB_SmallDateTime:
  754.         *((CDB_SmallDateTime*)GetData()) = v;
  755.         break;
  756.     default:
  757.         VerifyType(false);
  758.     }
  759.     return *this;
  760. }
  762. CVariant& CVariant::operator=(const CVariant& v)
  763. {
  764.     this->m_data->AssignValue(*(v.m_data));
  765.     return *this;
  766. }
  768. bool CVariant::operator< (const CVariant& v) const 
  769. {
  770.     bool less = false;
  772.     if( IsNull() || v.IsNull() ) {
  773.         less = IsNull() && !v.IsNull();
  774.     }
  775.     else {
  776.         if( GetType() != v.GetType() ) {
  777.             throw CVariantException
  778.                 ("CVariant::operator<(): cannot compare different types");
  779.         }
  781.         switch( GetType() ) {
  782.         case eDB_Char:
  783.         case eDB_VarChar:
  784.         case eDB_LongChar:
  785.             less = GetString() < v.GetString();
  786.             break;
  787.         case eDB_TinyInt:
  788.             less = GetByte() < v.GetByte();
  789.             break;
  790.         case eDB_SmallInt:      
  791.             less = GetInt2() < v.GetInt2();
  792.             break;
  793.         case eDB_Int:
  794.             less = GetInt4() < v.GetInt4();
  795.             break;
  796.         case eDB_Float:
  797.             less = GetFloat() < v.GetFloat();
  798.             break;
  799.         case eDB_Double:
  800.             less = GetDouble() < v.GetDouble();
  801.             break;
  802.         case eDB_DateTime:
  803.         case eDB_SmallDateTime:
  804.             less = GetCTime() < v.GetCTime();
  805.             break;
  806.         default:
  807.             throw CVariantException
  808.                 ("CVariant::operator<(): type not supported");
  809.         }
  810.     }
  811.     return less;
  812. }
  815. END_NCBI_SCOPE