SQLite C++操作类

为了方便SQLite的使用，封装了一个SQLite的C++类，同时支持ANSI 和UNICODE编码。代码如下：

头文件（SQLite.h）

[cpp] view plain copy print ?

1. /******************************************************************** 
2. filename:   SQLite.h 
3. created:    2012-11-05 
4. author:     firehood 
5.  
6. purpose:    SQLite数据库操作类 
7. *********************************************************************/  
8. #pragma once   
9. #include <windows.h>   
10. #include "..\SQLite\sqlite3.h"    
11. #pragma comment(lib,"SQLite.lib")   
12.   
13. typedef BOOL (WINAPI *QueryCallback) (void *para, int n_column, char **column_value, char **column_name);  
14.   
15. typedef enum _SQLITE_DATATYPE  
16. {  
17.     SQLITE_DATATYPE_INTEGER = SQLITE_INTEGER,  
18.     SQLITE_DATATYPE_FLOAT  = SQLITE_FLOAT,  
19.     SQLITE_DATATYPE_TEXT  = SQLITE_TEXT,  
20.     SQLITE_DATATYPE_BLOB = SQLITE_BLOB,  
21.     SQLITE_DATATYPE_NULL= SQLITE_NULL,  
22. }SQLITE_DATATYPE;  
23.   
24. class SQLite;  
25.   
26. class SQLiteDataReader  
27. {  
28. public:  
29.     SQLiteDataReader(sqlite3_stmt *pStmt);  
30.     ~SQLiteDataReader();  
31. public:  
32.     // 读取一行数据   
33.     BOOL Read();  
34.     // 关闭Reader，读取结束后调用   
35.     void Close();  
36.     // 总的列数   
37.     int ColumnCount(void);  
38.     // 获取某列的名称    
39.     LPCTSTR GetName(int nCol);  
40.     // 获取某列的数据类型   
41.     SQLITE_DATATYPE GetDataType(int nCol);  
42.     // 获取某列的值(字符串)   
43.     LPCTSTR GetStringValue(int nCol);  
44.     // 获取某列的值(整形)   
45.     int GetIntValue(int nCol);  
46.     // 获取某列的值(长整形)   
47.     long GetInt64Value(int nCol);  
48.     // 获取某列的值(浮点形)   
49.     double GetFloatValue(int nCol);  
50.     // 获取某列的值(二进制数据)   
51.     const BYTE* GetBlobValue(int nCol, int &nLen);  
52. private:  
53.     sqlite3_stmt *m_pStmt;  
54. };  
55.   
56. class SQLiteCommand  
57. {  
58. public:  
59.     SQLiteCommand(SQLite* pSqlite);  
60.     SQLiteCommand(SQLite* pSqlite,LPCTSTR lpSql);  
61.     ~SQLiteCommand();  
62. public:  
63.     // 设置命令   
64.     BOOL SetCommandText(LPCTSTR lpSql);  
65.     // 绑定参数（index为要绑定参数的序号，从1开始）  
66.     BOOL BindParam(int index, LPCTSTR szValue);  
67.     BOOL BindParam(int index, const int nValue);  
68.     BOOL BindParam(int index, const double dValue);  
69.     BOOL BindParam(int index, const unsigned char* blobValue, int nLen);  
70.     // 执行命令   
71.     BOOL Excute();  
72.     // 清除命令（命令不再使用时需调用该接口清除）   
73.     void Clear();  
74. private:  
75.     SQLite *m_pSqlite;  
76.     sqlite3_stmt *m_pStmt;  
77. };  
78.   
79. class SQLite  
80. {  
81. public:  
82.     SQLite(void);  
83.     ~SQLite(void);  
84. public:  
85.     // 打开数据库   
86.     BOOL Open(LPCTSTR lpDbFlie);  
87.     // 关闭数据库   
88.     void Close();  
89.   
90.     // 执行非查询操作（更新或删除）   
91.     BOOL ExcuteNonQuery(LPCTSTR lpSql);  
92.     BOOL ExcuteNonQuery(SQLiteCommand* pCmd);  
93.   
94.     // 查询   
95.     SQLiteDataReader ExcuteQuery(LPCTSTR lpSql);  
96.     // 查询（回调方式）   
97.     BOOL ExcuteQuery(LPCTSTR lpSql,QueryCallback pCallBack);  
98.   
99.     // 开始事务   
100.     BOOL BeginTransaction();  
101.     // 提交事务   
102.     BOOL CommitTransaction();  
103.     // 回滚事务   
104.     BOOL RollbackTransaction();  
105.   
106.     // 获取上一条错误信息   
107.     LPCTSTR GetLastErrorMsg();  
108. public:  
109.     friend class SQLiteCommand;  
110. private:  
111.     sqlite3 *m_db;  
112. };  

/********************************************************************
filename: 	SQLite.h
created:	2012-11-05
author:		firehood

purpose:	SQLite数据库操作类
*********************************************************************/
#pragma once
#include <windows.h>
#include "..\SQLite\sqlite3.h" 
#pragma comment(lib,"SQLite.lib") 

typedef BOOL (WINAPI *QueryCallback) (void *para, int n_column, char **column_value, char **column_name);

