uniapp 实现点击更新数据包

有的时候博客内容会有变动，首发博客是最新的，其他博客地址可能会未同步, 认准 https://blog.zysicyj.top

可点击链接 https://blog-1253652709.cos.ap-guangzhou.myqcloud.com//picgo/202401180921373.png 解答疑问

index.html

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
<template>
	<uni-list :border="true">
		<view v-for="item in list">
			<!-- 显示圆形头像 -->
			<uni-list-chat :avatar-circle="true" :title=item.title
				avatar="https://qiniu-web-assets.dcloud.net.cn/unidoc/zh/unicloudlogo.png" :note=item.note
				:time=item.time></uni-list-chat>
		</view>
		<uni-button @click="fetchData"> 刷新数据 1</uni-button>
	</uni-list>
</template>

<script>
	import DB from '@/pages/common/utils/db/sqllite.js';

	export default {
		components: {

		},
		data() {
			return {
				list: [{
					title: ' 标题 1',
					note: ' 收到消息 1',
					time: '2020-02-02 20:02'
				}, {
					title: ' 标题 2',
					note: ' 收到消息 12',
					time: '2020-03-02 20:02'
				}]
			}
		},
		methods: {
			moveDirecty(oldPath) {
				const newLocalPath = '_doc'
				plus.io.resolveLocalFileSystemURL(newLocalPath, function(entry1) {
					plus.io.resolveLocalFileSystemURL(oldPath, function(entry2) {
						uni.removeSavedFile({
							filePath: DB.dbPath,
							success: function() {
								console.log(' 文件删除成功！')
								entry2.moveTo(entry1, '', function(res) {
									console.log(' 移动成功 ', JSON.stringify(res))
									DB.openSqlite().then((res) => {
										// 查询表 DB.selectTableData(表名, 查询条件列名, 查询条件列值)
										DB.selectTableData("note")
											.then(res => {
												console.log(JSON.stringify(
													res))
												this.list = res;
											})
											.catch(error => {
												console.log(JSON.stringify(
													error))
											});
									})
								}, function(e) {
									DB.openSqlite().then((res) => {
										// 查询表 DB.selectTableData(表名, 查询条件列名, 查询条件列值)
										DB.selectTableData("note")
											.then(res => {
												console.log(JSON.stringify(
													res))
												this.list = res;
											})
											.catch(error => {
												console.log(JSON.stringify(
													error))
											});
									})
									console.log(' 内层移动失败 ' + JSON.stringify(
										e))
								})
							}
						})
					}, function(e) {
						console.log(' 移动失败 ' + JSON.stringify(e))
					})
				}, function(e) {
					console.log(' 外层操作失败 ' + JSON.stringify(e))
				})

			},
			fetchData() {
				uni.downloadFile({
					url: 'https://blog-1253652709.cos.ap-guangzhou.myqcloud.com/tmp/test.db', // 仅为示例，并非真实的资源 
					success: async (res) => {
						if (res.statusCode === 200) {
							console.log(JSON.stringify(res));
							await DB.closeSqlite()
							this.moveDirecty(res.tempFilePath)
						}
					}
				});
			}
		},
		onLoad() {
			let open = DB.isOpen();
			if (!open) {
				DB.openSqlite().then((res) => {
					// 查询表 DB.selectTableData(表名, 查询条件列名, 查询条件列值)
					DB.selectTableData("note")
						.then(res => {
							console.log(JSON.stringify(res))
							this.list = res;
						})
						.catch(error => {
							console.log(JSON.stringify(error))
						});
				})
			} else {
				// 查询表 DB.selectTableData(表名, 查询条件列名, 查询条件列值)
				DB.selectTableData("note")
					.then(res => {
						console.log(JSON.stringify(res))
						this.list = res;
					})
					.catch(error => {
						console.log(JSON.stringify(error))
					});
			}

		}
	}
</script>

<style>
	.chat-custom-right {
		flex: 1;
		/* #ifndef APP-NVUE */
		display: flex;
		/* #endif */
		flex-direction: column;
		justify-content: space-between;
		align-items: flex-end;
	}

	.chat-custom-text {
		font-size: 12px;
		color: #999;
	}
