使用C++模板封装SQLite（完整版）

傷城~ 2022-08-24 04:07 436阅读 0赞

SQLite 是一款开源的嵌入式数据库，由于本身小巧玲珑，比较适合作为应用软件的一部分嵌入到程序中，SQLite提供了一套简单易用的C API供应用程序调用, 但由于API的使用比较繁杂，并且考虑到将来移植到不同数据库的需求，应当避免直接使用SQLite API,应对其适当的封装，增加代码的灵活性。本文就项目中的使用经验提供了一种封装的方法。

１．API层的封装

由于SQLite支持ansi && unicode，为同时支持char, wchar\_t，一些API同时提供了两个版本，如sqlite3\_open，sqlite3\_open16，另外一些API则只有一个版本，基于这两点实现了两个简单的类别:SQLite\_APIBase和SQLite\_APITraits,,SQLite\_APIBase包含char, wchar\_t**无关**的API，SQLite\_APITraits模板从SQLite\_APIBase派生，并针对char, wchar\_t提供了两个特化版本。如下：

1.  struct SQLite\_APIBase
2.  \{
3.  static int Close(sqlite3\* pDb)
4.  \{
5.  return sqlite3\_close(pDb);
6.  \}
7.  
8.  static int Prepare(sqlite3\* db, wchar\_t const\* pszSQL, int nBytes, sqlite3\_stmt \*\*ppStmt, const void\*\* pzTail)
9.  \{
10. return sqlite3\_prepare16(db, pszSQL, nBytes, ppStmt, pzTail);
11. \}
12. 
13. static int Step(sqlite3\_stmt\* pStmt)
14. \{
15. return sqlite3\_step(pStmt);
16. \}
17. 
18. static int Finalize(sqlite3\_stmt \*pStmt)
19. \{
20. return sqlite3\_finalize(pStmt);
21. \}
22. 
23. //set operations 
24. static int BindInt(sqlite3\_stmt \*pStmt, int iIndex, int iValue)
25. \{
26. return sqlite3\_bind\_int(pStmt, iIndex, iValue);
27. \}
28. 
29. static int BindDouble(sqlite3\_stmt \*pStmt, int iIndex, double fValue)
30. \{
31. return sqlite3\_bind\_double(pStmt, iIndex, fValue);
32. \}
33. 
34. static int BindBlob(sqlite3\_stmt \*pStmt, int iIndex, void const\* pData, int iSize)
35. \{
36. return sqlite3\_bind\_blob(pStmt, iIndex, pData, iSize, NULL);
37. \}
38. 
39. ．．．．
40. \};
41. 
42. 
43. 
44. template< class TChar >
45. struct SQLite\_APITraits;
46. 
47. 
48. 
49. template<>
50. struct SQLite\_APITraits<char> : public SQLite\_APIBase
51. \{
52. static int Open( char const\* filename, sqlite3\*\* ppDb)
53. \{
54. return sqlite3\_open(filename, ppDb);
55. \}
56. 
57. 
58. 
59. static int BindText(sqlite3\_stmt \*pStmt, int iIndex, char const\* pText, int iSize)
60. \{
61. return sqlite3\_bind\_text(pStmt, iIndex, pText, iSize, NULL);
62. \}
63. 
64. static char const\* ErrorMsg(sqlite3\* pDB)
65. \{
66. return sqlite3\_errmsg(pDB);
67. \}
68. 
69. 
70. 
71. ...........
72. 
73. \};
74. 
75. 
76. 
77. template<>
78. struct SQLite\_APITraits<wchar\_t> : public SQLite\_APIBase
79. \{
80. static int Open( wchar\_t const\* filename, sqlite3\*\* ppDb)
81. \{
82. return sqlite3\_open16(filename, ppDb);
83. \}
84. 
85. 
86. 
87. static int BindText(sqlite3\_stmt \*pStmt, int iIndex, wchar\_t const\* pText, int iSize)
88. \{
89. return sqlite3\_bind\_text16(pStmt, iIndex, pText, iSize, NULL);
90. \}
91. 
92. static wchar\_t const\* ErrorMsg(sqlite3\* pDB)
93. \{
94. return sqlite3\_errmsg16(pDB);
95. \}
96. 
97. ............
98. 
99. \};
100.