typedef enum _SQLITE_DATATYPE
{
	SQLITE_DATATYPE_INTEGER = SQLITE_INTEGER,
	SQLITE_DATATYPE_FLOAT  = SQLITE_FLOAT,
	SQLITE_DATATYPE_TEXT  = SQLITE_TEXT,
	SQLITE_DATATYPE_BLOB = SQLITE_BLOB,
	SQLITE_DATATYPE_NULL= SQLITE_NULL,
}SQLITE_DATATYPE;

class SQLite;

class SQLiteDataReader
{
public:
	SQLiteDataReader(sqlite3_stmt *pStmt);
	~SQLiteDataReader();
public:
	// 读取一行数据
	BOOL Read();
	// 关闭Reader，读取结束后调用
	void Close();
	// 总的列数
    int ColumnCount(void);
	// 获取某列的名称 
	LPCTSTR GetName(int nCol);
	// 获取某列的数据类型
	SQLITE_DATATYPE GetDataType(int nCol);
	// 获取某列的值(字符串)
	LPCTSTR GetStringValue(int nCol);
	// 获取某列的值(整形)
	int GetIntValue(int nCol);
	// 获取某列的值(长整形)
	long GetInt64Value(int nCol);
	// 获取某列的值(浮点形)
	double GetFloatValue(int nCol);
	// 获取某列的值(二进制数据)
	const BYTE* GetBlobValue(int nCol, int &nLen);
private:
	sqlite3_stmt *m_pStmt;
};

class SQLiteCommand
{
public:
	SQLiteCommand(SQLite* pSqlite);
	SQLiteCommand(SQLite* pSqlite,LPCTSTR lpSql);
	~SQLiteCommand();
public:
	// 设置命令
	BOOL SetCommandText(LPCTSTR lpSql);
	// 绑定参数（index为要绑定参数的序号，从1开始）
	BOOL BindParam(int index, LPCTSTR szValue);
	BOOL BindParam(int index, const int nValue);
	BOOL BindParam(int index, const double dValue);
	BOOL BindParam(int index, const unsigned char* blobValue, int nLen);
	// 执行命令
	BOOL Excute();
	// 清除命令（命令不再使用时需调用该接口清除）
	void Clear();
private:
	SQLite *m_pSqlite;
	sqlite3_stmt *m_pStmt;
};

class SQLite
{
public:
	SQLite(void);
	~SQLite(void);
public:
	// 打开数据库
    BOOL Open(LPCTSTR lpDbFlie);
	// 关闭数据库
	void Close();

    // 执行非查询操作（更新或删除）
	BOOL ExcuteNonQuery(LPCTSTR lpSql);
	BOOL ExcuteNonQuery(SQLiteCommand* pCmd);

    // 查询
	SQLiteDataReader ExcuteQuery(LPCTSTR lpSql);
	// 查询（回调方式）
	BOOL ExcuteQuery(LPCTSTR lpSql,QueryCallback pCallBack);

	// 开始事务
	BOOL BeginTransaction();
	// 提交事务
	BOOL CommitTransaction();
	// 回滚事务
	BOOL RollbackTransaction();

	// 获取上一条错误信息
	LPCTSTR GetLastErrorMsg();
public:
	friend class SQLiteCommand;
private:
	sqlite3 *m_db;
};

源文件（SQLite.cpp）

[cpp] view plain copy print ?

