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

    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.     }
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.     }
13.     static int Step(sqlite3_stmt* pStmt)
14.     {
15.         return sqlite3_step(pStmt);
16.     }
18.     static int Finalize(sqlite3_stmt *pStmt)
19.     {
20.         return sqlite3_finalize(pStmt);
21.     }
23.     //set operations
24.     static int BindInt(sqlite3_stmt *pStmt, int iIndex, int iValue)
25.     {
26.         return sqlite3_bind_int(pStmt, iIndex, iValue);
27.     }
29.     static int BindDouble(sqlite3_stmt *pStmt, int iIndex, double fValue)
30.     {
31.         return sqlite3_bind_double(pStmt, iIndex, fValue);
32.     }
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.     }
39.     ．．．．
40. };
44. template< class TChar >
45. struct SQLite_APITraits;
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.     }
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.     }
64.     static char const* ErrorMsg(sqlite3* pDB)
65.     {
66.         return sqlite3_errmsg(pDB);
67.     }
71.     ...........
73. };
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.     }
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.     }
92.     static wchar_t const* ErrorMsg(sqlite3* pDB)
93.     {
94.         return sqlite3_errmsg16(pDB);
95.     }
97.     ............
99. };

这样以来，使用SQLite API时方便多了，不必针对char wchar_t调用不同的函数了，现在只需这样SQLite_APITraits::some_func.

    

    ２．数据库层的封装

先来看一下数据库的接口

 

 

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

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

 

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

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

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

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

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

 