</style>

sqlite.js

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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
module.exports = {
	dbName: 'main', // 数据库名称 
	dbPath: '_doc/test.db', // 数据库地址, 推荐以下划线为开头   _doc/xxx.db

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

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

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

	// 数据库建表 sql:'CREATE TABLE IF NOT EXISTS dbTable("id" varchar(50),"name" TEXT) 
	// 创建 CREATE TABLE IF NOT EXISTS 、 dbTable 是表名，不能用数字开头、括号里是表格的表头 
	createTable(dbTable, data) {
		return new Promise((resolve, reject) => {
			// executeSql: 执行增删改等操作的 SQL 语句 
			plus.sqlite.executeSql({
				name: this.dbName,
				sql: `CREATE TABLE IF NOT EXISTS ${dbTable}(${data})`,
				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);
				}
			})
		})
	},

	// 向表格里添加数据 sql:'INSERT INTO dbTable VALUES('x','x','x')'   对应新增 
	// 或者 sql:'INSERT INTO dbTable ('x','x','x') VALUES('x','x','x')'   具体新增 
	// 插入 INSERT INTO  、 dbTable 是表名、根据表头列名插入列值 
	insertTableData(dbTable, data, condition) {
		// 判断有没有传参 
		if (dbTable !== undefined && data !== undefined) {
			// 判断传的参是否有值 
			var bol = (JSON.stringify(data) == "{}");
			if (!bol) {
				if (condition == undefined) {
					var sql = `INSERT INTO ${dbTable} VALUES('${data}')`;
				} else {
					var sql = `INSERT INTO ${dbTable} (${condition}) VALUES(${data})`;
				}
				// console.log(sql);
				return new Promise((resolve, reject) => {
					// 表格添加数据 
					plus.sqlite.executeSql({
						name: this.dbName,
						sql: sql,
						success(e) {
							resolve(e);
						},
						fail(e) {
							reject(e);
						}
					})
				})
			} else {
				return new Promise((resolve, reject) => {
					reject(" 错误添加 ")
				})
			}
		} else {
			return new Promise((resolve, reject) => {
				reject(" 错误添加 ")
			})
		}
	},

	// 根据条件向表格里添加数据  有数据更新、无数据插入 
	// (建表时需要设置主键) 例如 --- "roomid" varchar(50) PRIMARY KEY
	insertOrReplaceData(dbTable, data, condition) {
		// 判断有没有传参 
		if (dbTable !== undefined && data !== undefined) {
			if (condition == undefined) {
				var sql = `INSERT OR REPLACE INTO ${dbTable} VALUES('${data}')`;
			} else {
				var sql = `INSERT OR REPLACE INTO ${dbTable} (${condition}) VALUES(${data})`;
			}
			// console.log(sql);
			return new Promise((resolve, reject) => {
				// 表格添加数据 
				plus.sqlite.executeSql({
					name: this.dbName,
					sql: sql,
					success(e) {
						resolve(e);
					},
					fail(e) {
						reject(e);
					}
				})
			})
		} else {
			return new Promise((resolve, reject) => {
				reject(" 错误添加 ")
			})
		}
	},

	// 查询获取数据库里的数据 sql:'SELECT * FROM dbTable WHERE lname = 'lvalue''
	// 查询 SELECT * FROM 、 dbTable 是表名、 WHERE 查找条件 lname,lvalue 是查询条件的列名和列值 
	selectTableData(dbTable, uname, namevalue, upass, passvalue, urrn, rrnvalue) {
		if (dbTable !== undefined) {
			// 第一个是表单名称，后两个参数是列表名，用来检索 
			if (uname !== undefined && upass !== undefined && urrn !== undefined) {
				// 三个检索条件 
				var sql =
					`SELECT * FROM ${dbTable} WHERE ${uname} = '${namevalue}' AND ${upass} = '${passvalue}' AND ${urrn}='${rrnvalue}'`;
			}
			if (uname !== undefined && upass !== undefined && urrn == undefined) {
				// 两个检索条件 
				var sql = `SELECT * FROM ${dbTable} WHERE ${uname} = '${namevalue}' AND ${upass} = '${passvalue}'`;
			}
			if (uname !== undefined && upass == undefined && urrn == undefined) {
				// 一个检索条件 
				var sql = `SELECT * FROM ${dbTable} WHERE ${uname} = '${namevalue}'`;
				// console.log(sql);
			}
			if (uname == undefined) {
				var sql = `SELECT * FROM ${dbTable}`;
			}
			return new Promise((resolve, reject) => {
				// 表格查询数据  执行查询的 SQL 语句 
				plus.sqlite.selectSql({
					name: this.dbName,
					sql: sql,
					success(e) {
						resolve(e);
					},
					fail(e) {
						reject(e);
					}
				})
			})
		} else {
			return new Promise((resolve, reject) => {
				reject(" 错误查询 ")
			});
		}
	},

	// 删除表里的数据 sql:'DELETE FROM dbTable WHERE lname = 'lvalue''
	// 删除 DELETE FROM 、 dbTable 是表名、 WHERE 查找条件 lname,lvalue 是查询条件的列名和列值 
	deleteTableData(dbTable, lname, lvalue, ww, ee) {
		if (dbTable !== undefined) {
			if (lname == undefined) {
				var sql = `DELETE FROM ${dbTable}`;
			} else {
				if (ww !== undefined) {
					// 两个检索条件 
					var sql = `DELETE FROM ${dbTable} WHERE ${lname} = '${lvalue}' AND ${ww} = '${ee}'`;
				} else {
					// 一个检索条件 
					var sql = `DELETE FROM ${dbTable} WHERE ${lname} = '${lvalue}'`;
				}
			}
			return new Promise((resolve, reject) => {
				// 删除表数据 
				plus.sqlite.executeSql({
					name: this.dbName,
					sql: sql,
					success(e) {
						resolve(e);
					},
					fail(e) {
						reject(e);
					}
				})
			})
		} else {
			return new Promise((resolve, reject) => {
				reject(" 错误删除 ")
			});
		}
	},

	// 修改数据表里的数据 sql:"UPDATE dbTable SET 列名 = ' 列值 ', 列名 = ' 列值 ' WHERE lname = 'lvalue'"
	// 修改 UPDATE 、 dbTable 是表名, data: 要修改的列名 = 修改后列值, lname,lvalue 是查询条件的列名和列值 
	updateTableData(dbTable, data, lname, lvalue) {
		if (lname == undefined) {
			var sql = `UPDATE ${dbTable} SET ${data}`;
		} else {
			var sql = `UPDATE ${dbTable} SET ${data} WHERE ${lname} = '${lvalue}'`;
		}
		// WHERE 前面是要修改的列名、列值，后面是条件的列名、列值 
		return new Promise((resolve, reject) => {
			// 修改表数据 
			plus.sqlite.executeSql({
				name: this.dbName,
				sql: sql,
				success(e) {
					resolve(e);
				},
				fail(e) {
					reject(e);
				}
			})
		})
	},

	// 获取指定数据条数  sql:"SELECT * FROM dbTable ORDER BY 'id' DESC LIMIT 15 OFFSET 'num'"
	// dbTable 表名, ORDER BY 代表排序默认正序, id 是排序的条件 DESC 代表倒序，从最后一条数据开始拿 
	// LIMIT 15 OFFSET '${num}', 这句的意思是跳过 num 条拿 15 条数据, num 为跳过多少条数据是动态值 
	// 例 初始 num 设为 0，就从最后的数据开始拿 15 条，下次不拿刚获取的数据，所以可以让 num 为 15，这样就能一步一步的拿完所有的数据 
	pullSQL(dbTable, id, num) {
		return new Promise((resolve, reject) => {
			plus.sqlite.selectSql({
				name: this.dbName,
				sql: `SELECT * FROM ${dbTable} ORDER BY '${id}' DESC LIMIT 15 OFFSET '${num}'`,
				success(e) {
					resolve(e);
				},
				fail(e) {
					reject(e);
				}
			})
		})
	}
}