1. /******************************************************************** 
2. filename:   SQLite.cpp 
3. created:    2012-11-05 
4. author:     firehood 
5.  
6. purpose:    SQLite数据库操作类 
7. *********************************************************************/  
8. #include "SQLite.h"   
9.   
10. const char* WcharToUtf8(const wchar_t *pwStr)  
11. {  
12.     if (pwStr == NULL)  
13.     {  
14.         return NULL;  
15.     }  
16.   
17.     int len = WideCharToMultiByte(CP_UTF8, 0, pwStr, -1, NULL, 0, NULL, NULL);  
18.     if (len <= 0)  
19.     {  
20.         return NULL;  
21.     }  
22.     char *pStr = new char[len];  
23.     WideCharToMultiByte(CP_UTF8, 0, pwStr, -1, pStr, len, NULL, NULL);  
24.     return pStr;  
25. }  
26.   
27. const wchar_t* Utf8ToWchar(const char *pStr)  
28. {  
29.     if (pStr == NULL)  
30.     {  
31.         return NULL;  
32.     }  
33.   
34.     int len = MultiByteToWideChar(CP_UTF8, 0, pStr, -1, NULL, 0);  
35.     if (len <= 0)  
36.     {  
37.         return NULL;  
38.     }  
39.     wchar_t *pwStr = new wchar_t[len];  
40.     MultiByteToWideChar(CP_UTF8, 0, pStr, -1, pwStr, len);  
41.     return pwStr;  
42. }  
43.   
44. SQLite::SQLite(void):  
45. m_db(NULL)  
46. {  
47. }  
48.   
49. SQLite::~SQLite(void)  
50. {  
51.     Close();  
52. }  
53.   
54. BOOL SQLite::Open(LPCTSTR lpDbFlie)  
55. {  
56.     if(lpDbFlie == NULL)  
57.     {  
58.         return FALSE;  
59.     }  
60. #ifdef  UNICODE    
61.     if(sqlite3_open16(lpDbFlie,&m_db) != SQLITE_OK)  
62. #else   
63.     if(sqlite3_open(lpDbFlie,&m_db) != SQLITE_OK)  
64. #endif   
65.     {  
66.         return FALSE;  
67.     }  
68.     return TRUE;  
69. }  
70.   
71. void SQLite::Close()  
72. {  
73.     if(m_db)  
74.     {  
75.         sqlite3_close(m_db);  
76.         m_db = NULL;  
77.     }  
78. }  
79.   
80. BOOL SQLite::ExcuteNonQuery(LPCTSTR lpSql)  
81. {  
82.     if(lpSql == NULL)  
83.     {  
84.         return FALSE;  
85.     }  
86.     sqlite3_stmt* stmt;    
87. #ifdef  UNICODE    
88.     if(sqlite3_prepare16_v2(m_db, lpSql, -1, &stmt, NULL) != SQLITE_OK)  
89. #else   
90.     if(sqlite3_prepare_v2(m_db, lpSql, -1, &stmt, NULL) != SQLITE_OK)  
91. #endif   
92.     {   
93.         return FALSE;    
94.     }    
95.     sqlite3_step(stmt);  
96.       
97.     return (sqlite3_finalize(stmt) == SQLITE_OK) ? TRUE : FALSE ;  
98. }  
99.   
100. BOOL SQLite::ExcuteNonQuery(SQLiteCommand* pCmd)  
101. {  
102.     if(pCmd == NULL)  
103.     {  
104.         return FALSE;  
105.     }  
106.     return pCmd->Excute();  
107. }  
108.   
109. // 查询(回调方式)   
110. BOOL SQLite::ExcuteQuery(LPCTSTR lpSql,QueryCallback pCallBack)  
111. {  
112.     if(lpSql == NULL || pCallBack == NULL)  
113.     {  
114.         return FALSE;  
115.     }  
116.     char *errmsg = NULL;  
117. #ifdef  UNICODE    
118.     const char *szSql = WcharToUtf8(lpSql);  
119.     if(sqlite3_exec(m_db, szSql, pCallBack, NULL, &errmsg) != SQLITE_OK)  
120.     {  
121.         delete[] szSql;  
122.         return FALSE;  
123.     }   
124.     delete[] szSql;  
125. #else   
126.     if(sqlite3_exec(m_db, lpSql, pCallBack, NULL, &errmsg) != SQLITE_OK)  
127.     {  
128.         return FALSE;  
129.     }   
130. #endif   
131.     return TRUE;  
132. }  
133.   
134. // 查询   
135. SQLiteDataReader SQLite::ExcuteQuery(LPCTSTR lpSql)  
136. {  
137.     if(lpSql == NULL)  
138.     {  
139.         return FALSE;  
140.     }  
141.     sqlite3_stmt* stmt;   
142. #ifdef  UNICODE    
143.     if(sqlite3_prepare16_v2(m_db, lpSql, -1, &stmt, NULL) != SQLITE_OK)  
144. #else   
145.     if(sqlite3_prepare_v2(m_db, lpSql, -1, &stmt, NULL) != SQLITE_OK)  
146. #endif   
147.     {   
148.         return FALSE;    
149.     }    
150.     return SQLiteDataReader(stmt);  
151. }  
152.   
153. // 开始事务   
154. BOOL SQLite::BeginTransaction()  
155. {  
156.     char * errmsg = NULL;  
157.     if(sqlite3_exec(m_db,"BEGIN TRANSACTION;",NULL,NULL,&errmsg) != SQLITE_OK)  
158.     {  
159.         return FALSE;  
160.     }   
161.     return TRUE;  
162. }  
163.   
164. // 提交事务   
165. BOOL SQLite::CommitTransaction()  
166. {  
167.     char * errmsg = NULL;  
168.     if(sqlite3_exec(m_db,"COMMIT TRANSACTION;;",NULL,NULL,&errmsg) != SQLITE_OK)  
169.     {  
170.         return FALSE;  
171.     }   
172.     return TRUE;  
173. }  
174.   
175. // 回滚事务   
176. BOOL SQLite::RollbackTransaction()  
177. {  
178.     char * errmsg = NULL;  
179.     if(sqlite3_exec(m_db,"ROLLBACK  TRANSACTION;",NULL,NULL,&errmsg) != SQLITE_OK)  
180.     {  
181.         return FALSE;  
182.     }   
183.     return TRUE;  
184. }  
185.   
186. // 获取上一条错误信息   
187. LPCTSTR SQLite::GetLastErrorMsg()  
188. {  
189. #ifdef UNICODE    
190.     return (LPCTSTR)sqlite3_errmsg16(m_db);  
191. #else   
192.     return sqlite3_errmsg(m_db);  
193. #endif   
194. }  
195.   
196.   
197.   
198. SQLiteDataReader::SQLiteDataReader(sqlite3_stmt *pStmt):  
199. m_pStmt(pStmt)  
200. {  
201.   
202. }  
203.   
204. SQLiteDataReader::~SQLiteDataReader()  
205. {  
206.     Close();  
207. }  
208.   
209. // 读取一行数据   
210. BOOL SQLiteDataReader::Read()  
211. {  
212.     if(m_pStmt == NULL)  
213.     {  
214.         return FALSE;  
215.     }  
216.     if(sqlite3_step(m_pStmt) != SQLITE_ROW)  
217.     {  
218.         return FALSE;  
219.     }  
220.     return TRUE;  
221. }  
222.   
223. // 关闭Reader，读取结束后调用   
224. void SQLiteDataReader::Close()  
225. {  
226.     if(m_pStmt)  
227.     {  
228.         sqlite3_finalize(m_pStmt);  
229.         m_pStmt = NULL;  
230.     }  
231. }  
232.   
233. // 总的列数   
234. int SQLiteDataReader::ColumnCount(void)  
235. {  
236.     return sqlite3_column_count(m_pStmt);  
237. }  
238.   
239. // 获取某列的名称    
240. LPCTSTR SQLiteDataReader::GetName(int nCol)  
241. {  
242. #ifdef  UNICODE    
243.     return (LPCTSTR)sqlite3_column_name16(m_pStmt, nCol);  
244. #else   
245.     return (LPCTSTR)sqlite3_column_name(m_pStmt, nCol);  
246. #endif   
247. }  
248.   
249. // 获取某列的数据类型   
250. SQLITE_DATATYPE SQLiteDataReader::GetDataType(int nCol)  
251. {  
252.     return (SQLITE_DATATYPE)sqlite3_column_type(m_pStmt, nCol);  
253. }  
254.   
255. // 获取某列的值(字符串)   
256. LPCTSTR SQLiteDataReader::GetStringValue(int nCol)  
257. {  
258. #ifdef  UNICODE    
259.     return (LPCTSTR)sqlite3_column_text16(m_pStmt, nCol);  
260. #else   
261.     return (LPCTSTR)sqlite3_column_text(m_pStmt, nCol);  
262. #endif   
263. }  
264.   
265. // 获取某列的值(整形)   
266. int SQLiteDataReader::GetIntValue(int nCol)  
267. {  
268.     return sqlite3_column_int(m_pStmt, nCol);  
269. }  
270.   
271. // 获取某列的值(长整形)   
272. long SQLiteDataReader::GetInt64Value(int nCol)  
273. {  
274.     return (long)sqlite3_column_int64(m_pStmt, nCol);  
275. }  
276.   
277. // 获取某列的值(浮点形)   
278. double SQLiteDataReader::GetFloatValue(int nCol)  
279. {  
280.     return sqlite3_column_double(m_pStmt, nCol);  
281. }  
282.   
283. // 获取某列的值(二进制数据)   
284. const BYTE* SQLiteDataReader::GetBlobValue(int nCol, int &nLen)  
285. {  
286.     nLen = sqlite3_column_bytes(m_pStmt, nCol);  
287.     return (const BYTE*)sqlite3_column_blob(m_pStmt, nCol);  
288. }  
289.   
290. SQLiteCommand::SQLiteCommand(SQLite* pSqlite):  
291. m_pSqlite(pSqlite),  
292. m_pStmt(NULL)  
293. {  
294. }  
295.   
296. SQLiteCommand::SQLiteCommand(SQLite* pSqlite,LPCTSTR lpSql):  
297. m_pSqlite(pSqlite),  
298. m_pStmt(NULL)  
299. {  
300.     SetCommandText(lpSql);  
301. }  
302.   
303. SQLiteCommand::~SQLiteCommand()  
304. {  
305.   
306. }  
307.   
308. BOOL SQLiteCommand::SetCommandText(LPCTSTR lpSql)  
309. {  
310. #ifdef  UNICODE    
311.     if(sqlite3_prepare16_v2(m_pSqlite->m_db, lpSql, -1, &m_pStmt, NULL) != SQLITE_OK)  
312. #else   
313.     if(sqlite3_prepare_v2(m_pSqlite->m_db, lpSql, -1, &m_pStmt, NULL) != SQLITE_OK)  
314. #endif   
315.     {   
316.         return FALSE;    
317.     }    
318.     return TRUE;  
319. }  
320.   
321. BOOL SQLiteCommand::BindParam(int index, LPCTSTR szValue)  
322. {  
323. #ifdef  UNICODE    
324.     if(sqlite3_bind_text16(m_pStmt, index, szValue, -1, SQLITE_TRANSIENT) != SQLITE_OK)  
325. #else   
326.     if(sqlite3_bind_text(m_pStmt, index, szValue,-1, SQLITE_TRANSIENT) != SQLITE_OK)  
327. #endif   
328.     {  
329.         return FALSE;  
330.     }  
331.     return TRUE;  
332. }  
333.   
334. BOOL SQLiteCommand::BindParam(int index, const int nValue)  
335. {  
336.     if(sqlite3_bind_int(m_pStmt, index, nValue) != SQLITE_OK)  
337.     {  
338.         return FALSE;  
339.     }  
340.     return TRUE;  
341. }  
342.   
343. BOOL SQLiteCommand::BindParam(int index, const double dValue)  
344. {  
345.     if(sqlite3_bind_double(m_pStmt, index, dValue) != SQLITE_OK)  
346.     {  
347.         return FALSE;  
348.     }  
349.     return TRUE;  
350. }  
351.   
352. BOOL SQLiteCommand::BindParam(int index, const unsigned char* blobBuf, int nLen)  
353. {  
354.     if(sqlite3_bind_blob(m_pStmt, index, blobBuf,nLen,NULL) != SQLITE_OK)  
355.     {  
356.         return FALSE;  
357.     }  
358.     return TRUE;  
359. }  
360.   
361. BOOL SQLiteCommand::Excute()  
362. {  
363.     sqlite3_step(m_pStmt);  
364.   
365.     return (sqlite3_reset(m_pStmt) == SQLITE_OK) ? TRUE : FALSE ;  
366. }  
367.   
368. void SQLiteCommand::Clear()  
369. {  
370.     if(m_pStmt)  
371.     {  
372.         sqlite3_finalize(m_pStmt);  
373.     }  
374. }  