1. template<class T, class TDBTraits = DBTraits, bool t_Managed = true>
2. class CDBConnection
3. {
4. public:
5.  typedef TDBTraits::DBHandle DBHandle;
6.  typedef TDBTraits::SQLStatementHandle SQLStatementHandle;
8. public:
9.  CDBConnection():m_pStatement(NULL)
10.  {
11.  }
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.  }
27. public:
28.  bool Open(TCHAR const* pszFileName)
29.  {
30.   return TDBTraits::Open(pszFileName);
31.  }
33.  bool Close()
34.  {
35.   return TDBTraits::Close();
36.  }
38.  CDBStatement* FetchStatement()
39.  {
40.   if (m_pStatement == NULL)
41.   {
42.    m_pStatement = new CDBStatement;
43.   }
45.   assert(m_pStatement != NULL);
47.   return m_pStatement;
48.  }
50. private:
51.  CDBStatement* m_pStatement;
52. };
55. template<class T, class TDBTraits = DBTraits >
56. class CDBStatement
57. {
58. public:
59.  typedef TDBTraits::DBHandle DBHandle;
60.  typedef TDBTraits::SQLStatementHandle SQLStatementHandle;
61.  typedef CDBRowSet CResultSet;
63. public:
64.  CDBStatement():m_pHandle(NULL),m_pResult(NULL)
65.  {
66.  }
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.   }
94.   return true;
95.  }
97.  template<class TValue>
98.  bool BindValue(int iIndex, TValue Value, int iSize)
99.  {
100.   return TDBTraits::BindVariant(iIndex, Value, iSize);
101.  }
103.  CResultSet* FetchResult() const
104.  {
105.   return m_pResult;
106.  }
108.  /*implicit*/operator SQLStatementHandle() const
109.  {
110.   return m_pHandle
111.  }
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.  }
124. private:
125.  CResultSet* m_pResult;
126.  SQLStatementHandle m_pHandle;
127. };
129. template<class T, class TDBTraits = DBTraits >
130. class CDBIterator
131. {
132. public:
133.  typedef TDBTraits::DBHandle DBHandle;
134.  typedef TDBTraits::SQLStatementHandle SQLStatementHandle;
135.  typedef CDBRow RowType;
137. public:
138.  CDBIterator():m_bIsDone(false)
139.  {
141.  }
142.  ~CDBIterator(){}
144. public:
145.  //++ operator
146.  //forward increment
147.  CDBIterator& operator++()
148.  {
149.   m_bIsDone = !(TDBTraits::Forward() );
151.   return *this;
152.  }
154.  //backwards increment
155.  CDBIterator operator++(int)
156.  {
157.   CDBIterator tmp(*this);
158.   
159.   m_bIsDone = !(TDBTraits::Forward() );
161.   return tmp;
162.  }
164.  //-- operator
165.  //no backwards operation
166. public:
167.  RowType& operator*()
168.  {
169.   return m_CurrentRow;
170.  }
172.  RowType* operator&()
173.  {
174.   return &m_CurrentRow;
175.  }
177.  RowType* operator->()
178.  {
179.   return &m_CurrentRow;
180.  }
182. public:
183.  bool IsDone() const
184.  {
185.   return m_bIsDone;
186.  }
189. private:
190.  bool m_bIsDone;
191.  RowType m_CurrentRow;
192. };
196. template<class T, class TDBTraits = DBTraits >
197. class CDBRow
198. {
199. public:
200.  typedef TDBTraits::DBHandle DBHandle;
201.  typedef TDBTraits::SQLStatementHandle SQLStatementHandle;
203. public:
204.  CDBRow(){}
205.  ~CDBRow(){}
207. public:
208.  template< class TValue >
209.  bool FetchValue(int iColumn, TValue pRetValue)
210.  {
211.   SQLStatementHandle pStmt = TDBTraits::GetStatementHandle();
213.   return TDBTraits::FetchValue(pStmt, iColumn, pRetValue);
214.  }
216.  int FetchBytes(int iColumn)
217.  {
218.   SQLStatementHandle pStmt = TDBTraits::GetStatementHandle();
219.   
220.   return TDBTraits::FetchColumnBytes(pStmt, iColumn);
221.  }
222. };
225. template<class T, class TDBTraits = DBTraits >
226. class CDBRowSet
227. {
228. public:
229.  typedef TDBTraits::DBHandle DBHandle;
230.  typedef TDBTraits::SQLStatementHandle SQLStatementHandle;
231.  typedef CDBIterator iterator;
233. public:
234.  CDBRowSet()
235.  :m_pIterator(NULL)
236.  {
237.  }
239.  ~CDBRowSet()
240.  {
241.   if (m_pIterator != NULL)
242.   {
243.    delete m_pIterator;
244.   }
245.  }
247. public:
248.  bool IsNULL() const
249.  {
250.   return TDBTraits::HasReturnValue();
251.  }
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.  }
264. private:
265.  iterator* m_pIterator;
266. };

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

//空类，留着扩展

 

 

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

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

 

最终的CSQLiteDatabase是这样的：

 

1. class CSQLiteDatabase : public CDatabaseImpl  
2. {
3. public:
4.  typedef CDatabaseImpl Base;
5.  typedef Base::iterator iterator;
6.  typedef Base::ResultSet ResultSet;
7. public:
8.  CSQLiteDatabase();
9.  virtual ~CSQLiteDatabase();
11. public:
12.  virtual bool Open(TCHAR const* pszFileName);
13.  virtual bool Close();
14.  virtual bool Execute(TCHAR const* pszSQLStatement);
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.  }
23.  ResultSet* GetResult();
25. private:
28. };
32. CSQLiteDatabase::CSQLiteDatabase()
33. {
35. }
37. CSQLiteDatabase::~CSQLiteDatabase()
38. {
40. }
42. bool CSQLiteDatabase::Open(TCHAR const* pszFileName)
43. {
44.  return GetConnection()->Open(pszFileName);
45. }
47. bool CSQLiteDatabase::Close()
48. {
49.  return GetConnection()->Close();
50. }
52. bool CSQLiteDatabase::Execute(TCHAR const* pszSQLStatement)
53. {
54.  return GetConnection()->FetchStatement()->Execute(pszSQLStatement);
55. }
57. CSQLiteDatabase::ResultSet* CSQLiteDatabase::GetResult()
58. {
59.  return GetConnection()->FetchStatement()->FetchResult();
60. }

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
8.   if (pSet != NULL)
9.   {  
10.    for (CSQLiteDatabase::iterator i = pSet->CreateIterator(); !i.IsDone() ; ++i)
11.    {
12.     int id;
14.     tchar strChinese[MAX];
16.     tchar strMath[MAX];
18.     tchar strEnglish[MAX];
20.     int iIndex = 0;
21.     bRet = (*i).FetchValue(iIndex++,id);
23.     bRet = (*i).FetchValue(iIndex++,strChinese);
25.     bRet = (*i).FetchValue(iIndex++,strMath);
27.     bRet = (*i).FetchValue(iIndex++,strEnglish);
28.    }
29.   }
30.  }

