openharmony开发最新4.0版本---数据库连接（二）(基于api10,devstudio4.0) 中relationalStore的使用

这篇具有很好参考价值的文章主要介绍了openharmony开发最新4.0版本---数据库连接（二）(基于api10,devstudio4.0) 中relationalStore的使用。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

如下代码是一个工具类,可以自己导入到自己项目中，在入口文件中初始化即可使用，使用示例放在下节中

import relationalStore from '@ohos.data.relationalStore'
import common from '@ohos.app.ability.common';
import { BusinessError } from '@ohos.base';
import { ValuesBucket, ValueType } from '@ohos.data.ValuesBucket';

const TAG: string = '[RDBUtil]'

class RDBUtil {
private context: common.UIAbilityContext | undefined = undefined
// 存储已创建的RdbStore
private rdbMap = new Map<string,relationalStore.RdbStore>()
private currentRDB: string = 'default'

init(context: common.UIAbilityContext) {
this.context = context
}

/**
* 创建数据库/获取连接
* @param rdbName
* @param config
* @returns
*/
async createRDB(rdbName: string, config ?: relationalStore.StoreConfig): Promise<relationalStore.RdbStore> {
let promise: Promise<relationalStore.RdbStore> = new Promise(async (resolve, reject) => {
if (!this.context) {
console.error(TAG, ' (init) ERROR => Context 未获取')
reject(TAG + ' (init) ERROR => Context 未获取')
}
this.currentRDB = rdbName
const STORE_CONFIG: relationalStore.StoreConfig = config ? config : {name: rdbName, securityLevel: 1}
try {
let rdb = this.rdbMap.get(rdbName)
if (!rdb) {
rdb = await relationalStore.getRdbStore(this.context, STORE_CONFIG)
this.rdbMap.set(rdbName, rdb)
}
console.info(TAG, ` (createRDB) SUCCESS TO CREATE: ${rdbName} => 创建连接成功`)
resolve(rdb)
} catch (err) {
let code = (err as BusinessError).code
let message = (err as BusinessError).message
console.error(TAG, ` (createRDB) FAIL TO CREATE: ${rdbName} => code: ${code}, message: ${message}`)
reject(err as BusinessError)
}
})
return promise
}

/**
* 获取/切换 RDB数据库
* @param rdbName
* @returns RdbStore
*/
async getConnection(rdbName: string): Promise<relationalStore.RdbStore> {
try {
this.currentRDB = rdbName
let rdb = this.rdbMap.get(rdbName)
if (!rdb) {
console.error(TAG, ` (getConnection) FAIL TO GET => ${this.currentRDB} RDB连接不存在重新创建`)
rdb = await this.createRDB(rdbName)
}
console.info(TAG, ` (getConnection) SUCCESS TO GET => ${this.currentRDB} RDB连接获取成功`)
return Promise.resolve(rdb)
} catch (err) {
let code = (err as BusinessError).code
let message = (err as BusinessError).message
console.error(TAG, ` (getConnection) FAIL TO GET: ${this.currentRDB} => code: ${code}, message: ${message}`)
return Promise.reject(err as BusinessError)
}
}

/**
* 插入对象
* @param tableName
* @param obj
* @returns
*/
async insert <T> (tableName: string, obj: T): Promise<number> {
try {
// 默认使用最近一次连接
let rdb = this.rdbMap.get(this.currentRDB)
if (!rdb) {
console.error(TAG, ` (insert) FAIL TO INSERT => ${this.currentRDB} 未获取RDB连接`)
return Promise.reject(TAG + ` (insert) FAIL TO INSERT => ${this.currentRDB} 未获取RDB连接`)
}
let value: ValuesBucket = this.obj2ValueBucket <T> (obj)
let insertNum: number = await rdb.insert(tableName, value)
console.info(TAG, ` (insert) SUCCESS TO INSERT => ${this.currentRDB} ${tableName} INSERT ${insertNum}`)
return Promise.resolve(insertNum)
} catch (err) {
let code = (err as BusinessError).code
let message = (err as BusinessError).message
console.error(TAG, ` (insert) FAIL TO INSERT: ${this.currentRDB} => code: ${code}, message: ${message}`)
return Promise.reject(err as BusinessError)
}
}

/**
* 批量插入数组
* @param tableName
* @param arr
* @returns 插入成功数量
*/
async batchInsert <T> (tableName: string, arr: T[]): Promise<number> {
try {
// 默认使用最近一次连接
let rdb = this.rdbMap.get(this.currentRDB)
let values: ValuesBucket[] = this.array2ValueBuckets <T> (arr)
if (!rdb) {
console.error(TAG, ` (batchInsert) FAIL TO BATCHINSERT => ${this.currentRDB} 未获取RDB连接`)
return Promise.reject(TAG + ` (batchInsert) FAIL TO BATCHINSERT => ${this.currentRDB} 未获取RDB连接`)
}
let insertNum: number = await rdb.batchInsert(tableName, values)
console.info(TAG, ` (batchInsert) SUCCESS TO BATCHINSERT => ${this.currentRDB} ${tableName} BATCHINSERT ${insertNum}}`)
return Promise.resolve(insertNum)
} catch (err) {
let code = (err as BusinessError).code
let message = (err as BusinessError).message
console.error(TAG, ` (batchInsert) FAIL TO BATCHINSERT: ${this.currentRDB} => code: ${code}, message: ${message}`)
return Promise.reject(err as BusinessError)
}
}

/**
* 查询
* @param tableName
* @param id
* @param columns
* @returns 对象
*/
async queryById <T> (tableName: string, id: number|string, columns ?: Array<string>): Promise<T> {
try {
// 默认使用最近一次连接
let rdb = this.rdbMap.get(this.currentRDB)
if (!rdb) {
console.error(TAG, ` (queryById) FAIL TO QUERY => ${this.currentRDB} 未获取RDB连接`)
return Promise.reject(TAG + ` (queryById) FAIL TO QUERY => ${this.currentRDB} 未获取RDB连接`)
}
let predicates = new relationalStore.RdbPredicates(tableName)
predicates.equalTo('id', id)
let resultSet: relationalStore.ResultSet
if (columns) {
resultSet = await rdb.query(predicates, columns)
} else {
resultSet = await rdb.query(predicates)
}
let arr: T[] = this.resultSet2Array <T> (resultSet)
resultSet.close()
if (arr.length == 0) {
console.error(TAG, ` (queryById) FAIL TO QUERY => 该表未查询到数据`)
return Promise.reject(null)
}
console.info(TAG, ` (queryById) SUCCESS TO QUERY => ${JSON.stringify(arr)}`)
return Promise.resolve(arr[0])
} catch (err) {
let code = (err as BusinessError).code
let message = (err as BusinessError).message
console.error(TAG, ` (queryById) FAIL TO QUERY: ${this.currentRDB} => code: ${code}, message: ${message}`)
return Promise.reject(err as BusinessError)
}
}

/**
* 批量查询
* @param predicates
* @param columns
* @returns 所有数据 => 数组
*/
async queryArray <T> (predicates: relationalStore.RdbPredicates, columns ?: Array<string>): Promise<T[]> {
try {
// 默认使用最近一次连接
let rdb = this.rdbMap.get(this.currentRDB)
if (!rdb) {
console.error(TAG, ` (queryArray) FAIL TO QUERY => ${this.currentRDB} 未获取RDB连接`)
return Promise.reject(TAG + ` (queryArray) FAIL TO QUERY => ${this.currentRDB} 未获取RDB连接`)
}
let resultSet: relationalStore.ResultSet
if (columns) {
resultSet = await rdb.query(predicates, columns)
} else {
resultSet = await rdb.query(predicates)
}
let arr: T[] = this.resultSet2Array <T> (resultSet)
resultSet.close()
if (arr.length == 0) {
console.error(TAG, ` (queryArray) FAIL TO QUERY => 该表未查询到数据`)
return Promise.resolve(arr)
}
console.info(TAG, ` (queryArray) SUCCESS TO QUERY => ${JSON.stringify(arr)}`)
return Promise.resolve(arr)
} catch (err) {
let code = (err as BusinessError).code
let message = (err as BusinessError).message
console.error(TAG, ` (queryArray) FAIL TO QUERY: ${this.currentRDB} => code: ${code}, message: ${message}`)
return Promise.reject(err as BusinessError)
}
}

/**
* 更新数据
* @param obj
* @param predicates
* @returns 更新数量
*/
async update <T> (obj: T, predicates: relationalStore.RdbPredicates): Promise<number> {
try {
// 默认使用最近一次连接
let rdb = this.rdbMap.get(this.currentRDB)
if (!rdb) {
console.error(TAG, ` (update) FAIL TO UPDATE => ${this.currentRDB} 未获取RDB连接`)
return Promise.reject(TAG + ` (update) FAIL TO UPDATE => ${this.currentRDB} 未获取RDB连接`)
}
let value = this.obj2ValueBucket <T>(obj)
let updateNum = await rdb.update(value, predicates)
console.info(TAG, ` (update) SUCCESS TO UPDATE => ${this.currentRDB} UPDATE ${updateNum}}`)
return Promise.resolve(updateNum)
} catch (err) {
let code = (err as BusinessError).code
let message = (err as BusinessError).message
console.error(TAG, ` (update) FAIL TO UPDATE: ${this.currentRDB} => code: ${code}, message: ${message}`)
return Promise.reject(err as BusinessError)
}
}

/**
* 更新数据 ById
* @param obj
* @param predicates
* @returns 成功更新数量
*/
async updateById <T> (tableName: string, id: number|string, obj: T): Promise<number> {
try {
let value = this.obj2ValueBucket <T>(obj)
let predicates = new relationalStore.RdbPredicates(tableName)
predicates.equalTo('id', id)
let updateNum = await this.update(value, predicates)
console.info(TAG, ` (updateById) SUCCESS TO UPDATE => ${this.currentRDB} UPDATE ${updateNum}}`)
return Promise.resolve(updateNum)
} catch (err) {
let code = (err as BusinessError).code
let message = (err as BusinessError).message
console.error(TAG, ` (updateById) FAIL TO UPDATE: ${this.currentRDB} => code: ${code}, message: ${message}`)
return Promise.reject(err as BusinessError)
}
}

/**
* 删除数据
* @param obj
* @param predicates
* @returns 删除数量
*/
async delete(predicates: relationalStore.RdbPredicates) :Promise<number> {
try {
// 默认使用最近一次连接
let rdb = this.rdbMap.get(this.currentRDB)
if (!rdb) {
console.error(TAG, ` (delete) FAIL TO DELETE => ${this.currentRDB} 未获取RDB连接`)
return Promise.reject(TAG + ` (update) FAIL TO DELETE => ${this.currentRDB} 未获取RDB连接`)
}
let deleteNum = await rdb.delete(predicates)
console.info(TAG, ` (delete) SUCCESS TO DELETE => ${this.currentRDB} DELETE ${deleteNum}}`)
return Promise.resolve(deleteNum)
} catch (err) {
let code = (err as BusinessError).code
let message = (err as BusinessError).message
console.error(TAG, ` (delete) FAIL TO DELETE: ${this.currentRDB} => code: ${code}, message: ${message}`)
return Promise.reject(err as BusinessError)
}
}

/**
* 删除数据 ById
* @param obj
* @param predicates
* @returns 成功删除数量
*/
async deleteById(tableName: string, id: number|string) :Promise<number> {
try {
let predicates = new relationalStore.RdbPredicates(tableName)
predicates.equalTo('id', id)
let deleteNum = await this.delete(predicates)
console.info(TAG, ` (deleteById) SUCCESS TO DELETE => ${this.currentRDB} DELETE ${deleteNum}}`)
return Promise.resolve(deleteNum)
} catch (err) {
let code = (err as BusinessError).code
let message = (err as BusinessError).message
console.error(TAG, ` (deleteById) FAIL TO DELETE: ${this.currentRDB} => code: ${code}, message: ${message}`)
return Promise.reject(err as BusinessError)
}
}

/**
* ResultSet => Array
* @param resultSet
* @returns 数组
*/
private resultSet2Array <T> (resultSet: relationalStore.ResultSet) : Array<T> {
let arr: T[] = []
if (resultSet.rowCount == 0 || resultSet.columnCount == 0){
console.error(TAG, ` (resultSet2Array) FAIL TO TRANSFER: ${this.currentRDB} => resultSet 为 null`)
return []
}
resultSet.goToFirstRow()
let str : string = '{'
do {
for (let index = 0; index < resultSet.columnCount; index++) {
str += `"${resultSet.getColumnName(index)}":"${resultSet.getString(index)}"`
if (index != resultSet.columnCount - 1) {
str += ','
}
}
str +='}'
let obj: T = JSON.parse(str)
arr.push(obj)
console.log(JSON.stringify(obj))
str = '{'
} while (resultSet.goToNextRow())
return arr
}

/**
* Object => ValueBucket
* @param arr
* @returns ValueBucket
*/
private obj2ValueBucket <T> (obj: T) {
let valuesBucket: ValuesBucket = {}
// 获取对象属性/成员变量
let keys: string[] = Object.keys(obj)
for (let key of keys) {
// 获取键值对
let value: ValueType = obj[key]
// 将键值对添加到ValuesBucket对象中
valuesBucket[key] = value
}
return valuesBucket
}

/**
* Array => ValueBucket[]
* @param arr
* @returns ValueBucket[]
*/
private array2ValueBuckets <T> (arr: Array<T>) {
let valuesBuckets: ValuesBucket[] = []
// 遍历对象集合
for (let obj of arr) {
valuesBuckets.push(this.obj2ValueBucket <T> (obj))
}
// 返回ValuesBucket对象
return valuesBuckets
}
}

export let rdbUtil: RDBUtil = new RDBUtil()
文章来源地址https://www.toymoban.com/news/detail-799901.html

到了这里，关于openharmony开发最新4.0版本---数据库连接（二）(基于api10,devstudio4.0) 中relationalStore的使用的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！