/********************************************************************
filename: 	SQLite.cpp
created:	2012-11-05
author:		firehood

purpose:	SQLite数据库操作类
*********************************************************************/
#include "SQLite.h"

const char* WcharToUtf8(const wchar_t *pwStr)
{
	if (pwStr == NULL)
	{
		return NULL;
	}

	int len = WideCharToMultiByte(CP_UTF8, 0, pwStr, -1, NULL, 0, NULL, NULL);
	if (len <= 0)
	{
		return NULL;
	}
	char *pStr = new char[len];
	WideCharToMultiByte(CP_UTF8, 0, pwStr, -1, pStr, len, NULL, NULL);
	return pStr;
}

const wchar_t* Utf8ToWchar(const char *pStr)
{
	if (pStr == NULL)
	{
		return NULL;
	}

	int len = MultiByteToWideChar(CP_UTF8, 0, pStr, -1, NULL, 0);
	if (len <= 0)
	{
		return NULL;
	}
	wchar_t *pwStr = new wchar_t[len];
	MultiByteToWideChar(CP_UTF8, 0, pStr, -1, pwStr, len);
	return pwStr;
}

SQLite::SQLite(void):
m_db(NULL)
{
}

SQLite::~SQLite(void)
{
	Close();
}

BOOL SQLite::Open(LPCTSTR lpDbFlie)
{
	if(lpDbFlie == NULL)
	{
		return FALSE;
	}
#ifdef  UNICODE 
	if(sqlite3_open16(lpDbFlie,&m_db) != SQLITE_OK)
#else
    if(sqlite3_open(lpDbFlie,&m_db) != SQLITE_OK)
#endif
	{
		return FALSE;
	}
	return TRUE;
}