这样以来，使用SQLite API时方便多了，不必针对char wchar\_t调用不同的函数了，现在只需这样SQLite\_APITraits<TCHAR>::some\_func.

２．数据库层的封装

先来看一下数据库的接口

1.  class CDatabase
2.  \{
3.  public:
4.  CDatabase();
5.  virtual ~CDatabase();
6.  
7.  public:
8.  virtual bool Open(TCHAR const\* pszFileName) = 0;
9.  virtual bool Close() = 0;
10. virtual bool Execute(TCHAR const\* pszSQLStatement) = 0;
11. 
12. \}；
13.

CDatabase 提供了3个接口，Open打开数据库文件，Close关闭数据库，Execute执行制定的SQL语句.

这些接口的实现主要用到了下面的一些组件CDBConnection类，CDBStatement类，CResultSet类：

其中，CDBConnection负责管理数据库连接，CDBStatement负责运行SQL语句并生成执行结果，最终通过CResultSet查询结果。

为了使得这些组件能在不同的数据库间移植，需要把不同数据库的具体实现能分离出来，这里我用DBTraits模板来分离，为每种数据库实现一个特化版本，关于Traits用法，请参考侯捷老大一篇文章[Traits: 類型的else-if-then機製][Traits_ _else-if-then].

（为了不影响代码的连贯性，DBTraits模板的代码附在最后）

下面是各个组件的实现，**中间用到了iterator,类似于STL的迭代器但稍稍不同，你将会看到iterator将使得结果查询变得多么简单优雅**

