uniapp sqlLite 数据库操作封装 2：如何面向对象操作数据库
前言
我个人是比较爱鼓捣的一个人，原本是写后端的，但是小公司，没办法，我也会写前端的一些东西。这里说一下我是怎么封装sqlLite数据库和如何写业务逻辑代码的。
Sqlite操作文档
这里感谢这篇博客给的想法
uniapp如何使用sqlite数据库
uniapp sqlite 数据库操作封装
使用ORM的思想来封装sql操作
什么是ORM?
ORM，即Object-Relational Mapping（对象关系映射），它的作用是在关系型数据库和业务实体对象之间作一个映射，这样，我们在具体的操作业务对象的时候，就不需要再去和复杂的SQL语句打交道，只需简单的操作对象的属性和方法。
注意：由于是对实体对象的操作，所以删和改操作必须在查操作之后，查到了东西才能删改
模拟ORM数据库操作
添加
去除
修改
查询
1.查
ORM对象
数据库名称
数据表名称
数据库操作
对象实体
数据库sql语句
数据库
增
2.删
2.改
简单来说我们都是通过一个对象实体来生成对应的sql语句
比如如下
//数据库设计
person{
id:主键,自增
name:姓名
age:年龄
sex:性别
}
//添加
ORM.Insert(new person(){
name :"小王",
age:15
})//添加一个name：小王，age：15，sex=null的数据
//删除
ORM.Delete(new person(){
name:"小王",
id:14
})//删除一个name是小王，id是14的数据
ORM.Select(new person(){
name:"小王",
id:14
})//查询一个name是小王，id是14的数据
//只有修改是最特殊的,将id视为唯一不变的
ORM.Update(new person(){
name:"小王",
id:14
})//id是14的数据的name修改成小王
使用ORM的思想对sqlList封装操作
SqlHelper.js（包含原生操作和封装操作）
module.exports = {
dbName: 'Bluetooth', // 数据库名称
dbPath: '_downloads/Bluetooth.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) {
console.log(`DROP TABLE ${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) {
console.log(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) {
console.log(sql)
return new Promise((resolve, reject) => {
plus.sqlite.selectSql({
name: this.dbName,
sql: sql,
success(e) {
resolve(e)
},
fail(e) {
reject(e)
}
})
})
},
//通过对象创建数据库,使用对象参数
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 (item[1] != undefined) {
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 (item[1] != undefined && item[0] != 'id') {
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)
},
//通过对象获取
JsUpdate(dbTable, data) {
// console.log(data)
var sql = ''
var condition = []
Object.entries(data).forEach(item => {
if (item[1] != undefined && item[0] != 'id') {
if (typeof(item[1] == 'string')) {
condition.push(` ${item[0]} = '${item[1]}' `)
} else {
condition.push(` ${item[0]} = ${item[1]} `)
}
}
})
condition = condition.join(',')
sql = `UPDATE ${dbTable} SET ${condition} where id = ${data.id}`
return this.SqlExecute(sql)
}
}
这里使用了js的一些语法，async和await，常用的一些迭代器：map,forEach,entries。这里不清楚的话可以先用着，或者看我别的一些文章
uniapp sqlite 数据库操作封装
js 使用 async和await，简单的写setTimeout
PS：所有的数据库操作都是异步操作，一定要会异步操作的使用方法
如何使用面向对象的思想操作数据库
简单来说就是把同一类事物抽象成一个实体。如果不知道如何封装js代码可以看这篇文章。
js 如何定义类和引用
这里我写一下我的测试样例
//这个是上面封装的数据库操作
const SqlHelper = require('@/utils/SqlHelper.js')
//这个是数据库的实体对象
var t_data = {
name: '姓名',
age: 15,
sex: '男'
}
module.exports = {
dtName :'SqlTest',
GetModel(){
return t_data
},
IsOpen(){
if(!SqlHelper.isOpen()){
SqlHelper.openSqlite()
}
return SqlHelper.isOpen()
},
Init(){
this.IsOpen()
return SqlHelper.JsCreateTableType(this.dtName,t_data)
},
Insert(data){
this.IsOpen()
return SqlHelper.JsInsertTableData(this.dtName,data)
},
Select(data){
this.IsOpen()
return SqlHelper.JsSelectTableData(this.dtName,data)
},
Update(data){
this.IsOpen()
return SqlHelper.JsUpdate(this.dtName,data)
}
}
随便一个按钮去绑定这个事件
async function action(){
if(SqlTest.IsOpen()){
console.log('数据库已打开')
SqlTest.Init()
console.log(1)
var data = SqlTest.GetModel()
data.id = 1
console.log(3)
SqlTest.Select(data).then(res=>{
console.log(res)
}).catch(err=>{
console.log(err)
})
data.id = 1
SqlTest.Select(data).then(res=>{
console.log(res)
}).catch(err=>{
console.log(err)
})
data.name = '新名字'
console.log(data)
SqlTest.Update(data).then(res=>{
console.log(res)
}).catch(err=>{
console.log(err)
})
SqlTest.Select(data).then(res=>{
console.log(res)
}).catch(err=>{
console.log(err)
})
}
}
action()
结果展示，这里我已经插入了一些数据了。这里我封装的时候把所有执行的sql操作都会打印，如果sql语句出现问题也可以看到
15:32:10.411 数据库已打开 at pages/index/index.js:133
15:32:10.415 CREATE TABLE IF NOT EXISTS SqlTest("id" INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT,age INT,sex TEXT) at utils/SqlHelper.js:138
15:32:10.417 CREATE TABLE IF NOT EXISTS SqlTest("id" INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT,age INT,sex TEXT) at utils/SqlHelper.js:69
15:32:10.420 [Number] 1 at pages/index/index.js:135
15:32:10.421 [Number] 3 at pages/index/index.js:138
15:32:10.425 SELECT * FROM SqlTest WHERE name = '姓名' AND age = '15' AND sex = '男' at utils/SqlHelper.js:85
15:32:10.435 SELECT * FROM SqlTest WHERE name = '姓名' AND age = '15' AND sex = '男' at utils/SqlHelper.js:85
15:32:10.437 [Object] {"name":"新名字","age":15,"sex":"男","id":1} at pages/index/index.js:151
15:32:10.440 UPDATE SqlTest SET name = '新名字' , age = '15' , sex = '男' where id = 1 at utils/SqlHelper.js:69
15:32:10.450 SELECT * FROM SqlTest WHERE name = '新名字' AND age = '15' AND sex = '男' at utils/SqlHelper.js:85
15:32:10.521 [Object] [{"id":1,"name":"姓名","age":15,"sex":"男"},{"id":2,"name":"姓名","age":15,"sex":"男"},{"id":4,"n...} at pages/index/index.js:140
15:32:10.523 [Object] [{"id":1,"name":"姓名","age":15,"sex":"男"},{"id":2,"name":"姓名","age":15,"sex":"男"},{"id":4,"n...} at pages/index/index.js:146
15:32:10.525 [Object] {} at pages/index/index.js:154
15:32:10.527 [Object] [{"id":1,"name":"新名字","age":15,"sex":"男"},{"id":3,"name":"新名字","age":15,"sex":"男"}] at pages/index/index.js:159