void SQLite::Close()
{
	if(m_db)
	{
		sqlite3_close(m_db);
		m_db = NULL;
	}
}

BOOL SQLite::ExcuteNonQuery(LPCTSTR lpSql)
{
	if(lpSql == NULL)
	{
		return FALSE;
	}
    sqlite3_stmt* stmt;  
#ifdef  UNICODE 
	if(sqlite3_prepare16_v2(m_db, lpSql, -1, &stmt, NULL) != SQLITE_OK)
#else
    if(sqlite3_prepare_v2(m_db, lpSql, -1, &stmt, NULL) != SQLITE_OK)
#endif
	{ 
		return FALSE;  
	}  
	sqlite3_step(stmt);
	
	return (sqlite3_finalize(stmt) == SQLITE_OK) ? TRUE : FALSE ;
}

BOOL SQLite::ExcuteNonQuery(SQLiteCommand* pCmd)
{
	if(pCmd == NULL)
	{
		return FALSE;
	}
	return pCmd->Excute();
}

// 查询(回调方式)
BOOL SQLite::ExcuteQuery(LPCTSTR lpSql,QueryCallback pCallBack)
{
	if(lpSql == NULL || pCallBack == NULL)
	{
		return FALSE;
	}
	char *errmsg = NULL;
#ifdef  UNICODE 
	const char *szSql = WcharToUtf8(lpSql);
	if(sqlite3_exec(m_db, szSql, pCallBack, NULL, &errmsg) != SQLITE_OK)
	{
		delete[] szSql;
		return FALSE;
	} 
    delete[] szSql;
#else
	if(sqlite3_exec(m_db, lpSql, pCallBack, NULL, &errmsg) != SQLITE_OK)
	{
		return FALSE;
	} 
#endif
	return TRUE;
}

// 查询
SQLiteDataReader SQLite::ExcuteQuery(LPCTSTR lpSql)
{
	if(lpSql == NULL)
	{
		return FALSE;
	}
    sqlite3_stmt* stmt; 
#ifdef  UNICODE 
	if(sqlite3_prepare16_v2(m_db, lpSql, -1, &stmt, NULL) != SQLITE_OK)
#else
	if(sqlite3_prepare_v2(m_db, lpSql, -1, &stmt, NULL) != SQLITE_OK)
#endif
	{ 
		return FALSE;  
	}  
	return SQLiteDataReader(stmt);
}

// 开始事务
BOOL SQLite::BeginTransaction()
{
	char * errmsg = NULL;
    if(sqlite3_exec(m_db,"BEGIN TRANSACTION;",NULL,NULL,&errmsg) != SQLITE_OK)
	{
		return FALSE;
	} 
	return TRUE;
}

// 提交事务
BOOL SQLite::CommitTransaction()
{
	char * errmsg = NULL;
	if(sqlite3_exec(m_db,"COMMIT TRANSACTION;;",NULL,NULL,&errmsg) != SQLITE_OK)
	{
		return FALSE;
	} 
	return TRUE;
}

// 回滚事务
BOOL SQLite::RollbackTransaction()
{
	char * errmsg = NULL;
	if(sqlite3_exec(m_db,"ROLLBACK  TRANSACTION;",NULL,NULL,&errmsg) != SQLITE_OK)
	{
		return FALSE;
	} 
	return TRUE;
}

// 获取上一条错误信息
LPCTSTR SQLite::GetLastErrorMsg()
{
#ifdef UNICODE 
	return (LPCTSTR)sqlite3_errmsg16(m_db);
#else
    return sqlite3_errmsg(m_db);
#endif
}



SQLiteDataReader::SQLiteDataReader(sqlite3_stmt *pStmt):
m_pStmt(pStmt)
{

}