1.  template<class T, class TDBTraits = DBTraits<T>, bool t\_Managed = true>
2.  class CDBConnection
3.  \{
4.  public:
5.  typedef TDBTraits::DBHandle DBHandle;
6.  typedef TDBTraits::SQLStatementHandle SQLStatementHandle;
7.  
8.  public:
9.  CDBConnection():m\_pStatement(NULL)
10. \{
11. \}
12. 
13. ~CDBConnection()
14. \{
15. if (m\_pStatement != NULL)
16. \{
17. delete m\_pStatement;
18. \}
19. 
20. if (t\_Managed)
21. \{
22. bool bRet = Close();
23. assert(bRet);
24. \}
25. \}
26. 
27. public:
28. bool Open(TCHAR const\* pszFileName)
29. \{
30. return TDBTraits::Open(pszFileName);
31. \}
32. 
33. bool Close()
34. \{
35. return TDBTraits::Close();
36. \}
37. 
38. CDBStatement<T, TDBTraits >\* FetchStatement()
39. \{
40. if (m\_pStatement == NULL)
41. \{
42. m\_pStatement = new CDBStatement<T, TDBTraits >;
43. \}
44. 
45. assert(m\_pStatement != NULL);
46. 
47. return m\_pStatement;
48. \}
49. 
50. private:
51. CDBStatement<T, TDBTraits >\* m\_pStatement;
52. \};
53. 
54. 
55. template<class T, class TDBTraits = DBTraits<T> >
56. class CDBStatement
57. \{
58. public:
59. typedef TDBTraits::DBHandle DBHandle;
60. typedef TDBTraits::SQLStatementHandle SQLStatementHandle;
61. typedef CDBRowSet<T, TDBTraits > CResultSet;
62. 
63. public:
64. CDBStatement():m\_pHandle(NULL),m\_pResult(NULL)
65. \{
66. \}
67. 
68. ~CDBStatement()
69. \{
70. if (m\_pResult != NULL)
71. \{
72. delete m\_pResult;
73. \}
74. \}
75. public:
76. bool Execute(TCHAR const\* pszSQLStatement)
77. \{
78. Reset();
79. 
80. bool bRet = TDBTraits::Execute(pszSQLStatement);
81. if (!bRet)
82. \{
83. return false;
84. \}
85. 
86. m\_pHandle = TDBTraits::GetStatementHandle();
87. 
88. if (TDBTraits::HasReturnValue())
89. \{
90. m\_pResult = new CResultSet();
91. assert(m\_pResult != NULL);
92. \}
93. 
94. return true;
95. \}
96. 
97. template<class TValue>
98. bool BindValue(int iIndex, TValue Value, int iSize)
99. \{
100. return TDBTraits::BindVariant(iIndex, Value, iSize);
101. \}
102. 
103. CResultSet\* FetchResult() const
104. \{
105. return m\_pResult;
106. \}
107. 
108. /\*implicit\*/operator SQLStatementHandle() const
109. \{
110. return m\_pHandle
111. \}
112. 
113. private:
114. void Reset()
115. \{
116. // it is OK to delete NULL 
117. if (m\_pResult != NULL)
118. \{
119. delete m\_pResult;
120. m\_pResult = NULL;
121. \}
122. \}
123. 
124. private:
125. CResultSet\* m\_pResult;
126. SQLStatementHandle m\_pHandle;
127. \};
128. 
129. template<class T, class TDBTraits = DBTraits<T> >
130. class CDBIterator
131. \{
132. public:
133. typedef TDBTraits::DBHandle DBHandle;
134. typedef TDBTraits::SQLStatementHandle SQLStatementHandle;
135. typedef CDBRow<T, TDBTraits> RowType;
136. 
137. public:
138. CDBIterator():m\_bIsDone(false)
139. \{
140. 
141. \}
142. ~CDBIterator()\{\}
143. 
144. public:
145. //++ operator 
146. //forward increment 
147. CDBIterator& operator++()
148. \{
149. m\_bIsDone = !(TDBTraits::Forward() );
150. 
151. return \*this;
152. \}
153. 
154. //backwards increment 
155. CDBIterator operator++(int)
156. \{
157. CDBIterator tmp(\*this);
158. 
159. m\_bIsDone = !(TDBTraits::Forward() );
160. 
161. return tmp;
162. \}
163. 
164. //-- operator 
165. //no backwards operation 
166. public:
167. RowType& operator\*()
168. \{
169. return m\_CurrentRow;
170. \}
171. 
172. RowType\* operator&()
173. \{
174. return &m\_CurrentRow;
175. \}
176. 
177. RowType\* operator->()
178. \{
179. return &m\_CurrentRow;
180. \}
181. 
182. public:
183. bool IsDone() const
184. \{
185. return m\_bIsDone;
186. \}
187. 
188. 
189. private:
190. bool m\_bIsDone;
191. RowType m\_CurrentRow;
192. \};
193. 
194. 
195. 
196. template<class T, class TDBTraits = DBTraits<T> >
197. class CDBRow
198. \{
199. public:
200. typedef TDBTraits::DBHandle DBHandle;
201. typedef TDBTraits::SQLStatementHandle SQLStatementHandle;
202. 
203. public:
204. CDBRow()\{\}
205. ~CDBRow()\{\}
206. 
207. public:
208. template< class TValue >
209. bool FetchValue(int iColumn, TValue pRetValue)
210. \{
211. SQLStatementHandle pStmt = TDBTraits::GetStatementHandle();
212. 
213. return TDBTraits::FetchValue(pStmt, iColumn, pRetValue);
214. \}
215. 
216. int FetchBytes(int iColumn)
217. \{
218. SQLStatementHandle pStmt = TDBTraits::GetStatementHandle();
219. 
220. return TDBTraits::FetchColumnBytes(pStmt, iColumn);
221. \}
222. \};
223. 
224. 
225. template<class T, class TDBTraits = DBTraits<T> >
226. class CDBRowSet
227. \{
228. public:
229. typedef TDBTraits::DBHandle DBHandle;
230. typedef TDBTraits::SQLStatementHandle SQLStatementHandle;
231. typedef CDBIterator<T, TDBTraits> iterator;
232. 
233. public:
234. CDBRowSet()
235. :m\_pIterator(NULL)
236. \{
237. \}
238. 
239. ~CDBRowSet()
240. \{
241. if (m\_pIterator != NULL)
242. \{
243. delete m\_pIterator;
244. \}
245. \}
246. 
247. public:
248. bool IsNULL() const
249. \{
250. return TDBTraits::HasReturnValue();
251. \}
252. 
253. //for iterator 
254. iterator& CreateIterator()
255. \{
256. if (m\_pIterator == NULL)
257. \{
258. m\_pIterator = new iterator;
259. \}
260. 
261. return \*m\_pIterator;
262. \}
263. 
264. private:
265. iterator\* m\_pIterator;
266. \};
267. 
268.