怎么样很简单吧.

 

附 DBTraits 源代码：

1. template< class TDatabase >
2. struct DBTraits;
4. template<>
5. struct DBTraits
6. {
7.  typedef sqlite3* DBHandle;
8.  typedef sqlite3_stmt* SQLStatementHandle;
9. // typedef struct  
11.  static bool Open(TCHAR const* pszFileName)
12.  {
13.   if (!Close())
14.   {
15.    return false;
16.   }
18.   assert(m_pDatabase == NULL);
19.   
20.   int iRet = SQLite_APITraits::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.  }
31.  static bool Close()
32.  {
33.   if (m_pStatement != NULL)
34.   {
35.    int iRet = SQLite_APITraits::Finalize(m_pStatement);
36.    if (iRet != SQLITE_OK)
37.    {
38.     return false;
39.    }
41.    m_pStatement = NULL;
42.   }
43.   
44.   if (m_pDatabase != NULL)
45.   {
46.    int iRet = SQLite_APITraits::Close(m_pDatabase);
47.    if (iRet == SQLITE_BUSY)
48.    {
49.     return false;
50.    }
51.    
52.    m_pDatabase = NULL;
53.   }
54.   
55.   return true;
56.  }
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::Prepare(m_pDatabase, pszSQLStatement, -1, &m_pStatement, NULL);
68.   if (iRet != SQLITE_OK)
69.   {
70.    return false;
71.   }
72.   
73.   assert(m_pStatement != NULL);
76.   //BindValue(sqlite3_stmt *pStmt, int iIndex, T Value, int iSize = 0);
77.   for (std::list >::iterator i = m_listBindValue.begin(); i != m_listBindValue.end(); ++i)
78.   {
79.    DBVariant Value= (*i);
80.    if (Value.m_iType == DBVariant::VALUE_INT)
81.    {
82.     SQLite_APITraits::BindValue(m_pStatement, Value.m_iIndex, Value.m_iIntValue, Value.m_iSize);
83.    }
84.    else if (Value.m_iType == DBVariant::VALUE_DOUBLE)
85.    {
86.     SQLite_APITraits::BindValue(m_pStatement, Value.m_iIndex, Value.m_fDoubleValue, Value.m_iSize);
87.    }
88.    else if (Value.m_iType == DBVariant::VALUE_TEXT)
89.    {
90.     SQLite_APITraits::BindValue(m_pStatement, Value.m_iIndex, Value.m_pTextValue, Value.m_iSize);
91.    }
92.    else if (Value.m_iType == DBVariant::VALUE_BLOB)
93.    {
94.     SQLite_APITraits::BindValue(m_pStatement, Value.m_iIndex, Value.m_pBlobValue, Value.m_iSize);
95.    }
96.    else
97.    {
98.     assert(false);
99.    }
100.   }
102.   m_listBindValue.clear();
103.   
104.   iRet = SQLite_APITraits::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::Finalize(m_pStatement);
116. //  if (iRet != SQLITE_OK)
117. //  {
118. //   return false;
119. //  }
121.   return true;
122.  }
124.  static DBHandle& GetDBHandle()
125.  {
126.   return m_pDatabase;
127.  }
129.  static SQLStatementHandle& GetStatementHandle()
130.  {
131.   return m_pStatement;
132.  }
134.  static void ResetStatement()
135.  {
136.   if (m_pStatement != NULL)
137.   {
138.    int iRet = SQLite_APITraits::Finalize(m_pStatement);
139.    if (iRet != SQLITE_OK)
140.    {
141.     assert(false);
142.    }
144.    m_pStatement = NULL;
145.   }
147.  }
149.  static bool HasReturnValue()
150.  {
151.   return m_bHasReturnValue;
152.  }
154.  static bool Forward()
155.  {
156.   int iRet = SQLite_APITraits::Step(m_pStatement);
158.   if (iRet == SQLITE_DONE)
159.   {
160.    ResetStatement();
161.   }
162.   
163.   m_bHasReturnValue = (iRet == SQLITE_ROW);
165.   return m_bHasReturnValue;
166.  }
168.  static int FetchColumnCount(SQLStatementHandle pStmt)
169.  {
170.   return SQLite_APITraits::ColumnCount(pStmt);
171.  }
173.  static int FetchColumnType(SQLStatementHandle pStmt, int iColumn)
174.  {
175.   return SQLite_APITraits::ColumnType(pStmt, iColumn);
176.  }
178.  static wchar_t const* FetchColumnName(SQLStatementHandle pStmt, int iColumn)
179.  {
180.   return SQLite_APITraits::ColumnName(pStmt, iColumn);
181.  }
183.  static int FetchColumnBytes(SQLStatementHandle pStmt, int iColumn)
184.  {
185.   return SQLite_APITraits::ColumnBytes(pStmt, iColumn);
186.  }
188.  template< class T >
189.  static bool FetchValue(SQLStatementHandle pStmt, int iColumn, T pRetValue)
190.  {
191.   return SQLite_APITraits::FetchColumnValue(pStmt, iColumn, pRetValue);
192.  }
194. // template< class T >
195. // static int BindValue(SQLStatementHandle pStmt, int iIndex, T Value, int iSize)
196. // {
197. //  return SQLite_APITraits::BindValue(pStmt, iColumn, Value, iSize);
198. // }
200.  template< class T >
201.  static bool BindVariant(int iIndex, T Value, int iSize/* = 0*/)
202.  {
203.   return false;
204.  }
206.  template<>
207.  static bool BindVariant<int>(int iIndex, int Value, int iSize/* = 0*/)
208.  {
209.   DBVariant Var;
210.   Var.m_iType = DBVariant::VALUE_INT;
211.   Var.m_iIndex = iIndex;
212.   Var.m_iIntValue = Value;
213.   Var.m_iSize = iSize;
214.   m_listBindValue.push_back(Var);
216.   return true;
217.  }
219.  template<>
220.  static bool BindVariant<double>(int iIndex, double Value, int iSize/* = 0*/)
221.  {
222.   DBVariant Var;
223.   Var.m_iType = DBVariant::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.  }
232.  template<>
233.  static bool BindVariantconst*>(int iIndex, TCHAR const* Value, int iSize)
234.  {
235.   DBVariant Var;
236.   Var.m_iType = DBVariant::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.  }
245.  template<>
246.  static bool BindVariant<void const*>(int iIndex, void const* pData, int iSize)
247.  {
248.   DBVariant Var;
249.   Var.m_iType = DBVariant::VALUE_BLOB;
250.   Var.m_iIndex = iIndex;
251.   Var.m_pBlobValue = pData;
252.   Var.m_iSize = iSize;
254.   m_listBindValue.push_back(Var);
255.   
256.   return true;
257.  }
259. private:
260.  static DBHandle m_pDatabase;
261.  static SQLStatementHandle m_pStatement;
262.  static bool  m_bHasReturnValue;
263.  static std::list > m_listBindValue;
264. };