SQLiteDataReader::~SQLiteDataReader()
{
	Close();
}

// 读取一行数据
BOOL SQLiteDataReader::Read()
{
	if(m_pStmt == NULL)
	{
		return FALSE;
	}
	if(sqlite3_step(m_pStmt) != SQLITE_ROW)
	{
		return FALSE;
	}
	return TRUE;
}

// 关闭Reader，读取结束后调用
void SQLiteDataReader::Close()
{
	if(m_pStmt)
	{
		sqlite3_finalize(m_pStmt);
		m_pStmt = NULL;
	}
}

// 总的列数
int SQLiteDataReader::ColumnCount(void)
{
	return sqlite3_column_count(m_pStmt);
}

// 获取某列的名称 
LPCTSTR SQLiteDataReader::GetName(int nCol)
{
#ifdef  UNICODE 
	return (LPCTSTR)sqlite3_column_name16(m_pStmt, nCol);
#else
	return (LPCTSTR)sqlite3_column_name(m_pStmt, nCol);
#endif
}

// 获取某列的数据类型
SQLITE_DATATYPE SQLiteDataReader::GetDataType(int nCol)
{
	return (SQLITE_DATATYPE)sqlite3_column_type(m_pStmt, nCol);
}

// 获取某列的值(字符串)
LPCTSTR SQLiteDataReader::GetStringValue(int nCol)
{
#ifdef  UNICODE 
	return (LPCTSTR)sqlite3_column_text16(m_pStmt, nCol);
#else
    return (LPCTSTR)sqlite3_column_text(m_pStmt, nCol);
#endif
}

// 获取某列的值(整形)
int SQLiteDataReader::GetIntValue(int nCol)
{
	return sqlite3_column_int(m_pStmt, nCol);
}

// 获取某列的值(长整形)
long SQLiteDataReader::GetInt64Value(int nCol)
{
	return (long)sqlite3_column_int64(m_pStmt, nCol);
}

// 获取某列的值(浮点形)
double SQLiteDataReader::GetFloatValue(int nCol)
{
	return sqlite3_column_double(m_pStmt, nCol);
}

// 获取某列的值(二进制数据)
const BYTE* SQLiteDataReader::GetBlobValue(int nCol, int &nLen)
{
	nLen = sqlite3_column_bytes(m_pStmt, nCol);
	return (const BYTE*)sqlite3_column_blob(m_pStmt, nCol);
}

SQLiteCommand::SQLiteCommand(SQLite* pSqlite):
m_pSqlite(pSqlite),
m_pStmt(NULL)
{
}

SQLiteCommand::SQLiteCommand(SQLite* pSqlite,LPCTSTR lpSql):
m_pSqlite(pSqlite),
m_pStmt(NULL)
{
	SetCommandText(lpSql);
}

SQLiteCommand::~SQLiteCommand()
{

}

BOOL SQLiteCommand::SetCommandText(LPCTSTR lpSql)
{
#ifdef  UNICODE 
	if(sqlite3_prepare16_v2(m_pSqlite->m_db, lpSql, -1, &m_pStmt, NULL) != SQLITE_OK)
#else
	if(sqlite3_prepare_v2(m_pSqlite->m_db, lpSql, -1, &m_pStmt, NULL) != SQLITE_OK)
#endif
	{ 
		return FALSE;  
	}  
	return TRUE;
}

BOOL SQLiteCommand::BindParam(int index, LPCTSTR szValue)
{
#ifdef  UNICODE 
	if(sqlite3_bind_text16(m_pStmt, index, szValue, -1, SQLITE_TRANSIENT) != SQLITE_OK)
#else
    if(sqlite3_bind_text(m_pStmt, index, szValue,-1, SQLITE_TRANSIENT) != SQLITE_OK)
#endif
	{
		return FALSE;
	}
	return TRUE;
}

BOOL SQLiteCommand::BindParam(int index, const int nValue)
{
	if(sqlite3_bind_int(m_pStmt, index, nValue) != SQLITE_OK)
	{
		return FALSE;
	}
	return TRUE;
}

BOOL SQLiteCommand::BindParam(int index, const double dValue)
{
	if(sqlite3_bind_double(m_pStmt, index, dValue) != SQLITE_OK)
	{
		return FALSE;
	}
	return TRUE;
}

BOOL SQLiteCommand::BindParam(int index, const unsigned char* blobBuf, int nLen)
{
	if(sqlite3_bind_blob(m_pStmt, index, blobBuf,nLen,NULL) != SQLITE_OK)
	{
		return FALSE;
	}
	return TRUE;
}

BOOL SQLiteCommand::Excute()
{
	sqlite3_step(m_pStmt);

	return (sqlite3_reset(m_pStmt) == SQLITE_OK) ? TRUE : FALSE ;
}

void SQLiteCommand::Clear()
{
	if(m_pStmt)
	{
		sqlite3_finalize(m_pStmt);
	}
}

使用方法

通过SQLite类操作数据库的基本代码如下：

[cpp] view plain copy print ?