下面是将上面3个组件黏合起来的代码，风格类似WTL

//空类，留着扩展

1.  template< class TBase >
2.  class CDatabaseImplRoot : public TBase
3.  \{
4.  public:
5.  CDatabaseImplRoot()\{\}
6.  virtual ~CDatabaseImplRoot()\{\}
7.  
8.  public:
9.  //interface 
10. 
11. private:
12. //implementations 
13. 
14. \};
15. 
16. template< class T, class TBase = CDatabase,class TDBTraits = DBTraits<T>, bool t\_Managed = true >
17. class CDatabaseImpl : public CDatabaseImplRoot<TBase>
18. \{
19. public:
20. typedef TDBTraits::DBHandle DBHandle;
21. typedef TDBTraits::SQLStatementHandle SQLStatementHandle;
22. typedef CDBIterator<T, TDBTraits> iterator;
23. typedef CDBStatement<T, TDBTraits>::CResultSet ResultSet;
24. 
25. public:
26. CDatabaseImpl()\{\}
27. virtual ~CDatabaseImpl()\{\}
28. 
29. protected:
30. CDBConnection< T, TDBTraits >\* GetConnection()
31. \{
32. return &m\_Connection;
33. \}
34. 
35. private:
36. CDBConnection< T, TDBTraits, t\_Managed> m\_Connection;
37. CDBStatement< T, TDBTraits > m\_pStatement;
38. 
39. \};
40.

好了，最终的CDatabaseImpl就是所有数据库类的共同基类，每种数据库具体实现全在DBTraits里，CDatabaseImpl是数据库无关的.

最终的CSQLiteDatabase是这样的：

1.  class CSQLiteDatabase : public CDatabaseImpl<CSQLiteDatabase, CDatabase>
2.  \{
3.  public:
4.  typedef CDatabaseImpl<CSQLiteDatabase, CDatabase> Base;
5.  typedef Base::iterator iterator;
6.  typedef Base::ResultSet ResultSet;
7.  public:
8.  CSQLiteDatabase();
9.  virtual ~CSQLiteDatabase();
10. 
11. public:
12. virtual bool Open(TCHAR const\* pszFileName);
13. virtual bool Close();
14. virtual bool Execute(TCHAR const\* pszSQLStatement);
15. 
16. public:
17. template<class T>
18. bool BindValue(int iIndex, T Value, int iSize)
19. \{
20. return GetConnection()->FetchStatement()->BindValue(iIndex,Value, iSize);
21. \}
22. 
23. ResultSet\* GetResult();
24. 
25. private:
26. 
27. 
28. \};
29. 
30. 
31. 
32. CSQLiteDatabase::CSQLiteDatabase()
33. \{
34. 
35. \}
36. 
37. CSQLiteDatabase::~CSQLiteDatabase()
38. \{
39. 
40. \}
41. 
42. bool CSQLiteDatabase::Open(TCHAR const\* pszFileName)
43. \{
44. return GetConnection()->Open(pszFileName);
45. \}
46. 
47. bool CSQLiteDatabase::Close()
48. \{
49. return GetConnection()->Close();
50. \}
51. 
52. bool CSQLiteDatabase::Execute(TCHAR const\* pszSQLStatement)
53. \{
54. return GetConnection()->FetchStatement()->Execute(pszSQLStatement);
55. \}
56. 
57. CSQLiteDatabase::ResultSet\* CSQLiteDatabase::GetResult()
58. \{
59. return GetConnection()->FetchStatement()->FetchResult();
60. \}
61. 
62.

