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
6. purpose:SQLite数据库操作类
7. *********************************************************************/
8. #pragmaonce
9. #include<windows.h>
10. #include"..\SQLite\sqlite3.h"
11. #pragmacomment(lib,"SQLite.lib")
13. typedefBOOL(WINAPI*QueryCallback)(void*para,intn_column,char**column_value,char**column_name);
15. typedefenum_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;
24. classSQLite;
26. classSQLiteDataReader
27. {
28. public:
29. SQLiteDataReader(sqlite3_stmt*pStmt);
30. ~SQLiteDataReader();
31. public:
32. //读取一行数据
33. BOOLRead();
34. //关闭Reader，读取结束后调用
35. voidClose();
36. //总的列数
37. intColumnCount(void);
38. //获取某列的名称
39. LPCTSTRGetName(intnCol);
40. //获取某列的数据类型
41. SQLITE_DATATYPEGetDataType(intnCol);
42. //获取某列的值(字符串)
43. LPCTSTRGetStringValue(intnCol);
44. //获取某列的值(整形)
45. intGetIntValue(intnCol);
46. //获取某列的值(长整形)
47. longGetInt64Value(intnCol);
48. //获取某列的值(浮点形)
49. doubleGetFloatValue(intnCol);
50. //获取某列的值(二进制数据)
51. constBYTE*GetBlobValue(intnCol,int&nLen);
52. private:
53. sqlite3_stmt*m_pStmt;
54. };
56. classSQLiteCommand
57. {
58. public:
59. SQLiteCommand(SQLite*pSqlite);
60. SQLiteCommand(SQLite*pSqlite,LPCTSTRlpSql);
61. ~SQLiteCommand();
62. public:
63. //设置命令
64. BOOLSetCommandText(LPCTSTRlpSql);
65. //绑定参数（index为要绑定参数的序号，从1开始）
66. BOOLBindParam(intindex,LPCTSTRszValue);
67. BOOLBindParam(intindex,constintnValue);
68. BOOLBindParam(intindex,constdoubledValue);
69. BOOLBindParam(intindex,constunsignedchar*blobValue,intnLen);
70. //执行命令
71. BOOLExcute();
72. //清除命令（命令不再使用时需调用该接口清除）
73. voidClear();
74. private:
75. SQLite*m_pSqlite;
76. sqlite3_stmt*m_pStmt;
77. };
79. classSQLite
80. {
81. public:
82. SQLite(void);
83. ~SQLite(void);
84. public:
85. //打开数据库
86. BOOLOpen(LPCTSTRlpDbFlie);
87. //关闭数据库
88. voidClose();
90. //执行非查询操作（更新或删除）
91. BOOLExcuteNonQuery(LPCTSTRlpSql);
92. BOOLExcuteNonQuery(SQLiteCommand*pCmd);
94. //查询
95. SQLiteDataReaderExcuteQuery(LPCTSTRlpSql);
96. //查询（回调方式）
97. BOOLExcuteQuery(LPCTSTRlpSql,QueryCallbackpCallBack);
99. //开始事务
100. BOOLBeginTransaction();
101. //提交事务
102. BOOLCommitTransaction();
103. //回滚事务
104. BOOLRollbackTransaction();
106. //获取上一条错误信息
107. LPCTSTRGetLastErrorMsg();
108. public:
109. friendclassSQLiteCommand;
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
6. purpose:SQLite数据库操作类
7. *********************************************************************/
8. #include"SQLite.h"
10. constchar*WcharToUtf8(constwchar_t*pwStr)
11. {
12. if(pwStr==NULL)
13. {
14. returnNULL;
15. }
17. intlen=WideCharToMultiByte(CP_UTF8,0,pwStr,-1,NULL,0,NULL,NULL);
18. if(len<=0)
19. {
20. returnNULL;
21. }
22. char*pStr=newchar[len];
23. WideCharToMultiByte(CP_UTF8,0,pwStr,-1,pStr,len,NULL,NULL);
24. returnpStr;
25. }
27. constwchar_t*Utf8ToWchar(constchar*pStr)
28. {
29. if(pStr==NULL)
30. {
31. returnNULL;
32. }
34. intlen=MultiByteToWideChar(CP_UTF8,0,pStr,-1,NULL,0);
35. if(len<=0)
36. {
37. returnNULL;
38. }
39. wchar_t*pwStr=newwchar_t[len];
40. MultiByteToWideChar(CP_UTF8,0,pStr,-1,pwStr,len);
41. returnpwStr;
42. }
44. SQLite::SQLite(void):
45. m_db(NULL)
46. {
47. }
49. SQLite::~SQLite(void)
50. {
51. Close();
52. }
54. BOOLSQLite::Open(LPCTSTRlpDbFlie)
55. {
56. if(lpDbFlie==NULL)
57. {
58. returnFALSE;
59. }
60. #ifdefUNICODE
61. if(sqlite3_open16(lpDbFlie,&m_db)!=SQLITE_OK)
62. #else
63. if(sqlite3_open(lpDbFlie,&m_db)!=SQLITE_OK)
64. #endif
65. {
66. returnFALSE;
67. }
68. returnTRUE;
69. }
71. voidSQLite::Close()
72. {
73. if(m_db)
74. {
75. sqlite3_close(m_db);
76. m_db=NULL;
77. }
78. }
80. BOOLSQLite::ExcuteNonQuery(LPCTSTRlpSql)
81. {
82. if(lpSql==NULL)
83. {
84. returnFALSE;
85. }
86. sqlite3_stmt*stmt;
87. #ifdefUNICODE
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. returnFALSE;
94. }
95. sqlite3_step(stmt);
97. return(sqlite3_finalize(stmt)==SQLITE_OK)?TRUE:FALSE;
98. }
100. BOOLSQLite::ExcuteNonQuery(SQLiteCommand*pCmd)
101. {
102. if(pCmd==NULL)
103. {
104. returnFALSE;
105. }
106. returnpCmd->Excute();
107. }
109. //查询(回调方式)
110. BOOLSQLite::ExcuteQuery(LPCTSTRlpSql,QueryCallbackpCallBack)
111. {
112. if(lpSql==NULL||pCallBack==NULL)
113. {
114. returnFALSE;
115. }
116. char*errmsg=NULL;
117. #ifdefUNICODE
118. constchar*szSql=WcharToUtf8(lpSql);
119. if(sqlite3_exec(m_db,szSql,pCallBack,NULL,&errmsg)!=SQLITE_OK)
120. {
121. delete[]szSql;
122. returnFALSE;
123. }
124. delete[]szSql;
125. #else
126. if(sqlite3_exec(m_db,lpSql,pCallBack,NULL,&errmsg)!=SQLITE_OK)
127. {
128. returnFALSE;
129. }
130. #endif
131. returnTRUE;
132. }
134. //查询
135. SQLiteDataReaderSQLite::ExcuteQuery(LPCTSTRlpSql)
136. {
137. if(lpSql==NULL)
138. {
139. returnFALSE;
140. }
141. sqlite3_stmt*stmt;
142. #ifdefUNICODE
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. returnFALSE;
149. }
150. returnSQLiteDataReader(stmt);
151. }
153. //开始事务
154. BOOLSQLite::BeginTransaction()
155. {
156. char*errmsg=NULL;
157. if(sqlite3_exec(m_db,"BEGINTRANSACTION;",NULL,NULL,&errmsg)!=SQLITE_OK)
158. {
159. returnFALSE;
160. }
161. returnTRUE;
162. }
164. //提交事务
165. BOOLSQLite::CommitTransaction()
166. {
167. char*errmsg=NULL;
168. if(sqlite3_exec(m_db,"COMMITTRANSACTION;;",NULL,NULL,&errmsg)!=SQLITE_OK)
169. {
170. returnFALSE;
171. }
172. returnTRUE;
173. }
175. //回滚事务
176. BOOLSQLite::RollbackTransaction()
177. {
178. char*errmsg=NULL;
179. if(sqlite3_exec(m_db,"ROLLBACKTRANSACTION;",NULL,NULL,&errmsg)!=SQLITE_OK)
180. {
181. returnFALSE;
182. }
183. returnTRUE;
184. }
186. //获取上一条错误信息
187. LPCTSTRSQLite::GetLastErrorMsg()
188. {
189. #ifdefUNICODE
190. return(LPCTSTR)sqlite3_errmsg16(m_db);
191. #else
192. returnsqlite3_errmsg(m_db);
193. #endif
194. }
198. SQLiteDataReader::SQLiteDataReader(sqlite3_stmt*pStmt):
199. m_pStmt(pStmt)
200. {
202. }
204. SQLiteDataReader::~SQLiteDataReader()
205. {
206. Close();
207. }
209. //读取一行数据
210. BOOLSQLiteDataReader::Read()
211. {
212. if(m_pStmt==NULL)
213. {
214. returnFALSE;
215. }
216. if(sqlite3_step(m_pStmt)!=SQLITE_ROW)
217. {
218. returnFALSE;
219. }
220. returnTRUE;
221. }
223. //关闭Reader，读取结束后调用
224. voidSQLiteDataReader::Close()
225. {
226. if(m_pStmt)
227. {
228. sqlite3_finalize(m_pStmt);
229. m_pStmt=NULL;
230. }
231. }
233. //总的列数
234. intSQLiteDataReader::ColumnCount(void)
235. {
236. returnsqlite3_column_count(m_pStmt);
237. }
239. //获取某列的名称
240. LPCTSTRSQLiteDataReader::GetName(intnCol)
241. {
242. #ifdefUNICODE
243. return(LPCTSTR)sqlite3_column_name16(m_pStmt,nCol);
244. #else
245. return(LPCTSTR)sqlite3_column_name(m_pStmt,nCol);
246. #endif
247. }
249. //获取某列的数据类型
250. SQLITE_DATATYPESQLiteDataReader::GetDataType(intnCol)
251. {
252. return(SQLITE_DATATYPE)sqlite3_column_type(m_pStmt,nCol);
253. }
255. //获取某列的值(字符串)
256. LPCTSTRSQLiteDataReader::GetStringValue(intnCol)
257. {
258. #ifdefUNICODE
259. return(LPCTSTR)sqlite3_column_text16(m_pStmt,nCol);
260. #else
261. return(LPCTSTR)sqlite3_column_text(m_pStmt,nCol);
262. #endif
263. }
265. //获取某列的值(整形)
266. intSQLiteDataReader::GetIntValue(intnCol)
267. {
268. returnsqlite3_column_int(m_pStmt,nCol);
269. }
271. //获取某列的值(长整形)
272. longSQLiteDataReader::GetInt64Value(intnCol)
273. {
274. return(long)sqlite3_column_int64(m_pStmt,nCol);
275. }
277. //获取某列的值(浮点形)
278. doubleSQLiteDataReader::GetFloatValue(intnCol)
279. {
280. returnsqlite3_column_double(m_pStmt,nCol);
281. }
283. //获取某列的值(二进制数据)
284. constBYTE*SQLiteDataReader::GetBlobValue(intnCol,int&nLen)
285. {
286. nLen=sqlite3_column_bytes(m_pStmt,nCol);
287. return(constBYTE*)sqlite3_column_blob(m_pStmt,nCol);
288. }
290. SQLiteCommand::SQLiteCommand(SQLite*pSqlite):
291. m_pSqlite(pSqlite),
292. m_pStmt(NULL)
293. {
294. }
296. SQLiteCommand::SQLiteCommand(SQLite*pSqlite,LPCTSTRlpSql):
297. m_pSqlite(pSqlite),
298. m_pStmt(NULL)
299. {
300. SetCommandText(lpSql);
301. }
303. SQLiteCommand::~SQLiteCommand()
304. {
306. }
308. BOOLSQLiteCommand::SetCommandText(LPCTSTRlpSql)
309. {
310. #ifdefUNICODE
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. returnFALSE;
317. }
318. returnTRUE;
319. }
321. BOOLSQLiteCommand::BindParam(intindex,LPCTSTRszValue)
322. {
323. #ifdefUNICODE
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. returnFALSE;
330. }
331. returnTRUE;
332. }
334. BOOLSQLiteCommand::BindParam(intindex,constintnValue)
335. {
336. if(sqlite3_bind_int(m_pStmt,index,nValue)!=SQLITE_OK)
337. {
338. returnFALSE;
339. }
340. returnTRUE;
341. }
343. BOOLSQLiteCommand::BindParam(intindex,constdoubledValue)
344. {
345. if(sqlite3_bind_double(m_pStmt,index,dValue)!=SQLITE_OK)
346. {
347. returnFALSE;
348. }
349. returnTRUE;
350. }
352. BOOLSQLiteCommand::BindParam(intindex,constunsignedchar*blobBuf,intnLen)
353. {
354. if(sqlite3_bind_blob(m_pStmt,index,blobBuf,nLen,NULL)!=SQLITE_OK)
355. {
356. returnFALSE;
357. }
358. returnTRUE;
359. }
361. BOOLSQLiteCommand::Excute()
362. {
363. sqlite3_step(m_pStmt);
365. return(sqlite3_reset(m_pStmt)==SQLITE_OK)?TRUE:FALSE;
366. }
368. voidSQLiteCommand::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. voidSqliteOperate()
2. {
3. TCHAR*szDbPath=_T("Book.db");
5. ::DeleteFile(szDbPath);
7. SQLitesqlite;
9. //打开或创建数据库
10. //******************************************************
11. if(!sqlite.Open(szDbPath))
12. {
13. _tprintf(_T("%s\n"),sqlite.GetLastErrorMsg());
14. return;
15. }
16. //******************************************************
18. //创建数据库表
19. //******************************************************
20. TCHARsql[512]={0};
21. _stprintf(sql,_T("%s"),
22. _T("CREATETABLE[Book](")
23. _T("[id]INTEGERNOTNULLPRIMARYKEY,")
24. _T("[name]NVARCHAR(20),")
25. _T("[author]NVARCHAR(20),")
26. _T("[catagory_id]INTEGERREFERENCES[Category]([id]),")
27. _T("[abstruct]NVARCHAR(100),")
28. _T("[path]NVARCHAR(50),")
29. _T("[image]BLOB);")
30. _T("CREATEINDEX[Book_id]ON[Book]([id]);")
31. );
32. if(!sqlite.ExcuteNonQuery(sql))
33. {
34. printf("Createdatabasetablefailed...\n");
35. }
36. //******************************************************
38. //插入数据【普通方式】
39. DWORDdwBeginTick=GetTickCount();
40. //******************************************************
41. //当一次性插入多条记录时候，采用事务的方式，提高效率
42. sqlite.BeginTransaction();
43. //批量插入数据
44. for(inti=0;i<1000;i++)
45. {
46. memset(sql,0,sizeof(sql));
47. _stprintf(sql,_T("insertintoBook(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("InsertDataTake%dMS...\n",GetTickCount()-dwBeginTick);
57. //******************************************************
60. //插入数据【通过参数绑定的方式，提交批量数据时，比上面的普通模式效率更高（提高约45%），同时可支持插入二进制数据】
61. dwBeginTick=GetTickCount();
62. //******************************************************
63. //当一次性插入多条记录时候，采用事务的方式，提高效率
64. sqlite.BeginTransaction();
65. memset(sql,0,sizeof(sql));
66. _stprintf(sql,_T("insertintoBook(name,author,catagory_id,image)values(?,'韩寒',?,?)"));
67. SQLiteCommandcmd(&sqlite,sql);
68. //批量插入数据
69. for(inti=0;i<1000;i++)
70. {
71. TCHARstrValue[16]={0};
72. _stprintf(strValue,_T("他的国%d"),i);
73. //绑定第一个参数（name字段值）
74. cmd.BindParam(1,strValue);
75. //绑定第二个参数（catagory_id字段值）
76. cmd.BindParam(2,20);
77. BYTEimageBuf[]={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("InsertDataTake%dMS...\n",GetTickCount()-dwBeginTick);
91. //******************************************************
93. //查询
94. dwBeginTick=GetTickCount();
95. //******************************************************
96. memset(sql,0,sizeof(sql));
97. _stprintf(sql,_T("%s"),_T("select*fromBookwherename='他的国345'"));
99. SQLiteDataReaderReader=sqlite.ExcuteQuery(sql);
101. intindex=0;
102. intlen=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. constBYTE*ImageBuf=Reader.GetBlobValue(6,len);
113. _tprintf(_T("*******************************************\n"));
114. }
115. Reader.Close();
116. printf("QueryTake%dMS...\n",GetTickCount()-dwBeginTick);
117. //******************************************************
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...