1. void SqliteOperate()  
2. {  
3.     TCHAR *szDbPath = _T("Book.db");  
4.   
5.     ::DeleteFile(szDbPath);  
6.   
7.     SQLite sqlite;  
8.   
9.     // 打开或创建数据库   
10.     //******************************************************  
11.     if(!sqlite.Open(szDbPath))  
12.     {  
13.         _tprintf(_T("%s\n"),sqlite.GetLastErrorMsg());  
14.         return;  
15.     }  
16.     //******************************************************  
17.   
18.     // 创建数据库表   
19.     //******************************************************  
20.     TCHAR sql[512] = {0};  
21.     _stprintf(sql,_T("%s"),  
22.         _T("CREATE TABLE [Book] (")  
23.         _T("[id] INTEGER NOT NULL PRIMARY KEY, ")  
24.         _T("[name] NVARCHAR(20), ")  
25.         _T("[author] NVARCHAR(20), ")  
26.         _T("[catagory_id] INTEGER REFERENCES [Category]([id]), ")  
27.         _T("[abstruct] NVARCHAR(100) ,")  
28.         _T("[path] NVARCHAR(50), ")  
29.         _T("[image] BLOB);")  
30.         _T("CREATE INDEX [Book_id] ON [Book] ([id]);")  
31.         );  
32.     if(!sqlite.ExcuteNonQuery(sql))  
33.     {  
34.         printf("Create database table failed...\n");  
35.     }  
36.     //******************************************************  
37.   
38.     // 插入数据【普通方式】   
39.     DWORD dwBeginTick = GetTickCount();  
40.     //******************************************************  
41.     // 当一次性插入多条记录时候，采用事务的方式，提高效率  
42.     sqlite.BeginTransaction();  
43.     // 批量插入数据   
44.     for(int i=0;i<1000;i++)  
45.     {  
46.         memset(sql,0,sizeof(sql));  
47.         _stprintf(sql,_T("insert into Book(name,author,catagory_id) values('红高粱%d','莫言',1)"),i);  
48.         if(!sqlite.ExcuteNonQuery(sql))  
49.         {  
50.             _tprintf(_T("%s\n"),sqlite.GetLastErrorMsg());  
51.             break;  
52.         }  
53.     }  
54.     // 提交事务   
55.     sqlite.CommitTransaction();  
56.     printf("Insert Data Take %dMS...\n",GetTickCount()-dwBeginTick);  
57.     //******************************************************  
58.   
59.   
60.     // 插入数据【通过参数绑定的方式，提交批量数据时，比上面的普通模式效率更高（提高约45%），同时可支持插入二进制数据】  
61.     dwBeginTick = GetTickCount();  
62.     //******************************************************  
63.     // 当一次性插入多条记录时候，采用事务的方式，提高效率  
64.     sqlite.BeginTransaction();  
65.     memset(sql,0,sizeof(sql));  
66.     _stprintf(sql,_T("insert into Book(name,author,catagory_id,image) values(?,'韩寒',?,?)"));  
67.     SQLiteCommand cmd(&sqlite,sql);  
68.     // 批量插入数据   
69.     for(int i=0;i<1000;i++)  
70.     {  
71.         TCHAR strValue[16] = {0};  
72.         _stprintf(strValue,_T("他的国%d"),i);  
73.         // 绑定第一个参数（name字段值）   
74.         cmd.BindParam(1,strValue);  
75.         // 绑定第二个参数（catagory_id字段值）  
76.         cmd.BindParam(2,20);  
77.         BYTE imageBuf[] = {0xff,0xff,0xff,0xff};  
78.         // 绑定第三个参数（image字段值,二进制数据）   
79.         cmd.BindParam(3,imageBuf,sizeof(imageBuf));  
80.         if(!sqlite.ExcuteNonQuery(&cmd))  
81.         {  
82.             _tprintf(_T("%s\n"),sqlite.GetLastErrorMsg());  
83.             break;  
84.         }  
85.     }  
86.     // 清空cmd   
87.     cmd.Clear();  
88.     // 提交事务   
89.     sqlite.CommitTransaction();  
90.     printf("Insert Data Take %dMS...\n",GetTickCount()-dwBeginTick);  
91.     //******************************************************  
92.   
93.     // 查询   
94.     dwBeginTick = GetTickCount();  
95.     //******************************************************  
96.     memset(sql,0,sizeof(sql));  
97.     _stprintf(sql,_T("%s"),_T("select * from Book where name = '他的国345'"));  
98.   
99.     SQLiteDataReader Reader = sqlite.ExcuteQuery(sql);  
100.   
101.     int index = 0;  
102.     int len = 0;  
103.     while(Reader.Read())  
104.     {  
105.         _tprintf( _T("***************【第%d条记录】***************\n"),++index);  
106.         _tprintf( _T("字段名:%s 字段值:%d\n"),Reader.GetName(0),Reader.GetIntValue(0));  
107.         _tprintf( _T("字段名:%s 字段值:%s\n"),Reader.GetName(1),Reader.GetStringValue(1));  
108.         _tprintf( _T("字段名:%s 字段值:%s\n"),Reader.GetName(2),Reader.GetStringValue(2));  
109.         _tprintf( _T("字段名:%s 字段值:%d\n"),Reader.GetName(3),Reader.GetIntValue(3));  
110.         _tprintf( _T("字段名:%s 字段值:%s\n"),Reader.GetName(4),Reader.GetStringValue(4));  
111.         // 读取图片二进制文件   
112.         const BYTE *ImageBuf = Reader.GetBlobValue(6,len);  
113.         _tprintf( _T("*******************************************\n"));  
114.     }  
115.     Reader.Close();  
116.     printf("Query Take %dMS...\n",GetTickCount()-dwBeginTick);  
117.     //******************************************************  
118.   
119.     // 关闭数据库   
120.     sqlite.Close();  
121. }  