CSQLiteDatabase实现了CDatabase定义的接口，现在可以使用了

现在有两个数据表(我不太懂数据库设计，可能有问题)

tbl\_student: id, name存储学生的学号和姓名

tbl\_score: id，chinese,math,english存储学生的学号和语文，数学，英语成绩．

现在假设查询王小明的成绩：

1.  CSQLiteDatabase\* pDatabase = GetDatabase();
2.  bool bRet = pDatabase->Execute(\_T("select a.id, b.chinese, b.math, b.english from tbl\_student a, tbl\_score b where a.name = 王小明 and a. id ==b.id"));
3.  if (bRet)
4.  \{
5.  CSQLiteDatabase::ResultSet\* pSet = pDatabase->GetResult();
6.  //如果不是查询语句，则pSet == NULL 
7.  
8.  if (pSet != NULL)
9.  \{
10. for (CSQLiteDatabase::iterator i = pSet->CreateIterator(); !i.IsDone() ; ++i)
11. \{
12. int id;
13. 
14. tchar strChinese\[MAX\];
15. 
16. tchar strMath\[MAX\];
17. 
18. tchar strEnglish\[MAX\];
19. 
20. int iIndex = 0;
21. bRet = (\*i).FetchValue(iIndex++,id);
22. 
23. bRet = (\*i).FetchValue(iIndex++,strChinese);
24. 
25. bRet = (\*i).FetchValue(iIndex++,strMath);
26. 
27. bRet = (\*i).FetchValue(iIndex++,strEnglish);
28. \}
29. \}
30. \}
31.

怎么样很简单吧.

附 DBTraits 源代码：

