uniapp sqlite 数据库操作封装_uniapp sqlite封装

前言

最近写uniapp，需要本地缓存一些数据，然后发现uniapp提供了原生的sqlite操作。后面我就对操作进行了一些封装。

Sqlite操作文档
这里感谢这篇博客给的想法
uniapp如何使用sqlite数据库

封装好的js文件

module.exports = {
	dbName: 'xxx', // 数据库名称
	dbPath: '_downloads/xxx.db', // 数据库地址,推荐以下划线为开头   _doc/xxx.db

	// 判断数据库是否打开
	isOpen() {
		// 数据库打开了就返回 true,否则返回 false
		var open = plus.sqlite.isOpenDatabase({
			name: this.dbName, // 数据库名称
			path: this.dbPath // 数据库地址
		})
		return open
	},

	// 创建数据库 或 有该数据库就打开
	openSqlite() {
		return new Promise((resolve, reject) => {
			// 打开数据库
			plus.sqlite.openDatabase({
				name: this.dbName,
				path: this.dbPath,
				success(e) {
					resolve(e) // 成功回调
				},
				fail(e) {
					reject(e) // 失败回调
				}
			})
		})
	},

	// 关闭数据库
	closeSqlite() {
		return new Promise((resolve, reject) => {
			plus.sqlite.closeDatabase({
				name: this.dbName,
				success(e) {
					resolve(e)
				},
				fail(e) {
					reject(e)
				}
			})
		})
	},


	// 数据库删表 sql:'DROP TABLE dbTable'
	dropTable(dbTable) {
		return new Promise((resolve, reject) => {
			plus.sqlite.executeSql({
				name: this.dbName,
				sql: `DROP TABLE ${dbTable}`,
				success(e) {
					resolve(e)
				},
				fail(e) {
					reject(e)
				}
			})
		})
	},

	//-----------------------js对象方法，简化操作-------------
	///原生的sql操作
	SqlExecute(sql) {
		return new Promise((resolve, reject) => {
			plus.sqlite.executeSql({
				name: this.dbName,
				sql: sql,
				success(e) {
					resolve(e)
				},
				fail(e) {
					reject(e)
				}
			})
		})
	},
	//执行原生的select语句
	SqlSelect(sql) {
		return new Promise((resolve, reject) => {
			plus.sqlite.selectSql({
				name: this.dbName,
				sql: sql,
				success(e) {
					resolve(e)
				},
				fail(e) {
					reject(e)
				}
			})
		})
	},

	//通过对象创建数据库,使用对象参数,并且默认自带id作为主键
	JsCreateTable(dbTable, data) {
		data = Object.entries(data).map(item => {
			return item[0] + ' ' + item[1]
		}).join(',')


		var sql = `CREATE TABLE IF NOT EXISTS ${dbTable}("id" INTEGER PRIMARY KEY AUTOINCREMENT,${data})`
		return this.SqlExecute(sql)
	},

	//通过对象创建数据库,使用对象的数据类型
	JsCreateTableType(dbTable, data) {
		data = Object.entries(data).map(item => {
			var typeName = ''
			switch (item[1].constructor) {
				case Number:
					if (Math.floor(item[1]) == item[1]) {
						typeName = 'INT'
					} else {
						typeName = 'DOUBLE'
					}
					break
				case String:
					typeName = 'TEXT'
					break
				case Boolean:
					typeName = 'BOOLEAN'
					break
				case Date:
					typeName = 'DATETIME'
					break
			}
			return item[0] + ' ' + typeName
		}).join(',')


		var sql = `CREATE TABLE IF NOT EXISTS ${dbTable}("id" INTEGER PRIMARY KEY AUTOINCREMENT,${data})`
		console.log(sql)
		return this.SqlExecute(sql)
	},
	//通过对象插入数据
	JsInsertTableData(dbTable, data) {
		var condition = []
		var sqlValue = []
		Object.entries(data).forEach(item => {
			condition.push(`'${item[0]}'`)
			if (typeof(item[1] == 'string')) {
				sqlValue.push(`'${item[1]}'`)
			} else {
				sqlValue.push(item[1])
			}
		})
		condition = condition.join(',')
		sqlValue = sqlValue.join(',')
		var sql = `INSERT INTO ${dbTable} (${condition}) VALUES(${sqlValue})`
		return this.SqlExecute(sql)
	},
	//通过对象选择数据
	JsSelectTableData(dbTable, data) {
		var sql = ''
		var condition = []
		Object.entries(data).forEach(item => {
			if (typeof(item[1] == 'string')) {
				condition.push(` ${item[0]} = '${item[1]}' `)
			} else {
				condition.push(` ${item[0]} = ${item[1]} `)
			}
		})
		condition = condition.join('AND')
		sql = `SELECT * FROM ${dbTable} WHERE ${condition}`
		return this.SqlSelect(sql)
	}



}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

示例

///引入对象
import DB from '@/common/utils/sqlHelper.js'

......其它代码省略
SqlBtn() {
	let open = DB.isOpen()
	var data = {
		name: '小王',
		age: 18,
		num:12.458,
		isStudent : true,
		CreateTime: new Date()
	}
	var data2 = { //因为CreateTime插入的时间是现在的时间，没办法完全对应
		name: '小王',
		age: 18,
		num:12.458,
		isStudent : true,
	}
	if (open) {
		// DB.dropTable('person')
		DB.JsCreateTableType('person',data).then(res => {
			console.log(res)
		}).catch(err => {
			console.log(err)
		})
		DB.JsInsertTableData('person',data).then(res => {
			console.log(res)
		}).catch(err => {
			console.log(err)
		})
		DB.JsInsertTableData('person',data).then(res => {
			console.log(res)
		}).catch(err => {
			console.log(err)
		})
		
		DB.JsSelectTableData('person',data2).then(res => {
			console.log(res)
		}).catch(err => {
			console.log(err)
		})
		
		

	} else {
		this.showToast('数据库未打开')
	}

},
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

随便写个按钮触发

<template>
	<view>
		<button @click="SqlBtn">数据库操作</button>
	</view>
</template>

<script src="./index.js">s
	
</script>

<style src="./index.scss" lang="scss">

</style>s
1
2
3
4
5
6
7
8
9
10
11
12
13

打印结果

插入的数据格式

[
    {
        "id": 1,
        "name": "小王",
        "age": 18,
        "num": 12.458,
        "isStudent": "true",
        "CreateTime": "Wed May 10 2023 16:25:21 GMT+0800 (CST)"
    },
    {
        "id": 2,
        "name": "小王",
        "age": 18,
        "num": 12.458,
        "isStudent": "true",
        "CreateTime": "Wed May 10 2023 16:25:21 GMT+0800 (CST)"
    }
]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

注意点：

Sqlite数据库存储的数据格式只有5种，我们定义的格式只是对这个格式进行推荐判断。
sqlite数据库数据类型

这里使用了js的对象遍历Object.entries()。返回key和value组成的二维数组
js对象遍历7中方法