void SqliteOperate()
{
	TCHAR *szDbPath = _T("Book.db");

	::DeleteFile(szDbPath);

	SQLite sqlite;

	// 打开或创建数据库
	//******************************************************
	if(!sqlite.Open(szDbPath))
	{
		_tprintf(_T("%s\n"),sqlite.GetLastErrorMsg());
		return;
	}
    //******************************************************

	// 创建数据库表
    //******************************************************
	TCHAR sql[512] = {0};
	_stprintf(sql,_T("%s"),
		_T("CREATE TABLE [Book] (")
		_T("[id] INTEGER NOT NULL PRIMARY KEY, ")
		_T("[name] NVARCHAR(20), ")
		_T("[author] NVARCHAR(20), ")
		_T("[catagory_id] INTEGER REFERENCES [Category]([id]), ")
		_T("[abstruct] NVARCHAR(100) ,")
		_T("[path] NVARCHAR(50), ")
		_T("[image] BLOB);")
		_T("CREATE INDEX [Book_id] ON [Book] ([id]);")
		);
	if(!sqlite.ExcuteNonQuery(sql))
	{
		printf("Create database table failed...\n");
	}
	//******************************************************

	// 插入数据【普通方式】
	DWORD dwBeginTick = GetTickCount();
	//******************************************************
	// 当一次性插入多条记录时候，采用事务的方式，提高效率
	sqlite.BeginTransaction();
	// 批量插入数据
	for(int i=0;i<1000;i++)
	{
		memset(sql,0,sizeof(sql));
		_stprintf(sql,_T("insert into Book(name,author,catagory_id) values('红高粱%d','莫言',1)"),i);
		if(!sqlite.ExcuteNonQuery(sql))
		{
			_tprintf(_T("%s\n"),sqlite.GetLastErrorMsg());
			break;
		}
	}
	// 提交事务
	sqlite.CommitTransaction();
	printf("Insert Data Take %dMS...\n",GetTickCount()-dwBeginTick);
    //******************************************************


	// 插入数据【通过参数绑定的方式，提交批量数据时，比上面的普通模式效率更高（提高约45%），同时可支持插入二进制数据】
	dwBeginTick = GetTickCount();
    //******************************************************
	// 当一次性插入多条记录时候，采用事务的方式，提高效率
	sqlite.BeginTransaction();
	memset(sql,0,sizeof(sql));
	_stprintf(sql,_T("insert into Book(name,author,catagory_id,image) values(?,'韩寒',?,?)"));
	SQLiteCommand cmd(&sqlite,sql);
	// 批量插入数据
	for(int i=0;i<1000;i++)
	{
		TCHAR strValue[16] = {0};
		_stprintf(strValue,_T("他的国%d"),i);
		// 绑定第一个参数（name字段值）
		cmd.BindParam(1,strValue);
		// 绑定第二个参数（catagory_id字段值）
		cmd.BindParam(2,20);
		BYTE imageBuf[] = {0xff,0xff,0xff,0xff};
		// 绑定第三个参数（image字段值,二进制数据）
		cmd.BindParam(3,imageBuf,sizeof(imageBuf));
		if(!sqlite.ExcuteNonQuery(&cmd))
		{
			_tprintf(_T("%s\n"),sqlite.GetLastErrorMsg());
			break;
		}
	}
	// 清空cmd
	cmd.Clear();
	// 提交事务
	sqlite.CommitTransaction();
	printf("Insert Data Take %dMS...\n",GetTickCount()-dwBeginTick);
    //******************************************************

	// 查询
	dwBeginTick = GetTickCount();
	//******************************************************
	memset(sql,0,sizeof(sql));
	_stprintf(sql,_T("%s"),_T("select * from Book where name = '他的国345'"));

	SQLiteDataReader Reader = sqlite.ExcuteQuery(sql);

	int index = 0;
	int len = 0;
	while(Reader.Read())
	{
		_tprintf( _T("***************【第%d条记录】***************\n"),++index);
		_tprintf( _T("字段名:%s 字段值:%d\n"),Reader.GetName(0),Reader.GetIntValue(0));
		_tprintf( _T("字段名:%s 字段值:%s\n"),Reader.GetName(1),Reader.GetStringValue(1));
		_tprintf( _T("字段名:%s 字段值:%s\n"),Reader.GetName(2),Reader.GetStringValue(2));
		_tprintf( _T("字段名:%s 字段值:%d\n"),Reader.GetName(3),Reader.GetIntValue(3));
		_tprintf( _T("字段名:%s 字段值:%s\n"),Reader.GetName(4),Reader.GetStringValue(4));
		// 读取图片二进制文件
		const BYTE *ImageBuf = Reader.GetBlobValue(6,len);
		_tprintf( _T("*******************************************\n"));
	}
	Reader.Close();
	printf("Query Take %dMS...\n",GetTickCount()-dwBeginTick);
    //******************************************************

	// 关闭数据库
	sqlite.Close();
}

运行结果

Insert Data Take 645MS...
Insert Data Take 229MS...
***************【第1条记录】***************
字段名:id 字段值:1346
字段名:name 字段值:他的国345
字段名:author 字段值:韩寒
字段名:catagory_id 字段值:20
字段名:abstruct 字段值:(null)
*******************************************
Query Take 63MS...