1.  template< class TDatabase >
2.  struct DBTraits;
3.  
4.  template<>
5.  struct DBTraits<CSQLiteDatabase>
6.  \{
7.  typedef sqlite3\* DBHandle;
8.  typedef sqlite3\_stmt\* SQLStatementHandle;
9.  // typedef struct 
10. 
11. static bool Open(TCHAR const\* pszFileName)
12. \{
13. if (!Close())
14. \{
15. return false;
16. \}
17. 
18. assert(m\_pDatabase == NULL);
19. 
20. int iRet = SQLite\_APITraits<TCHAR>::Open(pszFileName,&m\_pDatabase);
21. if (iRet != SQLITE\_OK)
22. \{
23. return false;
24. \}
25. 
26. assert(m\_pDatabase != NULL);
27. 
28. return true;
29. \}
30. 
31. static bool Close()
32. \{
33. if (m\_pStatement != NULL)
34. \{
35. int iRet = SQLite\_APITraits<TCHAR>::Finalize(m\_pStatement);
36. if (iRet != SQLITE\_OK)
37. \{
38. return false;
39. \}
40. 
41. m\_pStatement = NULL;
42. \}
43. 
44. if (m\_pDatabase != NULL)
45. \{
46. int iRet = SQLite\_APITraits<TCHAR>::Close(m\_pDatabase);
47. if (iRet == SQLITE\_BUSY)
48. \{
49. return false;
50. \}
51. 
52. m\_pDatabase = NULL;
53. \}
54. 
55. return true;
56. \}
57. 
58. static bool Execute(TCHAR const\* pszSQLStatement)
59. \{
60. if (m\_pDatabase == NULL/\* || m\_pStatement == NULL\*/)
61. \{
62. return false;
63. \}
64. 
65. ResetStatement();
66. 
67. int iRet = SQLite\_APITraits<TCHAR>::Prepare(m\_pDatabase, pszSQLStatement, -1, &m\_pStatement, NULL);
68. if (iRet != SQLITE\_OK)
69. \{
70. return false;
71. \}
72. 
73. assert(m\_pStatement != NULL);
74. 
75. 
76. //BindValue(sqlite3\_stmt \*pStmt, int iIndex, T Value, int iSize = 0); 
77. for (std::list<DBVariant<TCHAR> >::iterator i = m\_listBindValue.begin(); i != m\_listBindValue.end(); ++i)
78. \{
79. DBVariant<TCHAR> Value= (\*i);
80. if (Value.m\_iType == DBVariant<TCHAR>::VALUE\_INT)
81. \{
82. SQLite\_APITraits<TCHAR>::BindValue(m\_pStatement, Value.m\_iIndex, Value.m\_iIntValue, Value.m\_iSize);
83. \}
84. else if (Value.m\_iType == DBVariant<TCHAR>::VALUE\_DOUBLE)
85. \{
86. SQLite\_APITraits<TCHAR>::BindValue(m\_pStatement, Value.m\_iIndex, Value.m\_fDoubleValue, Value.m\_iSize);
87. \}
88. else if (Value.m\_iType == DBVariant<TCHAR>::VALUE\_TEXT)
89. \{
90. SQLite\_APITraits<TCHAR>::BindValue(m\_pStatement, Value.m\_iIndex, Value.m\_pTextValue, Value.m\_iSize);
91. \}
92. else if (Value.m\_iType == DBVariant<TCHAR>::VALUE\_BLOB)
93. \{
94. SQLite\_APITraits<TCHAR>::BindValue(m\_pStatement, Value.m\_iIndex, Value.m\_pBlobValue, Value.m\_iSize);
95. \}
96. else
97. \{
98. assert(false);
99. \}
100. \}
101. 
102. m\_listBindValue.clear();
103. 
104. iRet = SQLite\_APITraits<TCHAR>::Step(m\_pStatement);
105. if (iRet != SQLITE\_DONE && iRet != SQLITE\_ROW)
106. \{
107. return false;
108. \}
109. 
110. if (iRet == SQLITE\_ROW)
111. \{
112. m\_bHasReturnValue = true;
113. \}
114. 
115. // iRet = SQLite\_APITraits<TCHAR>::Finalize(m\_pStatement); 
116. // if (iRet != SQLITE\_OK) 
117. // \{ 
118. // return false; 
119. // \} 
120. 
121. return true;
122. \}
123. 
124. static DBHandle& GetDBHandle()
125. \{
126. return m\_pDatabase;
127. \}
128. 
129. static SQLStatementHandle& GetStatementHandle()
130. \{
131. return m\_pStatement;
132. \}
133. 
134. static void ResetStatement()
135. \{
136. if (m\_pStatement != NULL)
137. \{
138. int iRet = SQLite\_APITraits<TCHAR>::Finalize(m\_pStatement);
139. if (iRet != SQLITE\_OK)
140. \{
141. assert(false);
142. \}
143. 
144. m\_pStatement = NULL;
145. \}
146. 
147. \}
148. 
149. static bool HasReturnValue()
150. \{
151. return m\_bHasReturnValue;
152. \}
153. 
154. static bool Forward()
155. \{
156. int iRet = SQLite\_APITraits<TCHAR>::Step(m\_pStatement);
157. 
158. if (iRet == SQLITE\_DONE)
159. \{
160. ResetStatement();
161. \}
162. 
163. m\_bHasReturnValue = (iRet == SQLITE\_ROW);
164. 
165. return m\_bHasReturnValue;
166. \}
167. 
168. static int FetchColumnCount(SQLStatementHandle pStmt)
169. \{
170. return SQLite\_APITraits<TCHAR>::ColumnCount(pStmt);
171. \}
172. 
173. static int FetchColumnType(SQLStatementHandle pStmt, int iColumn)
174. \{
175. return SQLite\_APITraits<TCHAR>::ColumnType(pStmt, iColumn);
176. \}
177. 
178. static wchar\_t const\* FetchColumnName(SQLStatementHandle pStmt, int iColumn)
179. \{
180. return SQLite\_APITraits<TCHAR>::ColumnName(pStmt, iColumn);
181. \}
182. 
183. static int FetchColumnBytes(SQLStatementHandle pStmt, int iColumn)
184. \{
185. return SQLite\_APITraits<TCHAR>::ColumnBytes(pStmt, iColumn);
186. \}
187. 
188. template< class T >
189. static bool FetchValue(SQLStatementHandle pStmt, int iColumn, T pRetValue)
190. \{
191. return SQLite\_APITraits<TCHAR>::FetchColumnValue(pStmt, iColumn, pRetValue);
192. \}
193. 
194. // template< class T > 
195. // static int BindValue(SQLStatementHandle pStmt, int iIndex, T Value, int iSize) 
196. // \{ 
197. // return SQLite\_APITraits<TCHAR>::BindValue(pStmt, iColumn, Value, iSize); 
198. // \} 
199. 
200. template< class T >
201. static bool BindVariant(int iIndex, T Value, int iSize/\* = 0\*/)
202. \{
203. return false;
204. \}
205. 
206. template<>
207. static bool BindVariant<int>(int iIndex, int Value, int iSize/\* = 0\*/)
208. \{
209. DBVariant<TCHAR> Var;
210. Var.m\_iType = DBVariant<TCHAR>::VALUE\_INT;
211. Var.m\_iIndex = iIndex;
212. Var.m\_iIntValue = Value;
213. Var.m\_iSize = iSize;
214. m\_listBindValue.push\_back(Var);
215. 
216. return true;
217. \}
218. 
219. template<>
220. static bool BindVariant<double>(int iIndex, double Value, int iSize/\* = 0\*/)
221. \{
222. DBVariant<TCHAR> Var;
223. Var.m\_iType = DBVariant<TCHAR>::VALUE\_DOUBLE;
224. Var.m\_iIndex = iIndex;
225. Var.m\_fDoubleValue = Value;
226. Var.m\_iSize = iSize;
227. m\_listBindValue.push\_back(Var);
228. 
229. return true;
230. \}
231. 
232. template<>
233. static bool BindVariant<TCHAR const\*>(int iIndex, TCHAR const\* Value, int iSize)
234. \{
235. DBVariant<TCHAR> Var;
236. Var.m\_iType = DBVariant<TCHAR>::VALUE\_TEXT;
237. Var.m\_iIndex = iIndex;
238. Var.m\_pTextValue = Value;
239. Var.m\_iSize = iSize;
240. m\_listBindValue.push\_back(Var);
241. 
242. return true;
243. \}
244. 
245. template<>
246. static bool BindVariant<void const\*>(int iIndex, void const\* pData, int iSize)
247. \{
248. DBVariant<TCHAR> Var;
249. Var.m\_iType = DBVariant<TCHAR>::VALUE\_BLOB;
250. Var.m\_iIndex = iIndex;
251. Var.m\_pBlobValue = pData;
252. Var.m\_iSize = iSize;
253. 
254. m\_listBindValue.push\_back(Var);
255. 
256. return true;
257. \}
258. 
259. private:
260. static DBHandle m\_pDatabase;
261. static SQLStatementHandle m\_pStatement;
262. static bool m\_bHasReturnValue;
263. static std::list<DBVariant<TCHAR> > m\_listBindValue;
264. \};
265. 
266.

[Traits_ _else-if-then]: http://jjhou.csdn.net/myan-type-traits.htm